@leverege/build-tools 2.31.4 → 2.32.1

package/src/tag-release.mjs

@@ -0,0 +1,630 @@
+#!/usr/bin/env node
+/* eslint-disable security/detect-unsafe-regex */
+/* eslint-disable no-console */
+/* eslint-disable max-len */
+
+import cliArgs from 'command-line-args'
+import cliHelp from 'command-line-usage'
+import { $, fs } from 'zx'
+import pkg from 'enquirer'
+import colors from 'ansi-colors'
+import path from 'path'
+import { readPackage } from 'read-pkg'
+
+const { prompt } = pkg
+
+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( `
+${colors.bold.red( 'ERROR:' )} Invalid version arg: ${colors.bold.yellow( args.version )}.
+Use SemVer specs (e.g: ${colors.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( `
+${colors.bold.red( 'ERROR:' )} Invalid npmjs tag: ${colors.bold.yellow( args['npmjs-tag'] )}.
+Possible values: ${colors.bold.yellow( npmjsTags.join( ', ' ) )}.
+` )
+    process.exit( 1 )
+  }
+
+  if (
+    ( config?.isBetaRelease === true || args?.version?.includes( '-beta.' ) ) &&
+    args['npmjs-tag'] === NPMJS_TAGS.LATEST
+  ) {
+    console.log( `
+${colors.bold.red( 'ERROR:' )} It's not possible to publish a beta release to npmjs with tag ${colors.bold.yellow( 'latest' )}.
+  ` )
+    process.exit( 1 )
+  }
+}
+
+const validateArgs = ( args ) => {
+  validateVersionArg( { args } )
+  validateNpmjsTag( { args } )
+}
+
+const getCurrentBranch = async () => {
+  const { stdout } =
+    await $`git branch --show-current`
+      .nothrow()
+      .quiet()
+
+  return stdout.split( '\n' )[0]
+}
+
+const getLatestBranches = async ( { n = 10, branchFilter } ) => {
+  const grepFilter = branchFilter || ''
+
+  const { stdout } =
+    await $`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( `
+${colors.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 $`git rev-parse --show-toplevel`.quiet()
+  return stdout.split( '\n' )[0]
+}
+
+const getSubDirectories = async ( repositoryRoot, directory ) => {
+  const absolutePathDirectory = path.join( repositoryRoot, directory )
+  const relativeDirectory = path.relative( repositoryRoot, absolutePathDirectory )
+  try {
+    const entries = await fs.promises.readdir( absolutePathDirectory, { withFileTypes : true } )
+    const subDirectories = entries.filter( entry => entry.isDirectory() )
+    return subDirectories.map( entry => path.join( relativeDirectory, entry.name ) )
+  } catch ( err ) {
+    return []
+  }
+}
+
+const fileExists = async ( filePath ) => {
+  try {
+    await 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 = path.join( directoriesToSearch[i], 'package.json' )
+      const pkgExists = await fileExists( path.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 readPackage( { cwd : repositoryRoot } )
+  } catch ( err ) {}
+
+  return findPackagesInDirectories( repositoryRoot, pkg?.workspaces || [ packagesPath ] )
+}
+
+const selectPackageToUpdate = async ( repositoryRoot, packagePaths ) => {
+  const currentPath = process.cwd()
+  const currentPackageRelativePath = path.relative( repositoryRoot, currentPath )
+  
+  const { packageName } = await prompt( {
+    type : 'select',
+    name : 'packageName',
+    message : 'What package are you releasing?',
+    choices : packagePaths,
+    initial : currentPackageRelativePath
+  } )
+
+  return path.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 $`git checkout ${branch}`
+  } catch ( err ) {
+    console.log( err.stderr || err )
+    process.exit( 1 )
+  }
+}
+
+const getPackageJsonVersion = async ( packagePath ) => {
+  if ( !packagePath ) {
+    console.log( `
+${colors.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 readPackage( { cwd : packagePath } )
+  return packageJson.version
+}
+
+const getNextVersions = ( currentVersion ) => {
+  const [ major, minor, patch, beta ] = currentVersion.split( /\.|-beta\./ ).map( Number )
+
+  const nextMajor = `${major + 1}.0.0`
+  const nextMinor = `${major}.${minor + 1}.0`
+  const nextPatch = `${major}.${minor}.${patch + 1}`
+  const nextBeta = beta ? `${major}.${minor}.${patch}-beta.${beta + 1}` : `${major}.${minor}.${patch + 1}-beta.1`
+
+  return {
+    nextMajor,
+    nextMinor,
+    nextPatch,
+    nextBeta,
+  }
+}
+
+const promptForVersion = async ( currentVersion ) => {
+  const { nextMajor, nextMinor, nextPatch, nextBeta } = getNextVersions( currentVersion )
+  const choices = [
+    { hint : '(major release)', value : nextMajor },
+    { hint : '(minor release)', value : nextMinor },
+    { hint : '(patch release)', value : nextPatch },
+    { hint : '(beta release)', value : nextBeta },
+    { 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 } ) => {
+  await checkoutToBranch( branch )
+  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 confirmPushCommit = async ( buildMessage ) => {
+  const { confirm } = await prompt( [ {
+    type : 'confirm',
+    name : 'confirm',
+    message : `${colors.bold.red( '[Warning]' )} Commit and push ${colors.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 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 $`npm version --no-git-tag-version ${version} --prefix ${packagePath}`.nothrow()
+      if ( isWorkspace ) {
+        await $`npm install`
+      } else {
+        await $`npm install --prefix ${packagePath}`
+      }
+    } else {
+      await $`npm version --no-git-tag-version ${version}`.nothrow()
+    }
+  } catch ( err ) {
+    console.log( err.stderr || err )
+    process.exit( 1 )
+  }
+}
+
+const createNewBuildCommit = async ( { buildMessage } ) => {
+  try {
+    await $`git add .`
+    await $`git commit -m ${buildMessage}`
+  } catch ( err ) {
+    console.log( err.stderr || err )
+    process.exit( 1 )
+  }
+}
+
+const pushToGitRemote = async () => {
+  try {
+    await $`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 ) => {
+  const { confirm } = await prompt( [ {
+    type : 'confirm',
+    name : 'confirm',
+    message : `${colors.bold.red( '[Warning]' )} Push new tag ${colors.bold.yellow( tagName )} to git remote?`
+  } ] )
+  return confirm
+}
+
+const createGitTag = async ( tagName ) => {
+  try {
+    await $`git tag ${tagName}`
+  } catch ( err ) {
+    console.log( err.stderr || err )
+    process.exit( 1 )
+  }
+}
+
+const pushGitTag = async ( tagName ) => {
+  try {
+    await $`git push origin ${tagName}`
+  } catch ( err ) {
+    console.log( err.stderr || err )
+    process.exit( 1 )
+  }
+}
+
+const createAndPushGitTag = async ( { tagName, noConfirm } ) => {
+  const confirmAnswer = noConfirm || await confirmPushTag( tagName )
+  if ( confirmAnswer ) {
+    await createGitTag( tagName )
+    await pushGitTag( tagName )
+  }
+}
+
+const confirmPublishToNpmjs = async ( version, npmjsTag ) => {
+  const { confirm } = await prompt( [ {
+    type : 'confirm',
+    name : 'confirm',
+    message : `${colors.bold.red( '[Warning]' )} Publish new version ${colors.bold.yellow( version )} to npmjs with tag ${colors.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 $`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,
+    publishable,
+    npmjsTag,
+    isBetaRelease
+  } = config
+
+  console.log( `
+
+${colors.bold.green( '============ Tag Release Summary ============' )}
+${colors.blue( 'Branch:' )} ${branch}
+${colors.blue( 'Version:' )} ${version}
+${colors.blue( 'Root directory:' )} ${repositoryRoot}
+${colors.blue( 'Package name:' )} ${packageName}
+${colors.blue( 'package.json path:' )} ${path.join( packagePath, 'package.json' )}${buildMessage ? `
+${colors.blue( 'Commit message:' )} ${buildMessage}` : ''}${isBetaRelease ? '' : `
+${colors.blue( 'Git tag:' )} ${tagName}`}${publishable ? `
+${colors.blue( 'Npmjs tag:' )} ${npmjsTag}` : ''}
+${colors.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 : '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-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 = cliArgs( optionList, { partial : true } )
+const help = cliHelp( sections )
+
+if ( args.help ) {
+  console.log( help )
+  process.exit()
+}
+
+validateArgs( args )
+
+const config = {}
+
+config.noConfirm = !!args['no-confirm']
+
+config.noCommit = !!args['no-commit']
+
+config.repositoryRoot = await getGitRootDirectory()
+
+config.branch = args.branch || await getBranch( { branchFilter : args['branch-filter'] } )
+
+const argsPackagePath = args['package-path'] && path.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 ) {
+  const tagSuffix = args['tag-suffix'] ?? await getGitTagSuffix()
+  const tagPrefix = config.isPackageInRepositoryRoot ? '' : `${config.packageName}/`
+  config.tagName = `${tagPrefix}v${config.version}${tagSuffix}`
+}
+
+config.publishable = !!args.publishable
+if ( config.publishable ) {
+  validateNpmjsTag( { config, args } )
+  config.npmjsTag = args['npmjs-tag'] || await promptForNpmjsTag( config )
+}
+
+displayReleaseInfo( config )
+
+const confirmResponse = await confirmTagRelease( config )
+if ( confirmResponse === 'yes' ) {
+  config.noConfirm = true
+}
+
+if ( !config.noCommit ) { await commitAndPushNewBuild( config ) }
+if ( !config.isBetaRelease ) { await createAndPushGitTag( config ) }
+if ( config.publishable ) { await publishToNpmjs( config ) }
+
+process.exit()