@npmcli/template-oss 4.19.0 → 4.21.0

package/lib/release-please/index.js

@@ -1,262 +0,0 @@
-const RP = require('release-please')
-const { CheckpointLogger } = require('release-please/build/src/util/logger.js')
-const ChangelogNotes = require('./changelog.js')
-const Version = require('./version.js')
-const NodeWs = require('./node-workspace.js')
-
-const logger = new CheckpointLogger(true, true)
-RP.setLogger(logger)
-RP.registerChangelogNotes('default', (o) => new ChangelogNotes(o))
-RP.registerVersioningStrategy('default', (o) => new Version(o))
-RP.registerPlugin('node-workspace', (o) => new NodeWs(o.github, o.targetBranch, o.repositoryConfig))
-
-const omit = (obj, ...keys) => {
-  const res = {}
-  for (const [key, value] of Object.entries(obj)) {
-    if (!keys.includes(key)) {
-      res[key] = value
-    }
-  }
-  return res
-}
-
-const getManifest = async ({ repo: fullRepo, token, branch }) => {
-  const fullRepoParts = fullRepo.split('/')
-  const github = await RP.GitHub.create({
-    owner: fullRepoParts[0],
-    repo: fullRepoParts[1],
-    token,
-  })
-
-  const { octokit, repository: { owner, repo, defaultBranch } } = github
-
-  const baseBranch = branch ?? defaultBranch
-
-  // This is mostly for testing and debugging. Use environs with the
-  // format `RELEASE_PLEASE_<manfiestOverrideConfigName>` (eg
-  // `RELEASE_PLEASE_lastReleaseSha=<SHA>`) to set one-off config items
-  // for the release please run without needing to commit and push the config.
-  const manifestOverrides = Object.entries(process.env)
-    .filter(([k, v]) => k.startsWith('RELEASE_PLEASE_') && v != null)
-    .map(([k, v]) => [k.replace('RELEASE_PLEASE_', ''), v])
-
-  const manifest = await RP.Manifest.fromManifest(
-    github,
-    baseBranch,
-    undefined,
-    undefined,
-    Object.fromEntries(manifestOverrides)
-  )
-
-  return {
-    github,
-    manifest,
-    octokit,
-    owner,
-    repo,
-    baseBranch,
-  }
-}
-
-const getReleasesFromPr = async ({ manifest, github, number }) => {
-  const baseUrl = `https://github.com/${github.repository.owner}/${github.repository.repo}`
-  // get the release please formatted pull request
-  let pullRequest
-  const prGenerator = github.pullRequestIterator(this.targetBranch, 'MERGED', 200, false)
-  for await (const pr of prGenerator) {
-    if (pr.number === number) {
-      pullRequest = pr
-      break
-    }
-  }
-  const strategiesByPath = await manifest.getStrategiesByPath()
-  const releases = []
-  for (const path in manifest.repositoryConfig) {
-    const config = manifest.repositoryConfig[path]
-    const release = await strategiesByPath[path].buildRelease(pullRequest)
-    if (release) {
-      const { tag, ...rest } = release
-      releases.push({
-        ...rest,
-        ...tag.version,
-        tagName: tag.toString(),
-        version: tag.version.toString(),
-        path,
-        draft: false,
-        url: `${baseUrl}/releases/tag/${tag.toString()}`,
-        prerelease: config.prerelease && !!tag.version.preRelease,
-      })
-    }
-  }
-  return releases
-}
-
-const getReleaseArtifacts = async ({ dryRun, manifest, forceReleases }) => {
-  let pullRequests = []
-  let releases = []
-
-  if (forceReleases) {
-    releases = forceReleases
-  } else if (dryRun) {
-    pullRequests = await manifest.buildPullRequests()
-    releases = await manifest.buildReleases()
-  } else {
-    pullRequests = await manifest.createPullRequests()
-    releases = await manifest.createReleases()
-  }
-
-  return {
-    pullRequests: pullRequests.filter(Boolean),
-    releases: releases.filter(Boolean),
-  }
-}
-
-// XXX(hack): to get release please to recreate a pull request it needs
-// to have a different body string so we append a message a message that CI
-// is running. This will force release-please to rebase the PR but it
-// wont update the body again, so we only append to it.
-const touchPullRequest = async ({ octokit, owner, repo, releasePr }) => {
-  const id = process.env.GITHUB_RUN_ID
-    ? `by https://github.com/${owner}/${repo}/actions/runs/${process.env.GITHUB_RUN_ID}`
-    : `manually starting at ${new Date().toJSON()}`
-
-  await octokit.pulls.update({
-    owner,
-    repo,
-    pull_number: releasePr.number,
-    body: `${releasePr.body.trim()}\n- This PR is being recreated ${id}`,
-  })
-}
-
-const main = async ({ repo: fullRepo, token, dryRun, branch, forcePullRequest }) => {
-  if (!token) {
-    throw new Error('Token is required')
-  }
-
-  if (!fullRepo) {
-    throw new Error('Repo is required')
-  }
-
-  const {
-    github,
-    octokit,
-    manifest,
-    owner,
-    repo,
-    baseBranch,
-  } = await getManifest({ repo: fullRepo, token, branch })
-
-  let forceReleases = null
-
-  if (forcePullRequest) {
-    const { data: releasePr } = await octokit.rest.pulls.get({
-      owner,
-      repo,
-      pull_number: forcePullRequest,
-    })
-
-    if (!releasePr) {
-      throw new Error(`Could not find PR from number: ${forcePullRequest}`)
-    }
-
-    if (releasePr.state === 'open') {
-      await touchPullRequest({ octokit, owner, repo, releasePr })
-    } else if (releasePr.state === 'closed' && releasePr.merged) {
-      forceReleases = await getReleasesFromPr({ manifest, github, number: releasePr.number })
-    } else {
-      throw new Error(`Could not run workflow on PR with wrong state: ${JSON.stringify(
-        releasePr,
-        null,
-        2
-      )}`)
-    }
-  }
-
-  const { pullRequests, releases } = await getReleaseArtifacts({ dryRun, manifest, forceReleases })
-
-  // We only ever get a single pull request with our current release-please settings
-  // Update this if we start creating individual PRs per workspace release
-  const rootPr = pullRequests[0]
-  let rootRelease = releases[0]
-
-  logger.debug(`pull requests: ${pullRequests.length}`)
-  logger.debug(`releases: ${releases.length}`)
-
-  if (rootPr) {
-    logger.debug(`root pr: ${JSON.stringify(omit(rootPr, 'body'), null, 2)}`)
-  }
-
-  if (rootPr?.number) {
-    const commits = await octokit.paginate(octokit.rest.pulls.listCommits, {
-      owner,
-      repo,
-      pull_number: rootPr.number,
-    })
-
-    const prSha = commits?.[commits.length - 1]?.sha
-    if (!prSha) {
-      throw new Error(`Could not find a latest sha for pull request: ${rootPr.number}`)
-    }
-
-    rootPr.sha = prSha
-  }
-
-  for (const release of releases) {
-    const { path, sha } = release
-    const prefix = path === '.' ? '' : path
-    const isRoot = !prefix
-    const packagePath = `${prefix}/package.json`
-
-    logger.debug(`release: ${JSON.stringify({
-      ...omit(release, 'notes'),
-      isRoot,
-      prefix,
-    }, null, 2)}`)
-
-    const releasePrNumber = await octokit.rest.repos.listPullRequestsAssociatedWithCommit({
-      owner,
-      repo,
-      commit_sha: sha,
-      per_page: 1,
-    }).then(r => r.data[0]?.number)
-
-    if (!releasePrNumber) {
-      throw new Error(`Could not find release PR number from commit: "${sha}"`)
-    }
-
-    logger.debug(`pr from ${sha}: ${releasePrNumber}`)
-
-    const releasePkgName = await octokit.rest.repos.getContent({
-      owner,
-      repo,
-      ref: baseBranch,
-      path: packagePath,
-    }).then(r => {
-      try {
-        return JSON.parse(Buffer.from(r.data.content, r.data.encoding)).name
-      } catch {
-        return null
-      }
-    })
-
-    if (!releasePkgName) {
-      throw new Error(`Could not find package name for release at: "${packagePath}#${baseBranch}"`)
-    }
-
-    logger.debug(`pkg name from ${packagePath}#${baseBranch}: "${releasePkgName}"`)
-
-    release.prNumber = releasePrNumber
-    release.pkgName = releasePkgName
-    if (isRoot) {
-      rootRelease = release
-    }
-  }
-
-  return {
-    pr: rootPr ?? null,
-    release: rootRelease ?? null,
-    releases: releases.length ? releases : null,
-  }
-}
-
-module.exports = main

