bitbucket-env-manager/src/guarded.api.js

Deploys Bitbucket Environment

const {
  create_env,
  create_var,
  delete_env,
  delete_var,
  get_envs,
  get_env,
  get_vars,
  exchangeToken,
  get_repo_vars,
  create_repo_var,
  delete_repo_var,
} = require('./api');
const { getTokensFromFile, getOauthFromEnv } = require('./helpers');
const { saveTokensFileRootOrWspace } = require('./helpers');
const { runLogin } = require('./login');

const authGuard = async (func, workspace) => {
  let tokens;
  try {
    tokens = getTokensFromFile(workspace);
    const resp = await func({ access_token: tokens.access_token });
    return resp;
  } catch (e) {
    console.error(e.message);
    if (e.message.match('401')) {
      console.log('Token Expired...');
      console.log('Exchanging Token...');
      try {
        const oauth = getOauthFromEnv(workspace);
        const resp = await exchangeToken({
          secret: oauth.OAUTH_SECRET,
          client: oauth.OAUTH_CLIENT,
          refresh_token: tokens.refresh_token,
        });
        saveTokensFileRootOrWspace(resp, workspace);

        console.log('Retrying api call..');
        const newtokens = getTokensFromFile(workspace);
        return await func({ access_token: newtokens.access_token });
      } catch (exchangeError) {
        console.error('Token exchange failed:', exchangeError.message);
        console.log('Refresh token expired, attempting fresh login...');
      }
    }

    // Fall through to login if not 401, or if token exchange failed
    try {
      await runLogin(workspace);
      const newtokens = getTokensFromFile(workspace);
      return await func({ access_token: newtokens.access_token });
    } catch (e) {
      console.error(e.message);
      try {
        console.log('--- trying root credentials login ---');
        await runLogin();
        const newtokens = getTokensFromFile();
        return await func({ access_token: newtokens.access_token });
      } catch (e) {
        console.error(e.message);
        throw new Error('Authentication failed: All login attempts exhausted');
      }
    }
  } finally {
  }
};

const guarded_create_env = ({
  env_name,
  env_rank, // 0,1,2
  workspace,
  repo_slug,
  env_config,
}) => {
  const func = ({ access_token }) => {
    return create_env({
      env_name,
      env_rank, // 0,1,2
      workspace,
      repo_slug,
      access_token,
      env_config,
    });
  };
  return authGuard(func, workspace);
};

const guarded_create_var = ({
  environment_uuid,
  workspace,
  repo_slug,
  var_key,
  var_value,
  var_secured,
}) => {
  const func = ({ access_token }) => {
    return create_var({
      environment_uuid,
      access_token,
      workspace,
      repo_slug,
      var_key,
      var_value,
      var_secured,
    });
  };
  return authGuard(func, workspace);
};
const guarded_delete_env = ({ environment_uuid, workspace, repo_slug }) => {
  const func = ({ access_token }) => {
    return delete_env({
      environment_uuid,
      access_token,
      workspace,
      repo_slug,
    });
  };
  return authGuard(func, workspace);
};

const guarded_delete_var = ({ environment_uuid, variable_uuid, workspace, repo_slug }) => {
  const func = ({ access_token }) => {
    return delete_var({
      environment_uuid,
      variable_uuid,
      access_token,
      workspace,
      repo_slug,
    });
  };
  return authGuard(func, workspace);
};

const guarded_get_envs = ({ workspace, repo_slug }) => {
  const func = ({ access_token }) => {
    return get_envs({
      workspace,
      repo_slug,
      access_token,
    });
  };
  return authGuard(func, workspace);
};

const guarded_get_env = ({ environment_uuid, workspace, repo_slug }) => {
  const func = ({ access_token }) => {
    return get_env({
      environment_uuid,
      access_token,
      workspace,
      repo_slug,
    });
  };
  return authGuard(func, workspace);
};

const guarded_get_vars = ({ workspace, repo_slug, environment_uuid, page, pagelen }) => {
  const func = ({ access_token }) => {
    return get_vars({
      access_token,
      workspace,
      repo_slug,
      environment_uuid,
      page,
      pagelen,
    });
  };
  return authGuard(func, workspace);
};

const guarded_get_repo_vars = ({ workspace, repo_slug, page, pagelen }) => {
  const func = ({ access_token }) => {
    return get_repo_vars({
      access_token,
      workspace,
      repo_slug,
      page,
      pagelen,
    });
  };
  return authGuard(func, workspace);
};

const guarded_create_repo_var = ({ workspace, repo_slug, var_key, var_value, var_secured }) => {
  const func = ({ access_token }) => {
    return create_repo_var({
      access_token,
      workspace,
      repo_slug,
      var_key,
      var_value,
      var_secured,
    });
  };
  return authGuard(func, workspace);
};

const guarded_delete_repo_var = ({ workspace, repo_slug, variable_uuid }) => {
  const func = ({ access_token }) => {
    return delete_repo_var({
      access_token,
      workspace,
      repo_slug,
      variable_uuid,
    });
  };
  return authGuard(func, workspace);
};

module.exports = {
  guarded_create_var,
  guarded_create_env,
  guarded_delete_env,
  guarded_delete_var,
  guarded_get_envs,
  guarded_get_vars,
  guarded_get_env,
  guarded_get_repo_vars,
  guarded_create_repo_var,
  guarded_delete_repo_var,
};