@leverege/build-tools 2.99.0 → 2.99.2-quinn.1

package/lib/server/build-tools.js

@@ -0,0 +1,138 @@
+#!/usr/bin/env node
+"use strict";
+
+const fs = require('node:fs');
+const path = require('node:path');
+const chalk = require('chalk');
+const cliArgs = require('command-line-args');
+const cliHelp = require('command-line-usage');
+const npmRegistryFetch = require('npm-registry-fetch');
+const semverLt = require('semver/functions/lt');
+
+/* eslint-disable no-console */
+
+const optionList = [
+// Use optionList to tie into the Usage statements
+{
+  name: 'root',
+  type: Boolean,
+  default: false,
+  description: 'returns the root of the build-tools installation'
+}, {
+  name: 'latest',
+  type: Boolean,
+  default: false,
+  description: 'verifies the latest build-tools are installed'
+}, {
+  name: 'bashfun',
+  type: Boolean,
+  default: false,
+  description: 'source the output to define common bash helper functions'
+}, {
+  name: 'reporoot',
+  type: Boolean,
+  default: false,
+  description: 'the root of the build-tools repo - for finding other config files'
+}, {
+  name: 'help',
+  type: Boolean,
+  default: false,
+  description: 'display this help screen'
+}, {
+  name: 'version',
+  type: Boolean,
+  default: false,
+  description: 'returns the build-tools repo version'
+}, {
+  name: 'verbose',
+  alias: 'v',
+  type: Boolean,
+  default: false,
+  description: 'emit additional info at run time'
+}];
+const sections = [{
+  header: 'A collection of build / support tools for all Leverege code',
+  content: `README: {green https://bitbucket.org/leverege/build-tools/src/development}
+`
+}, {
+  header: 'Options',
+  optionList
+}];
+const args = cliArgs(optionList, {
+  partial: true
+});
+const help = cliHelp(sections);
+const repoRoot = path.dirname(__dirname);
+const thisPackage = require(`${repoRoot}/package.json`);
+const thisVersion = thisPackage.version;
+if (args.root) {
+  console.log(repoRoot);
+  process.exit(0);
+}
+if (args.bashfun) {
+  console.log(`${repoRoot}/src/bash-funcs`);
+  process.exit(0);
+}
+if (args.reporoot) {
+  console.log(`${repoRoot}`);
+  process.exit(0);
+}
+const checkForLatest = async (pkg = '@leverege/build-tools') => {
+  const getToken = () => {
+    const tokenFile = `${process.env.HOME}/.npmrc`;
+    if (!fs.existsSync(tokenFile)) {
+      console.error(`Cannot find token file ${tokenFile}`);
+      process.exit(1);
+    }
+    try {
+      const tokenLine = fs.readFileSync(tokenFile).toString();
+      const tokenRegX = new RegExp('.*registry.npmjs.org\\/:\\w+=+(.*)');
+      const tokenStr = tokenLine.match(tokenRegX);
+      if (!tokenStr) {
+        console.error(`\n***ERROR: malformed npm token in ${tokenFile}\n`);
+        process.exit(1);
+      }
+      return tokenLine.match(tokenRegX)[1];
+    } catch (err) {
+      console.error(err);
+    }
+  };
+  try {
+    const list = await npmRegistryFetch.json(pkg, {
+      '//registry.npmjs.org/:_authToken': getToken()
+    });
+    return list['dist-tags'].latest;
+  } catch (err) {
+    console.log(err);
+  }
+};
+const checkAndAnnounce = () => {
+  checkForLatest().then(latestVersion => {
+    if (semverLt(thisVersion, latestVersion)) {
+      console.log(chalk.white`
+  Update available ${chalk.grey(thisVersion)} \u2b62 ${chalk.green(latestVersion)}
+  Run ${chalk.cyan('npm i -g @leverege/build-tools')} to update
+`);
+      process.exit(1);
+    } else {
+      process.exit(0);
+    }
+  }).catch(err => {});
+};
+if (args.latest) {
+  checkAndAnnounce();
+}
+if (args.version) {
+  console.log(`build-tools version ${thisVersion}`);
+  checkAndAnnounce();
+}
+if (args.help) {
+  console.log(help);
+  process.exit(0);
+}
+
+/* eslint-disable no-underscore-dangle */
+if (args._unknown) {
+  console.log(`\nUnrecognized argument [${args._unknown}] try --help\n`);
+  process.exit(1);
+}