package/lib/release-please/node-workspace.js

@@ -1,192 +0,0 @@
-const localeCompare = require('@isaacs/string-locale-compare')('en')
-const { NodeWorkspace } = require('release-please/build/src/plugins/node-workspace.js')
-const { RawContent } = require('release-please/build/src/updaters/raw-content.js')
-const { jsonStringify } = require('release-please/build/src/util/json-stringify.js')
-const { addPath } = require('release-please/build/src/plugins/workspace.js')
-const { TagName } = require('release-please/build/src/util/tag-name.js')
-const { ROOT_PROJECT_PATH } = require('release-please/build/src/manifest.js')
-const makeGh = require('./github.js')
-const { link, code } = require('./util.js')
-
-const SCOPE = '__REPLACE_WORKSPACE_DEP__'
-const WORKSPACE_DEP = new RegExp(`${SCOPE}: (\\S+) (\\S+)`, 'gm')
-
-module.exports = class extends NodeWorkspace {
-  constructor (github, ...args) {
-    super(github, ...args)
-    this.gh = makeGh(github)
-  }
-
-  async preconfigure (strategiesByPath, commitsByPath, releasesByPath) {
-    // First build a list of all releases that will happen based on
-    // the conventional commits
-    const candidates = []
-    for (const path in strategiesByPath) {
-      const pullRequest = await strategiesByPath[path].buildReleasePullRequest(
-        commitsByPath[path],
-        releasesByPath[path]
-      )
-      if (pullRequest?.version) {
-        candidates.push({ path, pullRequest })
-      }
-    }
-
-    // Then build the graph of all those releases + any other connected workspaces
-    const { allPackages, candidatesByPackage } = await this.buildAllPackages(candidates)
-    const orderedPackages = this.buildGraphOrder(
-      await this.buildGraph(allPackages),
-      Object.keys(candidatesByPackage)
-    )
-
-    // Then build a list of all the updated versions
-    const updatedVersions = new Map()
-    for (const pkg of orderedPackages) {
-      const path = this.pathFromPackage(pkg)
-      const packageName = this.packageNameFromPackage(pkg)
-
-      let version = null
-      const existingCandidate = candidatesByPackage[packageName]
-      if (existingCandidate) {
-        // If there is an existing pull request use that version
-        version = existingCandidate.pullRequest.version
-      } else {
-        // Otherwise build another pull request (that will be discarded) just
-        // to see what the version would be if it only contained a deps commit.
-        // This is to make sure we use any custom versioning or release strategy.
-        const strategy = strategiesByPath[path]
-        const depsSection = strategy.changelogSections.find(c => c.section === 'Dependencies')
-        const releasePullRequest = await strategiesByPath[path].buildReleasePullRequest(
-          [{ message: `${depsSection.type}:` }],
-          releasesByPath[path]
-        )
-        version = releasePullRequest.version
-      }
-
-      updatedVersions.set(packageName, version)
-    }
-
-    // Save some data about the preconfiugred releases so we can look it up later
-    // when rewriting the changelogs
-    this.releasesByPackage = new Map()
-    this.pathsByComponent = new Map()
-
-    // Then go through all the packages again and add deps commits
-    // for each updated workspace
-    for (const pkg of orderedPackages) {
-      const path = this.pathFromPackage(pkg)
-      const packageName = this.packageNameFromPackage(pkg)
-      const graphPackage = this.packageGraph.get(pkg.name)
-
-      // Update dependency versions
-      for (const [depName, resolved] of graphPackage.localDependencies) {
-        const depVersion = updatedVersions.get(depName)
-        const isNotDir = resolved.type !== 'directory'
-
-        // Due to some bugs in release-please we need to create `deps:` commits
-        // for all dev and prod dependencies even though we normally would only
-        // do a `chore:` commit to bump a dev dep. The tradeoff is an extra
-        // patch release to workspaces that depend on other workspaces as dev
-        // dependencies.
-        if (depVersion && isNotDir) {
-          commitsByPath[path].push({
-            message: `deps(${SCOPE}): ${depName} ${depVersion.toString()}`,
-          })
-        }
-      }
-
-      const component = await strategiesByPath[path].getComponent()
-      this.pathsByComponent.set(component, path)
-      this.releasesByPackage.set(packageName, {
-        path,
-        component,
-      })
-    }
-
-    return strategiesByPath
-  }
-
-  // This is copied from the release-please node-workspace plugin
-  // except it only updates the package.json instead of appending
-  // anything to changelogs since we've already done that in preconfigure.
-  updateCandidate (candidate, pkg, updatedVersions) {
-    const newVersion = updatedVersions.get(pkg.name)
-    const graphPackage = this.packageGraph.get(pkg.name)
-
-    const updatedPackage = pkg.clone()
-    updatedPackage.version = newVersion.toString()
-    for (const [depName, resolved] of graphPackage.localDependencies) {
-      const depVersion = updatedVersions.get(depName)
-      if (depVersion && resolved.type !== 'directory') {
-        updatedPackage.updateLocalDependency(resolved, depVersion.toString(), '^')
-      }
-    }
-
-    for (const update of candidate.pullRequest.updates) {
-      if (update.path === addPath(candidate.path, 'package.json')) {
-        update.updater = new RawContent(
-          jsonStringify(updatedPackage.toJSON(), updatedPackage.rawContent)
-        )
-      }
-    }
-
-    return candidate
-  }
-
-  postProcessCandidates (candidates) {
-    for (const candidate of candidates) {
-      for (const release of candidate.pullRequest.body.releaseData) {
-        // Update notes with a link to each workspaces release notes
-        // now that we have all of the releases in a single pull request
-        release.notes = release.notes.replace(WORKSPACE_DEP, (_, depName, depVersion) => {
-          const { path, component } = this.releasesByPackage.get(depName)
-
-          const url = this.gh.release(new TagName(
-            depVersion,
-            component,
-            this.repositoryConfig[path].tagSeparator,
-            this.repositoryConfig[path].includeVInTag
-          ))
-
-          return `${link('Workspace', url)}: ${code(`${depName}@${depVersion}`)}`
-        })
-
-        // Find the associated changelog and update that too
-        const path = this.pathsByComponent.get(release.component)
-        for (const update of candidate.pullRequest.updates) {
-          if (update.path === addPath(path, 'CHANGELOG.md')) {
-            update.updater.changelogEntry = release.notes
-          }
-        }
-      }
-
-      // Sort root release to the top of the pull request
-      candidate.pullRequest.body.releaseData.sort((a, b) => {
-        const aPath = this.pathsByComponent.get(a.component)
-        const bPath = this.pathsByComponent.get(b.component)
-        if (aPath === ROOT_PROJECT_PATH) {
-          return -1
-        }
-        // release please pre sorts based on graph order so
-        // this is never called in normal circumstances
-        /* istanbul ignore next */
-        if (bPath === ROOT_PROJECT_PATH) {
-          return 1
-        }
-        return localeCompare(aPath, bPath)
-      })
-    }
-
-    return candidates
-  }
-
-  // Stub these methods with errors since the preconfigure method should negate these
-  // ever being called from the release please base class. If they are called then
-  // something has changed that would likely break us in other ways.
-  bumpVersion () {
-    throw new Error('Should not bump packages. This should be done in preconfigure.')
-  }
-
-  newCandidate () {
-    throw new Error('Should not create new candidates. This should be done in preconfigure.')
-  }
-}

