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

Deploys Bitbucket Environment

const {
  create_env,
  create_var,
  delete_env,
  get_envs,
  get_env,
  get_vars,
  exchangeToken,
} = 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 (e) {
        console.error(e.message);
      }
    } else {
      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);
        }
      }
    }
  } 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_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);
};

module.exports = {
  guarded_create_var,
  guarded_create_env,
  guarded_delete_env,
  guarded_get_envs,
  guarded_get_vars,
  guarded_get_env,
};