@leverege/build-tools 2.96.7 → 2.96.8

package/lib/web/tag-release.js

@@ -0,0 +1,681 @@
+#!/usr/bin/env node
+/* eslint-disable security/detect-unsafe-regex */
+/* eslint-disable no-console */
+/* eslint-disable max-len */
+"use strict";
+
+var _nodePath = _interopRequireDefault(require("node:path"));
+var _commandLineArgs = _interopRequireDefault(require("command-line-args"));
+var _commandLineUsage = _interopRequireDefault(require("command-line-usage"));
+var _zx = require("zx");
+var _enquirer = _interopRequireDefault(require("enquirer"));
+var _ansiColors = _interopRequireDefault(require("ansi-colors"));
+var _readPkg = require("read-pkg");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+const {
+  prompt
+} = _enquirer.default;
+const NPMJS_TAGS = {
+  ALPHA: 'alpha',
+  BETA: 'beta',
+  LATEST: 'latest'
+};
+const DEFAULT_PACKAGES_PATH = './packages/*';
+
+/**
+ * Functions
+ */
+
+const validateVersionArg = ({
+  args
+}) => {
+  if (!args.version) {
+    return;
+  }
+  const isValid = /^\d+\.\d+\.\d+(-[a-zA-Z]+\.\d+)?$/.test(args.version);
+  if (!isValid) {
+    console.log(`
+${_ansiColors.default.bold.red('ERROR:')} Invalid version arg: ${_ansiColors.default.bold.yellow(args.version)}.
+Use SemVer specs (e.g: ${_ansiColors.default.bold.yellow('2.25.5-beta.1')}).
+`);
+    process.exit(1);
+  }
+};
+const validateNpmjsTag = ({
+  args,
+  config
+}) => {
+  const npmjsTags = Object.values(NPMJS_TAGS);
+  if (args['npmjs-tag'] && !npmjsTags.includes(args['npmjs-tag'])) {
+    console.log(`
+${_ansiColors.default.bold.red('ERROR:')} Invalid npmjs tag: ${_ansiColors.default.bold.yellow(args['npmjs-tag'])}.
+Possible values: ${_ansiColors.default.bold.yellow(npmjsTags.join(', '))}.
+`);
+    process.exit(1);
+  }
+  if ((config?.isBetaRelease === true || args?.version?.includes('-beta.')) && args['npmjs-tag'] === NPMJS_TAGS.LATEST) {
+    console.log(`
+${_ansiColors.default.bold.red('ERROR:')} It's not possible to publish a beta release to npmjs with tag ${_ansiColors.default.bold.yellow('latest')}.
+  `);
+    process.exit(1);
+  }
+};
+const validateArgs = args => {
+  validateVersionArg({
+    args
+  });
+  validateNpmjsTag({
+    args
+  });
+};
+const getCurrentBranch = async () => {
+  const {
+    stdout
+  } = await (0, _zx.$)`git branch --show-current`.nothrow().quiet();
+  return stdout.split('\n')[0];
+};
+const getLatestBranches = async ({
+  n = 10,
+  branchFilter
+}) => {
+  const grepFilter = branchFilter || '';
+  const {
+    stdout
+  } = await (0, _zx.$)`git branch -r --sort=-committerdate --format "%(refname:lstrip=3)" | grep "${grepFilter}"`.nothrow().quiet();
+  const branches = stdout.split('\n').slice(0, -1).filter(branch => branch !== 'HEAD');
+  return branches.slice(0, n);
+};
+const promptForBranch = async (latestBranches, currentBranch) => {
+  if (latestBranches.length === 0) {
+    console.log(`
+${_ansiColors.default.bold.red('ERROR:')} Could not find git branches.
+`);
+    process.exit(1);
+  }
+  const {
+    branch
+  } = await prompt({
+    type: 'select',
+    name: 'branch',
+    message: 'Which branch would you like to release?',
+    choices: latestBranches.map(option => ({
+      value: option
+    })),
+    initial: currentBranch
+  });
+  return branch;
+};
+const getBranch = async branchFilter => {
+  const currentBranch = await getCurrentBranch();
+  const latestBranches = await getLatestBranches(branchFilter);
+  return promptForBranch(latestBranches, currentBranch);
+};
+const getGitRootDirectory = async () => {
+  const {
+    stdout
+  } = await (0, _zx.$)`git rev-parse --show-toplevel`.quiet();
+  return stdout.split('\n')[0];
+};
+const getSubDirectories = async (repositoryRoot, directory) => {
+  const absolutePathDirectory = _nodePath.default.join(repositoryRoot, directory);
+  const relativeDirectory = _nodePath.default.relative(repositoryRoot, absolutePathDirectory);
+  try {
+    const entries = await _zx.fs.promises.readdir(absolutePathDirectory, {
+      withFileTypes: true
+    });
+    const subDirectories = entries.filter(entry => entry.isDirectory());
+    return subDirectories.map(entry => _nodePath.default.join(relativeDirectory, entry.name));
+  } catch (err) {
+    return [];
+  }
+};
+const fileExists = async filePath => {
+  try {
+    await _zx.fs.promises.access(filePath);
+    return true;
+  } catch (err) {
+    return false;
+  }
+};
+const findPackagesInDirectories = async (repositoryRoot, directories) => {
+  return directories.reduce(async (accPromise, directory) => {
+    const acc = await accPromise;
+    const hasWildcard = directory.endsWith('*');
+    const basePath = hasWildcard ? directory.slice(0, -1) : directory;
+    const directoriesToSearch = hasWildcard ? await getSubDirectories(repositoryRoot, basePath) : [basePath];
+    for (let i = 0; i < directoriesToSearch.length; i++) {
+      const currentDirectory = directoriesToSearch[i];
+      const pkgPath = _nodePath.default.join(directoriesToSearch[i], 'package.json');
+      const pkgExists = await fileExists(_nodePath.default.join(repositoryRoot, pkgPath)); // eslint-disable-line no-await-in-loop
+      if (pkgExists) {
+        acc.push(currentDirectory);
+      }
+    }
+    return acc;
+  }, Promise.resolve([]));
+};
+const getMonorepoPackagePaths = async (repositoryRoot, packagesPath) => {
+  let pkg;
+  try {
+    pkg = await (0, _readPkg.readPackage)({
+      cwd: repositoryRoot
+    });
+  } catch (err) {}
+  return findPackagesInDirectories(repositoryRoot, pkg?.workspaces || [packagesPath]);
+};
+const selectPackageToUpdate = async (repositoryRoot, packagePaths) => {
+  const currentPath = process.cwd();
+  const currentPackageRelativePath = _nodePath.default.relative(repositoryRoot, currentPath);
+  const {
+    packageName
+  } = await prompt({
+    type: 'select',
+    name: 'packageName',
+    message: 'What package are you releasing?',
+    choices: packagePaths,
+    initial: currentPackageRelativePath
+  });
+  return _nodePath.default.join(repositoryRoot, packageName);
+};
+const getPackagePath = async ({
+  repositoryRoot,
+  packagesPath = DEFAULT_PACKAGES_PATH
+}) => {
+  const packagePaths = await getMonorepoPackagePaths(repositoryRoot, packagesPath);
+  if (packagePaths.length > 0) {
+    return selectPackageToUpdate(repositoryRoot, packagePaths);
+  }
+  return repositoryRoot;
+};
+const checkoutToBranch = async ({
+  branch
+}) => {
+  try {
+    await (0, _zx.$)`git checkout ${branch}`;
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const getPackageJsonVersion = async packagePath => {
+  if (!packagePath) {
+    console.log(`
+${_ansiColors.default.bold.red('ERROR:')} Could not find a package.json file.
+The tag-release script must run from a npm project.
+  `);
+    return process.exit(1);
+  }
+  const packageJson = await (0, _readPkg.readPackage)({
+    cwd: packagePath
+  });
+  return packageJson.version;
+};
+const getNextVersions = currentVersion => {
+  const regex = /^(\d+)(?:\.(\d+))?(?:\.(\d+))?(?:-(\w+)\.(\d+))?$/i;
+  const [, dirtyMajor, dirtyMinor, dirtyPatch, testTag, dirtyTestVersion] = currentVersion.match(regex);
+  const major = parseInt(dirtyMajor);
+  const minor = parseInt(dirtyMinor) || 0;
+  const patch = parseInt(dirtyPatch) || 0;
+  const testVersion = parseInt(dirtyTestVersion) || 0;
+  const nextMajor = `${major + 1}.0.0`;
+  const nextMinor = `${major}.${minor + 1}.0`;
+  const nextPatch = `${major}.${minor}.${patch + 1}`;
+  const nextAlpha = testTag === 'alpha' ? `${major}.${minor}.${patch}-alpha.${testVersion + 1}` : `${major}.${minor}.${patch + 1}-alpha.1`;
+  const nextBeta = testTag === 'beta' ? `${major}.${minor}.${patch}-beta.${testVersion + 1}` : `${major}.${minor}.${patch + 1}-beta.1`;
+  const nextTestTag = testTag && !['alpha', 'beta'].includes(testTag) ? `${major}.${minor}.${patch}-${testTag}.${testVersion + 1}` : null;
+  return {
+    nextMajor,
+    nextMinor,
+    nextPatch,
+    nextAlpha,
+    nextBeta,
+    nextTestTag,
+    testTag
+  };
+};
+const promptForVersion = async currentVersion => {
+  const {
+    nextMajor,
+    nextMinor,
+    nextPatch,
+    nextAlpha,
+    nextBeta,
+    nextTestTag,
+    testTag
+  } = getNextVersions(currentVersion);
+  const choices = [{
+    hint: '(major release)',
+    value: nextMajor
+  }, {
+    hint: '(minor release)',
+    value: nextMinor
+  }, {
+    hint: '(patch release)',
+    value: nextPatch
+  }, {
+    hint: '(alpha release)',
+    value: nextAlpha
+  }, {
+    hint: '(beta release)',
+    value: nextBeta
+  }, ...(nextTestTag ? [{
+    hint: `(${testTag} release)`,
+    value: nextTestTag
+  }] : []), {
+    hint: '(current version)',
+    value: currentVersion
+  }, {
+    value: 'custom'
+  }];
+  const {
+    version
+  } = await prompt({
+    type: 'select',
+    name: 'version',
+    message: `What version are you releasing (current version is ${currentVersion})?`,
+    choices
+  });
+  if (version === 'custom') {
+    const {
+      customVersion
+    } = await prompt({
+      type: 'input',
+      name: 'customVersion',
+      message: `What custom version are you releasing (current version is ${currentVersion})?`,
+      initial: currentVersion
+    });
+    return customVersion;
+  }
+  return version;
+};
+const getVersion = async ({
+  branch,
+  packagePath
+}) => {
+  const currentVersion = await getPackageJsonVersion(packagePath);
+  return promptForVersion(currentVersion);
+};
+const getPackageName = async ({
+  packagePath
+}) => {
+  const noTrailingSlashPath = packagePath.slice(-1) === '/' ? packagePath.substr(0, packagePath.length - 1) : packagePath;
+  return noTrailingSlashPath.split('/').slice(-1)[0];
+};
+const getBuildMessage = ({
+  isPackageInRepositoryRoot,
+  packageName,
+  version
+}) => {
+  if (isPackageInRepositoryRoot) {
+    return `BUILD v${version}`;
+  }
+  return `BUILD ${packageName}/v${version}`;
+};
+const getGitTagSuffix = async () => {
+  const {
+    tagSuffix
+  } = await prompt({
+    type: 'input',
+    name: 'tagSuffix',
+    message: 'What suffix you like to add to the tag name for git? (e.g: "-RC.1" for v1.2.3-RC.1)'
+  });
+  return tagSuffix;
+};
+const getGitAnnotationMessage = async ({
+  tagName
+}) => {
+  const {
+    annotationMessage
+  } = await prompt({
+    type: 'input',
+    name: 'annotationMessage',
+    message: 'What annotation message would you like to add to git tag?',
+    initial: tagName
+  });
+  return annotationMessage;
+};
+const confirmPushCommit = async buildMessage => {
+  const {
+    confirm
+  } = await prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: `${_ansiColors.default.bold.red('[Warning]')} Commit and push ${_ansiColors.default.bold.yellow(buildMessage)} to git remote?`
+  }]);
+  return confirm;
+};
+const isPackageInRepositoryRoot = async ({
+  repositoryRoot,
+  packagePath
+}) => {
+  return repositoryRoot === packagePath;
+};
+const promptForNpmjsTag = async ({
+  isBetaRelease
+}) => {
+  const choices = Object.values(NPMJS_TAGS).map(option => ({
+    value: option,
+    ...(isBetaRelease && option === NPMJS_TAGS.LATEST && {
+      disabled: '(not available for beta releases)'
+    })
+  }));
+  const {
+    npmjsTag
+  } = await prompt({
+    type: 'select',
+    name: 'npmjsTag',
+    message: 'Which npmjs tag would you like to use when publishing?',
+    choices,
+    initial: isBetaRelease ? NPMJS_TAGS.BETA : NPMJS_TAGS.LATEST
+  });
+  return npmjsTag;
+};
+const confirmTagRelease = async ({
+  isBetaRelease,
+  publishable
+}) => {
+  const message = ['Releasing will commit', isBetaRelease ? ' and push' : ', push, and tag', ' the version in git', publishable ? ' and npm' : '', '. Proceed?'].join('');
+  const {
+    confirmResponse
+  } = await prompt({
+    type: 'select',
+    name: 'confirmResponse',
+    message,
+    choices: ['yes', 'no', 'advanced'],
+    initial: 'yes'
+  });
+  if (confirmResponse === 'no') {
+    console.log('Aborting...');
+    process.exit();
+  }
+  return confirmResponse;
+};
+const isWorkspacePackage = async () => {
+  const gitRootDirectory = await getGitRootDirectory();
+  try {
+    const packageJson = await (0, _readPkg.readPackage)({
+      cwd: gitRootDirectory
+    });
+    return packageJson?.workspaces?.length > 0;
+  } catch (err) {
+    return false;
+  }
+};
+const updateNpmPackageJsonAndLock = async config => {
+  const {
+    version,
+    packagePath,
+    isPackageInRepositoryRoot
+  } = config;
+  const isWorkspace = await isWorkspacePackage();
+  try {
+    if (!isPackageInRepositoryRoot) {
+      await (0, _zx.$)`npm version --no-git-tag-version ${version} --prefix ${packagePath}`.quiet().nothrow();
+      if (isWorkspace) {
+        await (0, _zx.$)`npm install`;
+      } else {
+        await (0, _zx.$)`npm install --prefix ${packagePath}`;
+      }
+    } else {
+      await (0, _zx.$)`npm version --no-git-tag-version ${version}`.quiet().nothrow();
+    }
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const createNewBuildCommit = async ({
+  buildMessage
+}) => {
+  try {
+    await (0, _zx.$)`git add .`;
+    await (0, _zx.$)`git commit --allow-empty -m ${buildMessage}`;
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const pushToGitRemote = async () => {
+  try {
+    await (0, _zx.$)`git push`;
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const commitAndPushNewBuild = async config => {
+  const {
+    buildMessage,
+    noConfirm
+  } = config;
+  const confirmAnswer = noConfirm || (await confirmPushCommit(buildMessage));
+  if (!confirmAnswer) {
+    console.log('Aborting...');
+    process.exit();
+  }
+  await updateNpmPackageJsonAndLock(config);
+  await createNewBuildCommit(config);
+  await pushToGitRemote();
+};
+const confirmPushTag = async (tagName, annotationMessage) => {
+  const {
+    confirm
+  } = await prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: `${_ansiColors.default.bold.red('[Warning]')} Push new tag ${_ansiColors.default.bold.yellow(tagName)} with annotation message "${_ansiColors.default.bold.yellow(annotationMessage)}" to git remote?`
+  }]);
+  return confirm;
+};
+const createGitTag = async (tagName, annotationMessage) => {
+  try {
+    await (0, _zx.$)`git tag -a ${tagName} -m "${annotationMessage}"`;
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const pushGitTag = async tagName => {
+  try {
+    await (0, _zx.$)`git push origin ${tagName}`;
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const createAndPushGitTag = async ({
+  tagName,
+  annotationMessage,
+  noConfirm
+}) => {
+  const confirmAnswer = noConfirm || (await confirmPushTag(tagName, annotationMessage));
+  if (confirmAnswer) {
+    await createGitTag(tagName, annotationMessage);
+    await pushGitTag(tagName);
+  }
+};
+const confirmPublishToNpmjs = async (version, npmjsTag) => {
+  const {
+    confirm
+  } = await prompt([{
+    type: 'confirm',
+    name: 'confirm',
+    message: `${_ansiColors.default.bold.red('[Warning]')} Publish new version ${_ansiColors.default.bold.yellow(version)} to npmjs with tag ${_ansiColors.default.bold.yellow(npmjsTag)}?`
+  }]);
+  return confirm;
+};
+const publishToNpmjs = async ({
+  version,
+  npmjsTag,
+  noConfirm
+}) => {
+  const confirmAnswer = noConfirm || (await confirmPublishToNpmjs(version, npmjsTag));
+  if (!confirmAnswer) {
+    console.log('Aborting...');
+    process.exit();
+  }
+  try {
+    await (0, _zx.$)`npm publish --tag ${npmjsTag}`;
+  } catch (err) {
+    console.log(err.stderr || err);
+    process.exit(1);
+  }
+};
+const displayReleaseInfo = config => {
+  const {
+    branch,
+    version,
+    repositoryRoot,
+    packageName,
+    packagePath,
+    buildMessage,
+    tagName,
+    annotationMessage,
+    publishable,
+    npmjsTag,
+    isBetaRelease,
+    noGitTag
+  } = config;
+  console.log(`
+
+${_ansiColors.default.bold.green('============ Tag Release Summary ============')}
+${_ansiColors.default.blue('Branch:')} ${branch}
+${_ansiColors.default.blue('Version:')} ${version}
+${_ansiColors.default.blue('Root directory:')} ${repositoryRoot}
+${_ansiColors.default.blue('Package name:')} ${packageName}
+${_ansiColors.default.blue('package.json path:')} ${_nodePath.default.join(packagePath, 'package.json')}${buildMessage ? `
+${_ansiColors.default.blue('Commit message:')} ${buildMessage}` : ''}${isBetaRelease || noGitTag ? '' : `
+${_ansiColors.default.blue('Git tag:')} ${tagName}`}${isBetaRelease || noGitTag ? '' : `
+${_ansiColors.default.blue('Git tag annotation:')} ${annotationMessage}`}${publishable ? `
+${_ansiColors.default.blue('Npmjs tag:')} ${npmjsTag}` : ''}
+${_ansiColors.default.bold.green('=============================================')}
+`);
+};
+
+/**
+ * Script
+ */
+
+const optionList = [{
+  name: 'branch',
+  type: String,
+  alias: 'b',
+  description: 'branch where the tag will be created'
+}, {
+  name: 'npmjs-tag',
+  type: String,
+  alias: 'n',
+  description: 'npmjs package tag to be used when publishing (for npmjs lib repositories)',
+  typeLabel: 'alpha|beta|latest'
+}, {
+  name: 'version',
+  type: String,
+  alias: 'v',
+  description: 'version to be tagged'
+}, {
+  name: 'publishable',
+  type: Boolean,
+  alias: 'p',
+  description: 'flag to indicate the repository is publishable to npmjs'
+}, {
+  name: 'package-path',
+  type: String,
+  alias: 'a',
+  description: 'relative path to the package from the projec\'s root in case it\'s a monorepo'
+}, {
+  name: 'tag-suffix',
+  type: String,
+  alias: 't',
+  description: 'tag suffix to be appended to the version when pushing to git'
+}, {
+  name: 'annotation-message',
+  type: String,
+  alias: 'm',
+  description: 'annotation message that will annotate the git tag'
+}, {
+  name: 'branch-filter',
+  type: String,
+  alias: 'f',
+  description: 'branch filter used to filter available branches in interactive mode'
+}, {
+  name: 'no-commit',
+  type: Boolean,
+  description: 'do not create a new commit on git (in case the goal is just tagging it)'
+}, {
+  name: 'no-git-tag',
+  type: Boolean,
+  description: 'do not create a new tag on git'
+}, {
+  name: 'no-confirm',
+  type: Boolean,
+  description: 'push to git and publish to npmjs without asking for confirmation'
+}, {
+  name: 'help',
+  type: Boolean,
+  alias: 'h',
+  description: 'show this help'
+}];
+const sections = [{
+  header: 'Tag release script',
+  content: 'This script is intended to give users a simple way to create git tags, push them and publish to Npmjs (if the --publishable flag is passed)'
+}, {
+  header: 'Options',
+  optionList
+}];
+const args = (0, _commandLineArgs.default)(optionList, {
+  partial: true
+});
+const help = (0, _commandLineUsage.default)(sections);
+if (args.help) {
+  console.log(help);
+  process.exit();
+}
+validateArgs(args);
+const config = {};
+config.noConfirm = !!args['no-confirm'];
+config.noCommit = !!args['no-commit'];
+config.noGitTag = !!args['no-git-tag'];
+config.repositoryRoot = await getGitRootDirectory();
+config.branch = args.branch || (await getBranch({
+  branchFilter: args['branch-filter']
+}));
+await checkoutToBranch(config);
+const argsPackagePath = args['package-path'] && _nodePath.default.join(config.repositoryRoot, args['package-path']);
+config.packagePath = argsPackagePath || (await getPackagePath(config));
+config.isPackageInRepositoryRoot = await isPackageInRepositoryRoot(config);
+config.version = args.version || (await getVersion(config));
+config.packageName = await getPackageName(config);
+config.buildMessage = config.noCommit ? '' : getBuildMessage(config);
+config.isBetaRelease = config.version.includes('-beta.');
+if (!config.isBetaRelease && !config.noGitTag) {
+  const tagSuffix = args['tag-suffix'] ?? (await getGitTagSuffix());
+  const tagPrefix = config.isPackageInRepositoryRoot ? '' : `${config.packageName}/`;
+  config.tagName = `${tagPrefix}v${config.version}${tagSuffix}`;
+  const annotationMessage = args['annotation-message'] ?? (await getGitAnnotationMessage(config));
+  config.annotationMessage = annotationMessage;
+}
+config.publishable = !!args.publishable;
+if (config.publishable) {
+  validateNpmjsTag({
+    config,
+    args
+  });
+  config.npmjsTag = args['npmjs-tag'] || (await promptForNpmjsTag(config));
+}
+displayReleaseInfo(config);
+if (!config.noConfirm) {
+  const confirmResponse = await confirmTagRelease(config);
+  if (confirmResponse === 'yes') {
+    config.noConfirm = true;
+  }
+}
+if (!config.noCommit) {
+  await commitAndPushNewBuild(config);
+}
+if (!config.isBetaRelease && !config.noGitTag) {
+  await createAndPushGitTag(config);
+}
+if (config.publishable) {
+  await publishToNpmjs(config);
+}
+process.exit();