package/lib/release-please/util.js

@@ -1,14 +0,0 @@
-const semver = require('semver')
-
-module.exports.specRe = new RegExp(`([^\\s]+@${semver.src[semver.tokens.FULLPLAIN]})`, 'g')
-
-module.exports.code = (c) => `\`${c}\``
-module.exports.link = (text, url) => url ? `[${text}](${url})` : text
-module.exports.list = (text) => `* ${text}`
-
-module.exports.dateFmt = (date = new Date()) => {
-  const year = date.getFullYear()
-  const month = (date.getMonth() + 1).toString().padStart(2, '0')
-  const day = date.getDate().toString().padStart(2, '0')
-  return [year, month, day].join('-')
-}

package/lib/release-please/version.js

@@ -1,103 +0,0 @@
-const semver = require('semver')
-const { Version } = require('release-please/build/src/version.js')
-
-// A way to compare the "level" of a release since we ignore some things during prereleases
-const LEVELS = new Map([['prerelease', 4], ['major', 3], ['minor', 2], ['patch', 1]]
-  .flatMap((kv) => [kv, kv.slice().reverse()]))
-
-const parseVersion = (v) => {
-  const { prerelease, minor, patch, version } = semver.parse(v)
-
-  // This looks at whether there are 0s in certain positions of the version
-  // 1.0.0 => major
-  // 1.5.0 => minor
-  // 1.5.6 => patch
-  const release = !patch
-    ? (minor ? LEVELS.get('minor') : LEVELS.get('major'))
-    : LEVELS.get('patch')
-
-  // Keep track of whether the version has any prerelease identifier
-  const hasPre = prerelease.length > 0
-  // Even if it is a prerelease version, this might be an empty string
-  const preId = prerelease.filter(p => typeof p === 'string').join('.')
-
-  return {
-    version,
-    release,
-    prerelease: hasPre,
-    preId,
-  }
-}
-
-const parseCommits = (commits, prerelease) => {
-  // Default is a patch level change
-  let release = LEVELS.get('patch')
-
-  for (const commit of commits) {
-    if (commit.breaking) {
-      // If any breaking commit is present, its a major
-      release = LEVELS.get('major')
-      break
-    } else if (['feat', 'feature'].includes(commit.type)) {
-      // Otherwise a feature is a minor release
-      release = LEVELS.get('minor')
-    }
-  }
-
-  return {
-    release,
-    prerelease: !!prerelease,
-  }
-}
-
-const preInc = ({ version, prerelease, preId }, release) => {
-  if (!release.startsWith('pre')) {
-    release = `pre${release}`
-  }
-
-  // `pre` is the default prerelease identifier when creating a new
-  // prerelease version
-  return semver.inc(version, release, prerelease ? preId : 'pre')
-}
-
-const semverToVersion = (v) => {
-  const { major, minor, patch, prerelease } = semver.parse(v)
-  return new Version(major, minor, patch, prerelease.join('.'))
-}
-
-// This does not account for pre v1 semantics since we don't publish those
-// Always 1.0.0 your initial versions!
-module.exports = class DefaultVersioningStrategy {
-  constructor (options) {
-    this.prerelease = options.prerelease
-  }
-
-  bump (currentVersion, commits) {
-    const next = parseCommits(commits, this.prerelease)
-    // Release please passes in a version class with a toString() method
-    const current = parseVersion(currentVersion.toString())
-
-    // This is a special case where semver doesn't align exactly with what we want.
-    // We are currently at a prerelease and our next is also a prerelease.
-    // In this case we want to ignore the release type we got from our conventional
-    // commits if the "level" of the next release is <= the level of the current one.
-    //
-    // This has the effect of only bumping the prerelease identifier and nothing else
-    // when we are actively working (and breaking) a prerelease. For example:
-    //
-    // `9.0.0-pre.4` + breaking changes = `9.0.0-pre.5`
-    // `8.5.0-pre.4` + breaking changes = `9.0.0-pre.0`
-    // `8.5.0-pre.4` + feature or patch changes = `8.5.0-pre.5`
-    if (current.prerelease && next.prerelease && next.release <= current.release) {
-      next.release = LEVELS.get('prerelease')
-    }
-
-    const release = LEVELS.get(next.release)
-    const releaseVersion = next.prerelease
-      ? preInc(current, release)
-      : semver.inc(current.version, release)
-    return semverToVersion(releaseVersion)
-  }
-}
-
-module.exports.semverToVersion = semverToVersion