package/lib/server/firebaseDeploy.js

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+/* eslint-disable no-console */
+// https://github.com/google/zx
+/* eslint-disable max-len */
+"use strict";
+
+var _enquirer = _interopRequireDefault(require("enquirer"));
+var _ansiColors = _interopRequireDefault(require("ansi-colors"));
+var _zx = require("zx");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  prompt
+} = _enquirer.default;
+
+// This will preserve coloration from spawned child processes
+process.env.FORCE_COLORS = 3;
+process.env.FORCE_COLOR = '1';
+let TARGET;
+let CHANNEL;
+
+// A single unnamed parameter is assumed to be a deploy target.
+// If named parameters exist, they may not be stored in argv,
+// so don't look for a larger length of argv to decide whether to look for named paramters
+if (_zx.argv._.length === 1) {
+  TARGET = _zx.argv._[0];
+} else {
+  TARGET = _zx.argv.target;
+  if (_zx.argv.channelName) {
+    CHANNEL = {};
+    CHANNEL.name = _zx.argv.channelName;
+    CHANNEL.expiration = _zx.argv.channelExpiration ?? '7d';
+  }
+}
+
+// If target has not been defined on the command line,
+// then enter interactive mode
+const INTERACTIVE_MODE = !TARGET;
+let exited = false;
+const SECRETS_DIR = 'secrets';
+const EXIT_EVENTS = ['SIGINT', 'exit', 'uncaughException', 'unhandledRejection'];
+const [firebaserc, firebaseJson, gitBranch] = await Promise.all([_zx.fs.exists(_zx.path.join(process.cwd(), '.firebaserc')), _zx.fs.exists(_zx.path.join(process.cwd(), 'firebase.json')), (0, _zx.$)`git rev-parse --abbrev-ref HEAD -C ${process.cwd()}`.then(({
+  stdout
+}) => {
+  return stdout.split('\n')[0];
+})]);
+if (!firebaserc) {
+  console.log(_zx.chalk.red('No .firebaserc file found. Make sure that you are executing firebaseDeploy from within a firebase project directory.'));
+}
+if (!firebaseJson) {
+  console.log(_zx.chalk.red('No firebase.json file found. Make sure that you are executing firebaseDeploy from within a firebase project directory.'));
+}
+if (!firebaserc || !firebaseJson) {
+  process.exit();
+}
+const firebasercContent = JSON.parse(await _zx.fs.readFile(_zx.path.join(process.cwd(), '.firebaserc'), {
+  encoding: 'utf-8'
+}));
+let maxSiteIdLength = 0;
+const targets = Object.entries(firebasercContent.targets).reduce((prev, [projectId, config]) => {
+  Object.entries(config.hosting).forEach(([siteId, aliases]) => {
+    aliases.forEach(alias => {
+      // Store the longest length of site id for formatting later on
+      maxSiteIdLength = Math.max(siteId.length, maxSiteIdLength);
+      prev[alias] = {
+        projectId,
+        siteId,
+        alias,
+        production: config.production
+      };
+    });
+  });
+  return prev;
+}, {});
+if (INTERACTIVE_MODE) {
+  const {
+    targetEnv
+  } = await prompt([{
+    type: 'autocomplete',
+    name: 'targetEnv',
+    message: 'To which environment would you like to deploy?',
+    choices: Object.values(targets).map(t => {
+      const productionLabel = t.production ? _ansiColors.default.bold.red('--PRODUCTION--') : '';
+      return {
+        message: `${_ansiColors.default.bold.cyan('Site: ')}${t.siteId.padEnd(maxSiteIdLength)} ${_ansiColors.default.bold.green('Project: ')}${t.projectId} ${productionLabel}`,
+        value: t.alias
+      };
+    })
+  }]);
+  TARGET = targets[targetEnv];
+  if (TARGET.production) {
+    const {
+      confirmProductionDeploy
+    } = await prompt([{
+      type: 'confirm',
+      name: 'confirmProductionDeploy',
+      message: `${_ansiColors.default.bold.red('WARNING: ')} This is a ${_ansiColors.default.bold.yellow('PRODUCTION')} environment. Are you sure you want to deploy here?`
+    }]);
+    if (!confirmProductionDeploy) {
+      console.log('Cancelling deployment...');
+      process.exit();
+    }
+  }
+  const {
+    useChannel
+  } = await prompt([{
+    type: 'confirm',
+    name: 'useChannel',
+    message: 'Do you want to deploy to a temporary preview channel?'
+  }]);
+  if (useChannel) {
+    const {
+      channelName,
+      channelExpiration
+    } = await prompt([{
+      type: 'input',
+      name: 'channelName',
+      message: 'To which channel would you like to deploy?',
+      initial: gitBranch ?? 'temp-deploy'
+    }, {
+      type: 'input',
+      name: 'channelExpiration',
+      message: 'When should the channel expire?',
+      initial: '7d'
+    }]);
+    CHANNEL = {
+      name: channelName,
+      expiration: channelExpiration
+    };
+  }
+} else {
+  TARGET = targets[TARGET];
+}
+if (!TARGET) {
+  console.log(_zx.chalk.red('No such target exists in .firebaserc config.'));
+  process.exit();
+}
+const [aliasFileExists, siteIdFileExists, sharedFileExists] = await Promise.all([_zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.alias}.env`)), _zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.siteId}.env`)), _zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, 'shared.env'))]);
+if (!aliasFileExists && !siteIdFileExists) {
+  console.log(_zx.chalk.red(`No env file for ${TARGET.alias} exists. Check your secrets directory and try again`));
+  process.exit();
+}
+const exec = [];
+if (sharedFileExists) {
+  exec.push(_zx.fs.readFile(_zx.path.join(process.cwd(), SECRETS_DIR, 'shared.env'), {
+    encoding: 'utf-8'
+  }));
+}
+if (aliasFileExists) {
+  exec.push(_zx.fs.readFile(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.alias}.env`), {
+    encoding: 'utf-8'
+  }));
+} else {
+  exec.push(_zx.fs.readFile(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.siteId}.env`), {
+    encoding: 'utf-8'
+  }));
+}
+console.log(`\n\n\n${_ansiColors.default.bold.green('====== Deployment Summary ======')}`);
+console.log(`${_ansiColors.default.blue('Firebase project:')} ${TARGET.projectId} ${TARGET.production ? _ansiColors.default.yellow('--PRODUCTION--') : ''}`);
+console.log(`${_ansiColors.default.blue('Site ID:')} ${TARGET.siteId}`);
+console.log(`${_ansiColors.default.blue('Channel Name:')} ${CHANNEL?.name ?? _ansiColors.default.italic.gray('(none)')}`);
+console.log(`${_ansiColors.default.blue('Channel Expiration date:')} ${CHANNEL?.name ? CHANNEL.expiration ?? _ansiColors.default.italic.gray('(none)') : _ansiColors.default.italic.gray('(n/a)')}`);
+console.log(`${_ansiColors.default.blue('Shared .env file:')} ${sharedFileExists ? `${SECRETS_DIR}/shared.env` : _ansiColors.default.italic.gray('(none)')}`);
+console.log(`${_ansiColors.default.blue('Additional .env overrides:')} ${aliasFileExists ? `${SECRETS_DIR}/${TARGET.alias}.env` : `${SECRETS_DIR}/${TARGET.siteId}.env`}`);
+console.log(`${_ansiColors.default.bold.green('===============================')}`);
+if (INTERACTIVE_MODE) {
+  const {
+    confirmSelections
+  } = await prompt([{
+    type: 'confirm',
+    name: 'confirmSelections',
+    message: 'Proceed with this deployment?'
+  }]);
+  if (!confirmSelections) {
+    console.log('Cancelling deployment...');
+    process.exit();
+  }
+}
+const envFileContent = (await Promise.all(exec)).join('\n');
+EXIT_EVENTS.forEach(event => {
+  process.on(event, () => {
+    if (!exited) {
+      exited = true;
+      _zx.fs.removeSync(_zx.path.join(process.cwd(), '.env.temp'));
+    }
+  });
+});
+await _zx.fs.writeFile(_zx.path.join(process.cwd(), '.env.temp'), envFileContent);
+try {
+  // deploying to a channel requires slightly different parameter structure 
+  const deployType = CHANNEL ? `hosting:channel:deploy ${CHANNEL.name} ${CHANNEL.expiration ? `--expires ${CHANNEL.expiration}` : ''}`.split(' ') : 'deploy';
+  const hostingPrefix = CHANNEL ? '' : 'hosting:';
+  await (0, _zx.$)`npm run clean && DOTENV_CONFIG_PATH=${_zx.path.join(process.cwd(), '.env.temp')} DEPLOYMENT_TARGET=${TARGET.siteId} npm run build && firebase use ${TARGET.projectId} && firebase ${deployType} --only ${hostingPrefix}${TARGET.siteId}`;
+} catch (err) {
+  console.error(err);
+}

