@leverege/build-tools 2.56.1 → 2.57.0

package/.har/config.json

@@ -0,0 +1,11 @@
+{
+  "protected-branches": [
+    "development",
+    "main"
+  ],
+  "npm-scripts": [
+    "lint",
+    "test"
+  ],
+  "ignore-packages": []
+}

package/.har/pre-commit

@@ -0,0 +1 @@
+hook-and-release

package/.har/pre-push

@@ -0,0 +1 @@
+hook-and-release

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leverege/build-tools",
-  "version": "2.56.1",
+  "version": "2.57.0",
   "description": "A collection of build / support tools for Leverege developers",
   "main": "index.js",
   "repository": {
@@ -10,7 +10,8 @@
   "scripts": {
     "clean": "rm -rf lib",
     "lint": "find ./src -name \\*.\\*js | xargs npx eslint --report-unused-disable-directives",
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "prepare": "hook-and-release",
+    "test": "echo \"no tests specified\" && exit 0"
   },
   "bin": {
     "build-tools": "src/build-tools.mjs",
@@ -34,6 +35,7 @@
     "helmup": "src/helmup.sh",
     "helminit": "src/helmup.sh",
     "helmwhat": "src/helmup.sh",
+    "hook-and-release": "src/hook-and-release.mjs",
     "k8cryo": "src/k8cryo.sh",
     "k8scale": "src/k8scale.sh",
     "k8thaw": "src/k8cryo.sh",
@@ -56,7 +58,7 @@
   "author": "Leverege Devs",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@google-cloud/artifact-registry": "^3.4.0",
+    "@google-cloud/artifact-registry": "^3.5.0",
     "ansi-colors": "^4.1.3",
     "chalk": "^5.3.0",
     "command-line-args": "^6.0.1",
@@ -66,7 +68,7 @@
     "execa": "^9.5.1",
     "glob": "^11.0.0",
     "handlebars": "^4.7.8",
-    "inquirer": "^12.0.1",
+    "inquirer": "^12.1.0",
     "js-yaml": "^4.1.0",
     "ms": "^2.1.3",
     "npm-registry-fetch": "^18.0.2",
@@ -76,7 +78,7 @@
     "readline-sync": "^1.4.10",
     "semver": "^7.6.3",
     "simple-git": "^3.27.0",
-    "zx": "^8.2.0"
+    "zx": "^8.2.2"
   },
   "devDependencies": {
     "@leverege/eslint-config-leverege": "^5.0.1",

package/src/Utils.mjs

@@ -9,6 +9,7 @@ import YAML from 'js-yaml'
 
 let debugEnabled = process.env.BUILD_TOOLS_DEBUG === '1'
 
+export const enableDebug = () => { debugEnabled = true }
 export const disableDebug = () => { debugEnabled = false }
 
 /* eslint-disable no-console */
@@ -115,26 +116,29 @@ export const getGcpSecret = async ( gcpProject, secretName, opts ) => {
   }
 }
 
-export const getGitRootDirectory = async () => {
+const runGitCommand = async ( cmd, debugLabel ) => {
   try {
-    const gitRoot = await shellCmd( 'git rev-parse --show-toplevel' )
-    debug( { gitRoot }, '<==getGitRootDirectory' )
-    return gitRoot
+    const result = await shellCmd( cmd )
+    debug( { result }, `<==${debugLabel}` )
+    return result
   } catch ( error ) {
-    debug( { error }, '<==getGitRootDirectory' )
-    throw error
+    debug( { error }, chalk.red( `***ERROR git failed [${cmd}]` ) )
+    return undefined
   }
 }
 
-export const getGitUpstream = async () => {
-  let branch
+export const getGitBranch = async () => runGitCommand( 'git rev-parse --abbrev-ref HEAD', 'getGitCurrentBranch' )
+export const getGitDiff = async opts => runGitCommand( `git diff ${opts}`, 'getGitDiff' )
+export const getGitHooksPath = async () => runGitCommand( 'git config --get core.hooksPath', 'getGitHooksPath' )
+export const setGitHooksPath = async hookPath => runGitCommand( `git config core.hooksPath ${hookPath}`, 'setGitHooksPath' )
+export const getGitRootDirectory = async () => runGitCommand( 'git rev-parse --show-toplevel', 'getGitRootDirectory' )
+export const getGitBranchAndUpstream = async () => {
+  const branch = await getGitBranch() ?? 'detached'
+  let upstream = 'no-upstream'
   try {
-    branch = await shellCmd( 'git rev-parse --abbrev-ref HEAD' )
-    const upstream = await shellCmd( `git rev-parse --abbrev-ref ${branch}@{u}` )
-    return { branch, upstream }
-  } catch ( err ) {
-    return { branch, upstream : undefined }
-  }
+    upstream = await runGitCommand( `git rev-parse --abbrev-ref ${branch}@{u}`, 'getGitUpstream' ) ?? 'no-upstream'
+  } catch ( error ) {}
+  return { branch, upstream }
 }
 
 export const gitRepoIsDirty = async () => {
@@ -382,13 +386,15 @@ export const parseHelmChart = async ( helmroot = './helm' ) => {
   } )
 }
 
-export const analyzeRepository = async ( giveGuidance ) => {
+export const getRepositoryDescr = async () => {
+  const currentDir = process.cwd()
+  const workingDir = process.env.PWD
   const gitRoot = await getGitRootDirectory()
+  const gitHooksPath = await getGitHooksPath()
+  const { branch : gitBranch, upstream : gitUpstream } = await getGitBranchAndUpstream()
   const subPkgs = await glob( `${gitRoot}/packages/**/package.json`, { ignore : '/**/node_modules/**' } )
   const helmChart = await parseHelmChart()
   const isMonoRepo = subPkgs?.length > 0
-
-  // Verify the presence of a root package.json file for all monorepos
   let rootPackageJson
   try {
     rootPackageJson = await parseJsonFile( `${gitRoot}/package.json` )
@@ -396,6 +402,32 @@ export const analyzeRepository = async ( giveGuidance ) => {
     rootPackageJson = { isInvalid : true, error : 'invalid or non-existent root package.json file' }
   }
   const isNpmWorkspace = rootPackageJson?.workspaces?.length > 0
+
+  return {
+    currentDir,
+    workingDir,
+    gitBranch,
+    gitHooksPath,
+    gitRoot,
+    gitUpstream,
+    helmChart,
+    isMonoRepo,
+    isNpmWorkspace,
+    rootPackageJson,
+    subPkgs,
+  }
+}
+
+export const analyzeRepository = async ( giveGuidance ) => {
+  const {
+    gitRoot,
+    subPkgs,
+    helmChart,
+    isMonoRepo,
+    rootPackageJson,
+    isNpmWorkspace,
+  } = await getRepositoryDescr()
+
   if ( isMonoRepo && rootPackageJson.isInvalid ) {
     log( chalk.red.bold( `
   ***REQUIRED: A package.json file is required at the monorepo root` ) )

package/src/docker-to-registry.mjs

@@ -11,7 +11,7 @@ import {
   debug, log,
   errorExit,
   analyzeRepository,
-  getGitUpstream,
+  getGitBranchAndUpstream,
   gitRepoIsDirty,
   proceed,
   shellCmd } from './Utils.mjs'
@@ -234,7 +234,7 @@ if ( imageVersion !== packageVersion ) {
   }
 }
 
-const repoInfo = await getGitUpstream()
+const repoInfo = await getGitBranchAndUpstream()
 
 if ( willGitTag && !repoInfo.upstream ) {
   log( `

package/src/hook-and-release/CLIParser.mjs

@@ -0,0 +1,23 @@
+import commandLineArgs from 'command-line-args'
+import commandLineUsage from 'command-line-usage'
+
+import { log } from '../Utils.mjs'
+
+const parseCLIArgs = ( optionList, sections ) => {
+  const cliArgs = commandLineArgs( optionList, { camelCase : true, partial : true } )
+
+  /* eslint-disable no-underscore-dangle */
+  if ( cliArgs._unknown ) {
+    throw new Error( `Unknown command line options: ${cliArgs._unknown.join( ', ' )}` )
+  }
+  /* eslint-enable no-underscore-dangle */
+
+  if ( cliArgs.help ) {
+    log( commandLineUsage( sections ) )
+    process.exit( 0 )
+  }
+
+  return cliArgs
+}
+
+export default parseCLIArgs

package/src/hook-and-release/Config.mjs

@@ -0,0 +1,249 @@
+import fs from 'node:fs'
+
+import chalk from 'chalk'
+
+import {
+  debug,
+  enableDebug,
+  errorExit,
+  getRepositoryDescr,
+  log,
+  parseJsonFile,
+  setGitHooksPath,
+  shellCmd,
+  warning,
+} from '../Utils.mjs'
+
+import parseCLIArgs from './CLIParser.mjs'
+
+const cliOptionList = [
+  {
+    name : 'init',
+    type : Boolean,
+    default : false,
+    description : '{green bootstraps the repo .har directory and adds appropriate git hook}',
+  },
+  {
+    name : 'debug',
+    type : Boolean,
+    default : false,
+    description : '{yellow enables verbose debugging}',
+  },
+  {
+    name : 'help',
+    type : Boolean,
+    default : false,
+    description : '{green display this help screen}',
+  },
+]
+
+const cliSections = [
+  {
+    header : 'Leverege Hook and Release (HAR) Script',
+    content : `{green HAR is a replacement for the Husky git hook manager - it is designed to
+handle git hooks in standard git repositories as well as git monorepos. It
+connects into a repository's git hook system after a repo is cloned. The hook
+connection is made during the {yellow.bold npm install} phase, which will execute the
+{yellow.bold npm prepare} script as defined in the package.json scripts section:
+
+  {yellow.bold "scripts": {
+    ...
+    "prepare": "hook-and-release",
+    ...
+  }
+
+The hook-and-release script can be invoked directly from the command line,
+typically for first-time initialization, or from the git hook scripts located
+in the .har subdirectory in the root of a repository. Running with the {yellow.bold --init}
+command line switch will create the .har subdirectory at the repo root with a
+config.json file and two standard hook scripts, pre-commit and pre-push:
+
+  {yellow.bold .har
+  ├── config.json
+  ├── pre-commit
+  └── pre-push}
+}`
+  },
+  {
+    header : 'Options',
+    optionList : cliOptionList,
+  },
+  {
+    header : 'Configuration File and Hook Scripts',
+    content : [
+      `{bold .har/config.json}   {green controls branch, script and package config
+{white.bold protected-branches} list of branch names to protect
+{white.bold npm-scripts}        list of npm scripts to run on protected branches
+{white.bold ignore-packages}    list of monorepo packages to ignore
+
+{white.bold Example config.json}
+\\{
+  "protected-branches": [
+    "development",
+    "main",
+  ],
+  "npm-scripts": [
+    "lint",
+    "test"
+  ],
+  "ignore-packages": [
+    "legacy-*"
+  ]
+\\}
+
+{white.bold Example pre-commit script file contents}
+
+  hook-and-release --debug
+
+which tell HAR to run with debugging enabled. This will print out copious
+amounts of information and prevents the git command from succeeding, so
+it's more like a debug with dry-run. Removing the {yellow.bold --debug} will
+allow everything to run normally.
+}`
+    ]
+  },
+]
+
+/* eslint-disable security/detect-non-literal-fs-filename */
+export default class Config {
+  constructor( options = {} ) {
+    try {
+      this.cliArgs = parseCLIArgs( cliOptionList, cliSections )
+
+      if ( this.cliArgs.debug ) {
+        enableDebug()
+      }
+    } catch ( error ) {
+      log( chalk.red( `\n***ERROR: ${error.message}` ) )
+      process.exit( 1 )
+    }
+  }
+
+  async bootstrapHookAndRelease() {
+    const repoDescr = await getRepositoryDescr()
+    this.gitRoot = repoDescr.gitRoot
+    this.gitBranch = repoDescr.gitBranch
+    this.gitHooksPath = repoDescr.gitHooksPath
+    this.isMonoRepo = repoDescr.isMonoRepo
+
+    const harHook = '.har'
+    this.harDir = `${this.gitRoot}/${harHook}`
+
+    if ( this.gitHooksPath !== harHook ) {
+      await setGitHooksPath( harHook )
+    }
+
+    if ( this.cliArgs.init ) {
+      await this.initializeConfiguration( this.harDir )
+    }
+
+    // Start with the basics, is there a root har directory?
+    if ( !fs.existsSync( this.harDir ) ) {
+      const missingHarDir = `
+  The required .har configuration directory is missing from this repository. Try running:
+
+       hook-and-release --init
+
+  which will populate the ${this.harDir} directory.`
+      errorExit( missingHarDir )
+    }
+
+    const harConfigFile = `${this.harDir}/config.json`
+    if ( !fs.existsSync( harConfigFile ) ) {
+      const missingHarConfig = `
+  The required .har/config.json file is missing from this repository which implies
+  the init phase failed. Try removing the .har directory and rerunning:
+
+       hook-and-release --init`
+      errorExit( missingHarConfig )
+    }
+
+    let jsonConfig
+    try {
+      jsonConfig = await parseJsonFile( harConfigFile )
+    } catch ( error ) {
+      errorExit( `
+  There appears to be a syntax error in the har config file:
+
+    ${harConfigFile}
+
+    ${error}
+
+  correct the JSON syntax and try again` )
+
+      return undefined
+    }
+
+    this.jsonConfig = jsonConfig
+    this.protectedBranches = jsonConfig['protected-branches'] || [ 'main', 'development' ]
+    this.ignoredPackages = jsonConfig['ignore-packages'] || ''
+    this.npmScripts = jsonConfig['npm-scripts'] || [ 'lint', 'test' ]
+    return this
+  }
+
+  isBranchProtected() {
+    const branchName = this.gitBranch
+    const protectedBranch = this.protectedBranches.some( ( pattern ) => {
+      // convert wildcard pattern to a regular expression
+      const regex = new RegExp( `^${pattern.replace( /\*/g, '.*' )}$` ) // eslint-disable-line security/detect-non-literal-regexp
+      return regex.test( branchName )
+    } )
+    debug( { branchName, protectedBranch }, '<==harConfig isBranchProtected' )
+    return protectedBranch
+  }
+
+  // this could be made more generic but the initial config is dirt simple
+  async initializeConfiguration( harDir ) {
+    if ( fs.existsSync( harDir ) ) {
+      const harConfigExists = `The hook-and-release configuration directory already exists - skipping --init
+
+      `
+      warning( harConfigExists )
+      return
+    }
+    fs.mkdirSync( harDir, { recursive : true } )
+
+    const CONFIG_CONTENT = {
+      'protected-branches' : [ 'development', 'main' ],
+      'npm-scripts' : [ 'lint', 'test' ],
+      'ignore-packages' : []
+    }
+    fs.writeFileSync( `${harDir}/config.json`, JSON.stringify( CONFIG_CONTENT, null, 2 ), 'utf8' )
+
+    const makeHarHookScript = async ( harScript ) => {
+      const SCRIPT_CONTENT = 'hook-and-release'
+
+      fs.writeFileSync( harScript, SCRIPT_CONTENT, 'utf8' )
+      fs.chmodSync( harScript, 0o750 )
+    }
+
+    makeHarHookScript( `${harDir}/pre-commit` )
+    makeHarHookScript( `${harDir}/pre-push` )
+  }
+
+  async runNpmScripts( runDirectories = [] ) {
+    for ( const runDirectory of runDirectories ) { // eslint-disable-line no-restricted-syntax
+      const scripts = this.npmScripts
+
+      // for each script run sequentially
+      for ( const script of scripts ) { // eslint-disable-line no-restricted-syntax
+        const cmd = `npm run ${script}`
+        log( `hook-and-release in ${chalk.green( runDirectory )} => ${chalk.green( cmd )}` )
+        if ( !this.cliArgs.debug ) {
+          try {
+            await shellCmd( cmd, { cwd : runDirectory, stdio : 'inherit' } ) // eslint-disable-line no-await-in-loop
+          } catch ( err ) {
+            errorExit( err )
+          }
+        }
+      }
+    }
+  }
+
+  // Static async factory method to initialize the Config object and run async setup
+  static async create( options = {} ) {
+    const config = new Config( options )
+    await config.bootstrapHookAndRelease()
+    return config
+  }
+}

package/src/hook-and-release/index.mjs

@@ -0,0 +1,3 @@
+import Config from './Config.mjs'
+
+export default Config

package/src/hook-and-release.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+
+import path from 'node:path'
+
+import { debug, getGitDiff, } from './Utils.mjs'
+
+import Config from './hook-and-release/index.mjs'
+
+const harConfig = await Config.create()
+debug( { harConfig }, '<==hook-and-release config object' )
+
+// Config.create() is the only thing that needs to run during npm install
+if ( process.env.npm_lifecycle_event === 'prepare' ) { process.exit( 0 ) }
+
+// if this branch isn't under protection then we're done
+if ( !harConfig.isBranchProtected() ) { process.exit( 0 ) }
+
+// TODO: maybe move getRunDirectories into the har Config class too?
+const getRunDirectories = async () => {
+  // non-mono means we just run once from the root of the repo
+  if ( !harConfig.isMonoRepo ) {
+    return [ process.cwd() ]
+  }
+
+  // otherwise get staged mods from git and parse out the package names
+  const gitDiff = await getGitDiff( '--name-only --cached' )
+  const stagedFiles = gitDiff.split( '\n' )
+  const packageDirs = new Set()
+
+  // loop through staged files and extract package directories
+  stagedFiles.forEach( ( file ) => {
+    const parts = file.split( path.sep ) // Split path to identify package
+    if ( parts.length > 1 && parts[0] === 'packages' ) {
+      const packageDir = parts[1]
+
+      // check if the package should be ignored before adding it to the Set
+      const shouldIgnore = harConfig.ignoredPackages.some( ( ignoredPattern ) => {
+        // convert an entry like legacy-* into a regex legacy-.*
+        const regex = new RegExp( ignoredPattern.replace( '*', '.*' ) ) // eslint-disable-line security/detect-non-literal-regexp
+        return regex.test( packageDir )
+      } )
+
+      if ( shouldIgnore ) {
+        debug( { packageDir }, '<==ignoring based on config' )
+      } else {
+        packageDirs.add( packageDir )
+      }
+    }
+  } )
+
+  const packageDirsArray = Array.from( packageDirs )
+  const packageDirsWithPath = packageDirsArray.map( ( packageDir ) => {
+    return path.join( process.cwd(), 'packages', packageDir )
+  } )
+
+  debug( { stagedFiles, packageDirsArray, packageDirsWithPath }, '<==unleash: getPackageDirectory' )
+  return packageDirsWithPath
+}
+
+const runDirectories = await getRunDirectories()
+await harConfig.runNpmScripts( runDirectories )
+
+// exit status of 1 in debug mode to prevent git from running
+process.exit( harConfig.cliArgs.debug ? 1 : 0 )

package/src/overwhelm.mjs

@@ -269,7 +269,7 @@ const validValuesLocalConfig = ( vlf ) => {
   if ( !fs.existsSync( vlf ) ) { return undefined }
 
   const valuesLocal = YAML.load( fs.readFileSync( vlf, { encoding : 'utf-8' } ) )
-  const configBlock = valuesLocal.config
+  const configBlock = valuesLocal?.config
 
   // only care about validating config at this time
   if ( configBlock ) {

package/registry-compass.yaml

@@ -1,20 +0,0 @@
-registry:
-  - root: us-docker.pkg.dev
-  - repositories:
-    - name: stack
-      charts:
-        - api-server
-        - authz-server
-        - emailer
-        - message-processor
-    - name: leverege
-      charts:
-        - pubsub-pulse
-        - pusher
-        - overdose
-    - name: cox-health
-      charts:
-        - actions-server
-        - analytics-server
-        - centrak-healthz
-        - centrak-ingestor

package/src/chart-compass.mjs

@@ -1,96 +0,0 @@
-#!/usr/bin/env node
-/*
- * chart-to-registry will...
- */
-import fs from 'node:fs'
-
-import chalk from 'chalk'
-import commandLineArgs from 'command-line-args'
-import commandLineUsage from 'command-line-usage'
-import { lt as semverLt } from 'semver'
-import YAML from 'js-yaml'
-
-import {
-  condir,
-  debug,
-  errorExit,
-  log,
-  warning,
-  getGitRootDirectory,
-  parsePackageJson,
-  parseHelmChart,
-  shellCmd } from './Utils.mjs'
-
-const commandLineOptions = [ // Use commandLineOptions to tie into the Usage statements
-   
-  {
-    name : 'location',
-    type : String,
-    description : '{green the location of the artifact registry the chart will be pushed to (default us-docker.pkg.dev)}',
-  },
-  {
-    name : 'project',
-    type : String,
-    description : '{green the name of the google project containing the npmrc and slack config secrets (default leverege-registry)}',
-  },
-  {
-    name : 'repository',
-    type : String,
-    description : '{green the target repository to receive the pushed chart}',
-  },
-  {
-    name : 'dry-run',
-    type : Boolean,
-    description : '{yellow perform everything except the actual chart push}',
-  },
-  {
-    name : 'help',
-    type : Boolean,
-    description : '{green display this help screen}',
-  },
-   
-]
-
-const sections = [
-  {
-    header : 'Leverege Helm Chart Compass (for helmup)',
-    content : `{green This tool helps helmup navigate the helm charts stored in the
-artifact-registries.}`
-  },
-  { header : 'Options',
-    optionList : commandLineOptions,
-  },
-]
-
-const args = commandLineArgs( commandLineOptions, { camelCase : true, partial : true } )
-const usage = commandLineUsage( sections )
-
-if ( args.help ) {
-  log( usage )
-  process.exit( 0 )
-}
-
-/* eslint-disable no-underscore-dangle */
-if ( args._unknown ) {
-  log( usage )
-  log( `\nUnrecognized argument [${chalk.bold.red( args._unknown )}]\n` )
-  process.exit( 1 )
-}
-/* eslint-enable no-underscore-dangle */
-
-const minNodejsVersion = '18.0.0'
-if ( semverLt( process.version, minNodejsVersion ) ) {
-  errorExit( `\n***ERROR: must be running at least node ${minNodejsVersion}\n` )
-}
-
-// First of all, fail if we are not in a git repository
-let gitRoot
-try {
-  gitRoot = await getGitRootDirectory()
-} catch ( error ) {
-  errorExit( chalk.red.bold( error ), { errorCode : 5 } )
-}
-
-const chartCompass = YAML.load( fs.readFileSync( './registry-compass.yaml', 'utf8' ) )
-
-condir( { chartCompass }, '<==Navigation' )