@npmcli/template-oss 4.18.1 → 4.19.0

package/lib/config.js

@@ -1,41 +1,63 @@
 const { relative, dirname, join, extname, posix, win32 } = require('path')
-const { defaults, pick, omit, uniq } = require('lodash')
-const semver = require('semver')
-const parseCIVersions = require('./util/parse-ci-versions.js')
+const { defaults, pick, omit, uniq, isPlainObject } = require('lodash')
+const ciVersions = require('./util/ci-versions.js')
 const parseDependabot = require('./util/dependabot.js')
 const git = require('./util/git.js')
 const gitignore = require('./util/gitignore.js')
-const { mergeWithArrays } = require('./util/merge.js')
+const { mergeWithCustomizers, customizers } = require('./util/merge.js')
 const { FILE_KEYS, parseConfig: parseFiles, getAddedFiles, mergeFiles } = require('./util/files.js')
 
 const CONFIG_KEY = 'templateOSS'
 const getPkgConfig = (pkg) => pkg[CONFIG_KEY] || {}
 
 const { name: NAME, version: LATEST_VERSION } = require('../package.json')
-const { minimatch } = require('minimatch')
 const MERGE_KEYS = [...FILE_KEYS, 'defaultContent', 'content']
 const DEFAULT_CONTENT = require.resolve(NAME)
 
