@leverege/build-tools 2.96.0 → 2.96.1

package/lib/server/tag-release.js

@@ -1,681 +0,0 @@
-#!/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();