bitbucket-env-manager/src/helpers.js

Deploys Bitbucket Environment

const dotenv = require('dotenv');
const fs = require('fs-extra');
const { paths } = require('./config');

const prettyJson = (jsonString) => JSON.stringify(JSON.parse(jsonString), null, 2);
const prettyPrintJson = (jsonString) => console.log(prettyJson(jsonString));
const delay = (ms) => {
  return new Promise((resolve) =>
    setTimeout(() => {
      resolve(0);
    }, ms)
  );
};
function capitalizeFirstLetter(string) {
  return string.charAt(0).toUpperCase() + string.slice(1);
}

function _getTokensFromFile(workspace) {
  const tokensPath = paths.tokensFile(workspace);
  if (!fs.existsSync(tokensPath)) {
    throw new Error(`No ${workspace ? workspace + '_' : ''}tokens.json file detected.`);
  }
  const imp = fs.readFileSync(tokensPath, { encoding: `utf-8` });
  const tokens = JSON.parse(imp);

  if (!tokens.access_token) {
    throw new Error(`No access_token in ${workspace ? workspace + '_' : ''}tokens.json.`);
  }
  return tokens;
}

function getTokensFromFile(workspace) {
  try {
    const tokens = _getTokensFromFile(workspace);
    return tokens;
  } catch (e1) {
    try {
      const rootTokens = _getTokensFromFile();
      return rootTokens;
    } catch (e2) {
      throw new Error(e1.message + ' and ' + e2.message);
      //ignore error2?
    }
  }
}

function _getOauthFromEnv(workspace) {
  const envPath = paths.envFile(workspace);

  if (!fs.existsSync(envPath)) {
    throw new Error(`No ${workspace}.env file detected`);
  }

  const result = dotenv.config({ path: envPath });
  if (result.error) {
    throw result.error;
  }

  const parsed = result.parsed;
  if (!parsed.OAUTH_CLIENT) {
    throw new Error('Missing OAUTH_CLIENT');
  }
  if (!parsed.OAUTH_SECRET) {
    throw new Error('Missing OAUTH_SECRET');
  }
  return parsed;
}

function getOauthFromEnv(workspace) {
  try {
    const parsed = _getOauthFromEnv(workspace);
    return parsed;
  } catch (e1) {
    try {
      const rootParsed = _getOauthFromEnv();
      return rootParsed;
    } catch (e2) {
      throw new Error(e1.message + ' and ' + e2.message);
      //ignore error2?
    }
  }
}

const saveTokensFileRootOrWspace = (resp, workspace = '') => {
  if (!resp) {
    throw new Error('Invalid resp');
  }

  const envPathPerWorkspace = paths.envFile(workspace);
  if (fs.existsSync(envPathPerWorkspace)) {
    // save to workspace tokens file
    fs.outputFileSync(paths.tokensFile(workspace), resp);
  } else {
    // save to root tokens file
    fs.outputFileSync(paths.tokensFile(), resp);
  }
};

const saveOauthEnvFile = ({ OAUTH_CLIENT, OAUTH_SECRET, WORKSPACE }) => {
  if (!OAUTH_CLIENT) {
    throw new Error('No OAUTH_CLIENT');
  }

  if (!OAUTH_SECRET) {
    throw new Error('No OAUTH_SECRET');
  }

  if (!WORKSPACE) {
    throw new Error('No WORKSPACE');
  }

  fs.outputFileSync(
    paths.envFile(WORKSPACE),
    `OAUTH_CLIENT=${OAUTH_CLIENT}
OAUTH_SECRET=${OAUTH_SECRET}
          `
  );
};

module.exports = {
  prettyJson,
  delay,
  prettyPrintJson,
  capitalizeFirstLetter,
  getTokensFromFile,
  getOauthFromEnv,
  saveTokensFileRootOrWspace,
  saveOauthEnvFile,
};