-const merge = mergeWithArrays('branches', 'distPaths', 'allowPaths', 'ignorePaths')
+const merge = mergeWithCustomizers(
+  customizers.mergeArrays('branches', 'distPaths', 'allowPaths', 'ignorePaths'),
+  (value, srcValue, key) => {
+    if (key === 'ciVersions' && (Array.isArray(srcValue) || isPlainObject(srcValue))) {
+      return { ...ciVersions.parse(value), ...ciVersions.parse(srcValue) }
+    }
+  }
+)
 
 const makePosix = (v) => v.split(win32.sep).join(posix.sep)
 const deglob = (v) => makePosix(v).replace(/[/*]+$/, '')
 const posixDir = (v) => `${v === '.' ? '' : deglob(v).replace(/\/$/, '')}${posix.sep}`
 const posixGlob = (str) => `${posixDir(str)}**`
 
-const getCmdPath = (key, { rootConfig, defaultConfig, isRoot, pkg, rootPkg }) => {
-  // Make a path relative from a workspace to the root if we are in a workspace
-  const wsToRoot = (p) => isRoot ? p : makePosix(join(relative(pkg.path, rootPkg.path), p))
+const getCmdPath = (key, { pkgConfig, rootConfig, isRoot, pkg, rootPkg }) => {
+  const result = (local, isRelative) => {
+    let root = local
+    const isLocal = local.startsWith('.') || local.startsWith('/')
+
+    if (isLocal) {
+      if (isRelative) {
+        // Make a path relative from a workspace to the root if we are in a workspace
+        local = makePosix(join(relative(pkg.path, rootPkg.path), local))
+      }
+      local = `node ${local}`
+      root = `node ${root}`
+    }
+
+    return {
+      isLocal,
+      local,
+      root,
+    }
+  }
 
-  const rootPath = rootConfig[key]
-  const defaultPath = defaultConfig[key]
-  const isLocal = rootPath && rootPath !== defaultPath
+  if (pkgConfig[key]) {
+    return result(pkgConfig[key])
+  }
 
-  return {
-    isLocal,
-    root: !isLocal ? defaultPath : `node ${rootPath}`,
-    local: !isLocal ? defaultPath : `node ${wsToRoot(rootPath)}`,
+  if (rootConfig[key]) {
+    return result(rootConfig[key], !isRoot)
   }
+
+  return result(key)
 }
 
 const mergeConfigs = (...configs) => {
@@ -139,9 +161,8 @@ const getFullConfig = async ({
     ] : [],
   ]
 
-  // root only configs
-  const npmPath = getCmdPath('npm', { rootConfig, defaultConfig, isRoot, pkg, rootPkg })
-  const npxPath = getCmdPath('npx', { rootConfig, defaultConfig, isRoot, pkg, rootPkg })
+  const npmPath = getCmdPath('npm', { pkgConfig, rootConfig, isRoot, pkg, rootPkg })
+  const npxPath = getCmdPath('npx', { pkgConfig, rootConfig, isRoot, pkg, rootPkg })
 
   // these are written to ci yml files so it needs to always use posix
   const pkgPath = makePosix(relative(rootPkg.path, pkg.path)) || '.'
@@ -157,9 +178,12 @@ const getFullConfig = async ({
 
   const branches = uniq([...pkgConfig.branches ?? [], pkgConfig.releaseBranch]).filter(Boolean)
   const gitBranches = await git.getBranches(rootPkg.path, branches)
-  const currentBranch = await git.currentBranch(rootPkg.path)
-  const isReleaseBranch = currentBranch ? minimatch(currentBranch, pkgConfig.releaseBranch) : false
   const defaultBranch = await git.defaultBranch(rootPkg.path) ?? 'main'
+  const isReleaseBranch = !!pkgConfig.backport
+  const publishTag = isReleaseBranch ? `next-${pkgConfig.backport}` : 'latest'
+  const releaseBranch = isReleaseBranch
+    ? pkgConfig.releaseBranch.replace(/\*/g, pkgConfig.backport)
+    : defaultBranch
 
   // all derived keys
   const derived = {
@@ -179,12 +203,11 @@ const getFullConfig = async ({
     // controls whether we are in a monorepo with any public workspaces
     isMonoPublic: isMono && !!publicPkgs.filter(p => p.path !== rootPkg.path).length,
     // git
-    defaultBranch,
-    baseBranch: isReleaseBranch ? currentBranch : defaultBranch,
     branches: gitBranches.branches,
     branchPatterns: gitBranches.patterns,
     isReleaseBranch,
-    // dependabot
+    releaseBranch,
+    publishTag,
     dependabot: parseDependabot(pkgConfig, defaultConfig, gitBranches.branches),
     // repo
     repoDir: rootPkg.path,
@@ -218,6 +241,8 @@ const getFullConfig = async ({
     // lockfiles are only present at the root, so this only should be set for
     // all workspaces based on the root
     lockfile: rootPkgConfig.lockfile,
+    // ci versions / engines
+    ciVersions: ciVersions.get(pkg.pkgJson.engines?.node, pkgConfig),
     // gitignore
     ignorePaths: [
       ...gitignore.sort([
@@ -242,33 +267,6 @@ const getFullConfig = async ({
     __PARTIAL_DIRS__: fileDirs,
   }
 
-  if (pkgConfig.ciVersions) {
-    let versions = pkgConfig.ciVersions
-    if (versions === 'latest' || (Array.isArray(versions) && versions.includes('latest'))) {
-      const { ciVersions } = [isWorkspace ? rootPkgConfig : {}, defaultConfig]
-        .find(c => Array.isArray(c.ciVersions))
-      const defaultLatest = ciVersions[ciVersions.length - 1]
-      versions = [].concat(versions).map(v => v === 'latest' ? defaultLatest : v)
-    }
-
-    const { targets, engines } = parseCIVersions(versions)
-
-    // get just a list of the target versions (not ranges)
-    // these are used for the node version when doing engines checks
-    // since we want to test in the lowest version of each major
-    let targetVersions = targets.filter(t => semver.valid(t))
-    // if the versions are all ranges then convert them to the lower bound of each range
-    if (!targetVersions.length) {
-      targetVersions = targets.filter(t => semver.validRange(t)).map(t => {
-        return new semver.Range(t).set[0][0].semver.version
-      })
-    }
-
-    derived.ciVersions = targets
-    derived.baseCiVersions = targetVersions
-    derived.engines = pkgConfig.engines || engines
-  }
-
   if (!pkgConfig.eslint) {
     derived.ignorePaths = derived.ignorePaths.filter(p => !p.includes('eslint'))
     if (Array.isArray(pkgConfig.requiredPackages?.devDependencies)) {

package/lib/content/_job-release-integration.yml

@@ -22,7 +22,7 @@ steps:
   - name: Publish
     env:
       PUBLISH_TOKEN: $\{{ secrets.PUBLISH_TOKEN }}
-    run: npm publish --provenance
+    run: npm publish --provenance --tag={{ publishTag }}
 {{else}}
 runs-on: ubuntu-latest
 defaults:

package/lib/content/ci-release.yml

@@ -7,7 +7,7 @@ on:
       ref:
         required: true
         type: string
-        default: {{ baseBranch }}
+        default: {{ releaseBranch }}
   workflow_call:
     inputs:
       ref:

package/lib/content/index.js

@@ -136,6 +136,8 @@ module.exports = {
   windowsCI: true,
   macCI: true,
   branches: ['main', 'latest'],
+  // set this to the major version to backport
+  backport: null,
   releaseBranch: 'release/v*',
   distPaths: [
     'bin/',
@@ -156,13 +158,12 @@ module.exports = {
     '/CHANGELOG*',
   ],
   ignorePaths: [],
-  ciVersions: ['14.17.0', '14.x', '16.13.0', '16.x', '18.0.0', '18.x'],
+  ciVersions: {},
+  latestCiVersion: 20,
   lockfile: false,
   codeowner: '@npm/cli-team',
   eslint: true,
   publish: false,
-  npm: 'npm',
-  npx: 'npx',
   updateNpm: true,
   dependabot: 'increase-if-necessary',
   unwantedPackages: [

package/lib/content/pkg.json

@@ -21,11 +21,6 @@
     "postpublish": {{{ del }}}
   },
   "repository": {{#if repository}}{{{ json repository }}}{{else}}{{{ del }}}{{/if}},
-  "engines": {
-    {{#if engines}}
-    "node": {{{ json engines }}}
-    {{/if}}
-  },
   {{{ json __CONFIG_KEY__ }}}: {
     "version": {{#if isDogFood}}{{{ del }}}{{else}}{{{ json __VERSION__ }}}{{/if}}
   },

package/lib/util/ci-versions.js

@@ -0,0 +1,80 @@
+const { uniq, range, isPlainObject } = require('lodash')
+const semver = require('semver')
+
+const parseCiVersions = (ciVersions) => {
+  if (Array.isArray(ciVersions)) {
+    return Object.fromEntries(ciVersions.map((v) => [v, true]))
+  }
+  if (isPlainObject(ciVersions)) {
+    return ciVersions
+  }
+}
+
+const getLowerBounds = (sRange) => {
+  return new semver.Range(sRange).set.map(c => c[0])
+}
+
+const getCiVersions = (nodeEngines, pkgConfig) => {
+  let allCiVersions = {}
+
+  // get ci versions
+  const { latestCiVersion, ciVersions } = pkgConfig
+
+  if (latestCiVersion) {
+    allCiVersions[`${latestCiVersion}.x`] = true
+  }
+
+  // determine the ci versions from the node engines set
+  if (nodeEngines) {
+    const lowerBounds = getLowerBounds(nodeEngines)
+      .map(v => v.semver)
+      .filter(v => v.version)
+
+    for (const version of lowerBounds) {
+      allCiVersions[version.version] = true
+      allCiVersions[`${version.major}.x`] = true
+    }
+
+    const lowestCiVersion = semver.sort(lowerBounds)[0]?.major
+    if (lowestCiVersion && latestCiVersion) {
+      for (const major of range(lowestCiVersion, latestCiVersion, 2)) {
+        allCiVersions[`${major}.x`] = true
+      }
+    }
+  }
+
+  if (ciVersions === 'latest' && latestCiVersion) {
+    // the plain string 'latest' means latest only and everything else is removed
+    allCiVersions = { [`${latestCiVersion}.x`]: true }
+  } else {
+    // this allows ciVersions to turn off default versions by setting them to a falsy value
+    Object.assign(allCiVersions, parseCiVersions(ciVersions))
+  }
+
+  if (allCiVersions.latest && latestCiVersion) {
+    delete allCiVersions.latest
+    allCiVersions[`${latestCiVersion}.x`] = true
+  }
+
+  const filteredCiVersions = Object.entries(allCiVersions)
+    .filter(([, v]) => v)
+    .map(([k]) => k)
+
+  return uniq(filteredCiVersions).sort((a, b) => {
+    const aComp = getLowerBounds(a)[0]
+    const bComp = getLowerBounds(b)[0]
+
+    if (aComp.semver.major > bComp.semver.major) {
+      return 1
+    } else if (aComp.semver.major < bComp.semver.major) {
+      return -1
+    }
+
+    return aComp.operator ? 1 : -1
+  })
+}
+
+module.exports = {
+  parse: parseCiVersions,
+  get: getCiVersions,
+}

package/lib/util/git.js

@@ -66,17 +66,8 @@ const defaultBranch = async (path) => {
   }
 }
 
-const currentBranch = async (path) => {
-  try {
-    return await tryGit(path, 'rev-parse', '--abbrev-ref', 'HEAD')
-  } catch {
-    // ignore errors
-  }
-}
-
 module.exports = {
   getUrl,
   getBranches,
   defaultBranch,
-  currentBranch,
 }

package/lib/util/merge.js

@@ -65,7 +65,6 @@ const customizers = {
 module.exports = {
   // default merge is to overwrite arrays
   merge: mergeWithCustomizers(customizers.overwriteArrays),
-  mergeWithArrays: (...keys) => mergeWithCustomizers(customizers.mergeArrays(...keys)),
   mergeWithCustomizers,
   mergeWith,
   customizers,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@npmcli/template-oss",
-  "version": "4.18.1",
+  "version": "4.19.0",
   "description": "templated files used in npm CLI team oss projects",
   "main": "lib/content/index.js",
   "bin": {

package/lib/util/parse-ci-versions.js

@@ -1,78 +0,0 @@
-const semver = require('semver')
-const { partition, uniq, groupBy } = require('lodash')
-
-// try to parse a version. if its invalid then
-// try to parse it as a range instead
-const versionOrRange = (v) => semver.parse(v) || new semver.Range(v)
-
-// get the version or the upper bound of the range
-// used for sorting to give the latest ci target
-const getMaxVersion = (v) => v.version || v.set[0][1].semver.version
-
-// given an array of versions, returns an object where
-// each key is a major and each value is a sorted list of versions
-const versionsByMajor = (versions) => {
-  const majors = groupBy(versions, (v) => semver.major(v))
-  for (const [k, vs] of Object.entries(majors)) {
-    majors[k] = semver.sort(vs)[0]
-  }
-  return majors
-}
-
-// given a list of semver ci targets like:
-// ['12.13.0', '12.x', '14.15.0', '14.x', '16.0.0', '16.x']
-// this will parse into a uniq list of lowest "supported"
-// versions. In our cases so that will return
-// '^12.13.0 || ^14.15.0 || >=16'. This is not super generic but fits
-// our use case for now where we want to test on a bunch of
-// specific versions/ranges and map them to somewhat loose
-// semver range for package.json#engines.node. This only supports
-// returning ^ ranges and makes the last version >= currently.
-//
-// Assumptions:
-// - ranges span a single major version
-// - specific versions are lower then the upper bound of
-//   ranges within the same major version
-const parseCITargets = (targets = []) => {
-  const [versions, ranges] = partition(
-    targets.map((t) => versionOrRange(t)),
-    (t) => t.version
-  )
-
-  const sorted = [...versions, ...ranges]
-    .sort((a, b) => semver.compareBuild(getMaxVersion(a), getMaxVersion(b)))
-    .map((v) => v.version || v.raw)
-
-  // object of {major: lowestVersion } for all passed in versions
-  const minVersions = versionsByMajor(versions)
-
-  // object of {major: lowestVersionInRange } for all passed in ranges
-  const minRanges = versionsByMajor(ranges.map((r) => semver.minVersion(r)))
-
-  // Given all the uniq major versions in targets...
-  const parsedRanges = uniq([...Object.keys(minVersions), ...Object.keys(minRanges)])
-    // first sort by major to make it display nicer
-    .sort((a, b) => Number(a) - Number(b))
-    .map((major) => {
-      const minVersion = minVersions[major]
-      const minRange = minRanges[major]
-      // if we only have one then return that
-      if (!minVersion || !minRange) {
-        return minVersion || minRange
-      }
-      // otherwise return min version
-      // XXX: this assumes the versions are lower than the upper
-      // bound for any range for the same major. This is ok for
-      // now but will break with more complex/specific semver ranges
-      return minVersion
-    })
-    // make the last version allow all greater than
-    .map((v, index, list) => (index === list.length - 1 ? '>=' : '^') + v)
-
-  return {
-    targets: sorted,
-    engines: parsedRanges.join(' || '),
-  }
-}
-
-module.exports = parseCITargets