package/lib/server/firebaseServe.js

@@ -0,0 +1,116 @@
+#!/usr/bin/env node
+// https://github.com/google/zx
+/* eslint-disable max-len */
+/* eslint-disable no-console */
+"use strict";
+
+var _enquirer = _interopRequireDefault(require("enquirer"));
+var _zx = require("zx");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  prompt
+} = _enquirer.default;
+
+// This will preserve coloration from spawned child processes
+process.env.FORCE_COLORS = 3;
+process.env.FORCE_COLOR = '1';
+let TARGET = _zx.argv._[0];
+let exited = false;
+const SECRETS_DIR = 'secrets';
+const EXIT_EVENTS = ['SIGINT', 'exit', 'uncaughtException', 'unhandledRejection'];
+const [firebaserc, firebaseJson, hasLocalConfig] = await Promise.all([_zx.fs.exists(_zx.path.join(process.cwd(), '.firebaserc')), _zx.fs.exists(_zx.path.join(process.cwd(), 'firebase.json')), _zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, 'local.env'))]);
+if (!hasLocalConfig) {
+  if (!firebaserc) {
+    console.log(_zx.chalk.red('No .firebaserc file found. Make sure that you are executing firebaseDeploy from within a firebase project directory.'));
+  }
+  if (!firebaseJson) {
+    console.log(_zx.chalk.red('No firebase.json file found. Make sure that you are executing firebaseDeploy from within a firebase project directory.'));
+  }
+  if (!firebaserc || !firebaseJson) {
+    process.exit();
+  }
+}
+const firebasercContent = firebaserc ? JSON.parse(await _zx.fs.readFile(_zx.path.join(process.cwd(), '.firebaserc'), {
+  encoding: 'utf-8'
+})) : {
+  targets: {}
+};
+const defaultTargets = {};
+if (hasLocalConfig) {
+  defaultTargets.local = {
+    siteId: 'local',
+    alias: 'local'
+  };
+}
+const targets = Object.entries(firebasercContent.targets).reduce((prev, [projectId, config]) => {
+  Object.entries(config.hosting).forEach(([siteId, aliases]) => {
+    aliases.forEach(alias => {
+      prev[alias] = {
+        projectId,
+        siteId,
+        alias
+      };
+    });
+  });
+  return prev;
+}, defaultTargets);
+if (!TARGET) {
+  const choices = Object.keys(targets).map(t => ({
+    name: t,
+    value: t
+  }));
+  let targetEnv;
+  if (choices.length > 1) {
+    const res = await prompt({
+      type: 'autocomplete',
+      name: 'targetEnv',
+      message: 'Which environment would you like to serve?',
+      choices
+    });
+    targetEnv = res.targetEnv;
+  } else {
+    targetEnv = choices[0].value;
+  }
+  TARGET = targets[targetEnv];
+} else {
+  TARGET = targets[TARGET];
+}
+if (!TARGET) {
+  console.log(_zx.chalk.red('No such target exists in .firebaserc config.'));
+  process.exit();
+}
+const [aliasFileExists, siteIdFileExists, sharedFileExists] = await Promise.all([_zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.alias}.env`)), _zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.siteId}.env`)), _zx.fs.exists(_zx.path.join(process.cwd(), SECRETS_DIR, 'shared.env'))]);
+if (!aliasFileExists && !siteIdFileExists) {
+  console.log(_zx.chalk.red(`No env file for ${TARGET.alias} exists. Check your secrets directory and try again`));
+  process.exit();
+}
+const exec = [];
+if (sharedFileExists) {
+  exec.push(_zx.fs.readFile(_zx.path.join(process.cwd(), SECRETS_DIR, 'shared.env'), {
+    encoding: 'utf-8'
+  }));
+}
+if (aliasFileExists) {
+  exec.push(_zx.fs.readFile(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.alias}.env`), {
+    encoding: 'utf-8'
+  }));
+} else {
+  exec.push(_zx.fs.readFile(_zx.path.join(process.cwd(), SECRETS_DIR, `${TARGET.siteId}.env`), {
+    encoding: 'utf-8'
+  }));
+}
+const envFileContent = (await Promise.all(exec)).join('\n');
+EXIT_EVENTS.forEach(event => {
+  process.on(event, () => {
+    if (!exited) {
+      exited = true;
+      _zx.fs.removeSync(_zx.path.join(process.cwd(), '.env.temp'));
+    }
+  });
+});
+await _zx.fs.writeFile(_zx.path.join(process.cwd(), '.env.temp'), envFileContent);
+try {
+  await (0, _zx.$)`DOTENV_CONFIG_PATH=${_zx.path.join(process.cwd(), '.env.temp')} DEPLOYMENT_TARGET=${TARGET.siteId} npm run serve --colors`;
+} catch (err) {
+  console.error(err);
+}

package/lib/server/getfbcfg.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+
+/**
+ * This script parses a firebase config into something useful.
+ *
+ * firebase --project leverege-dev-john apps:sdkconfig | getfbcfg
+ */
+"use strict";
+
+const stdbuf = [];
+
+/* eslint-disable no-console */
+process.stdin.on('data', d => {
+  stdbuf.push(d);
+}).on('end', () => {
+  const rawCfg = stdbuf.join('').replace(/["\n\r]/g, '');
+  const keyVals = rawCfg.match(/\{(.*)\}/)[1].split(',');
+  const lastLine = keyVals.length - 1;
+  console.log('{');
+  for (let i = 0; i <= lastLine; i++) {
+    const kv = keyVals[i].trim().split(' ');
+    console.log(`  "${kv[0].replace(/:/, '')}": "${kv[1]}"${i < lastLine ? ',' : ''}`);
+  }
+  console.log('}');
+}).setEncoding('utf8');

package/lib/server/getjson.js

@@ -0,0 +1,70 @@
+#!/usr/bin/env node
+
+/**
+ * This script will allow the user to grab a value from a JSON file and
+ * optionally apply a regular expression to it. Given this test.json file:
+ * 
+ * {
+ *   "name": "@leverege/packagename",
+ *   "main": "lib/index.js"
+ * }
+ *
+ * and invoking as:
+ *   ./getjson --file ./test.json --key name --regex "^@\w{3}"
+ *
+ * will yield an output of: @lev
+ */
+
+/**
+ * Get a command line switch parser.
+ */
+"use strict";
+
+var _fs = _interopRequireDefault(require("fs"));
+var _commandLineArgs = _interopRequireDefault(require("command-line-args"));
+var _commandLineUsage = _interopRequireDefault(require("command-line-usage"));
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-console */
+const optionList = [
+// Use optionList to tie into the Usage statements
+{
+  name: 'file',
+  type: String,
+  alias: 'f',
+  description: 'file to parse JSON from'
+}, {
+  name: 'key',
+  type: String,
+  alias: 'k',
+  description: 'JSON key whose value to grab'
+}, {
+  name: 'regex',
+  type: String,
+  alias: 'r',
+  description: 'regular expression to apply to the value'
+}];
+const sections = [{
+  header: 'JSON variable fetching script',
+  content: `  This script is intended to give shell scripts a simple JSON
+  parsing capability.`
+}, {
+  header: 'Options',
+  optionList
+}];
+const args = (0, _commandLineArgs.default)(optionList, {
+  partial: true
+});
+const help = (0, _commandLineUsage.default)(sections);
+if (!args.file) {
+  console.error('\n***ERROR: Missing a --file param\n');
+  console.log(help);
+  process.exit(1);
+}
+try {
+  const json = JSON.parse(_fs.default.readFileSync(args.file, 'utf8'));
+  const value = json[args.key];
+  const match = new RegExp(args.regex || '.*').exec(value);
+  console.log(match ? match[match.length - 1] : '');
+} catch (e) {
+  console.log(e);
+}