@npmcli/template-oss 4.20.0 → 4.21.0

package/lib/release/changelog.js

@@ -0,0 +1,184 @@
+const { link, code, wrapSpecs, list, formatDate, makeGitHubUrl } = require('./util')
+
+class Changelog {
+  static BREAKING = 'breaking'
+
+  #title
+  #entries = {}
+  #types = new Set([Changelog.BREAKING])
+  #titles = {
+    [Changelog.BREAKING]: '⚠️ BREAKING CHANGES',
+  }
+
+  constructor ({ version, url, sections }) {
+    this.#title = `## ${url ? link(version, url) : version} (${formatDate()})`
+    for (const section of sections) {
+      this.#types.add(section.type)
+      this.#titles[section.type] = section.section
+    }
+  }
+
+  add (type, ...entries) {
+    if (!this.#types.has(type) || !entries.length) {
+      return
+    }
+    this.#entries[type] ??= []
+    this.#entries[type].push(...entries)
+  }
+
+  toString () {
+    const body = [this.#title]
+    for (const type of this.#types) {
+      const title = this.#titles[type]
+      if (this.#entries[type]?.length) {
+        body.push(
+          `### ${title}`,
+          this.#entries[type].map(list).join('\n')
+        )
+      }
+    }
+    return body.join('\n\n').trim()
+  }
+}
+
+class ChangelogNotes {
+  #owner
+  #repo
+  #rest
+  #graphql
+  #ghUrl
+
+  constructor (github) {
+    this.#owner = github.repository.owner
+    this.#repo = github.repository.repo
+    this.#rest = github.octokit.rest
+    this.#graphql = github.graphql
+    this.#ghUrl = makeGitHubUrl(this.#owner, this.#repo)
+  }
+
+  async #getAuthorsForCommits (commits) {
+    const shas = commits
+      .filter(c => c.type !== 'deps')
+      .map(c => c.sha)
+      .filter(Boolean)
+
+    if (!shas.length) {
+      return {}
+    }
+
+    const authorsByCommit = {}
+    const { repository } = await this.#graphql(
+        `fragment CommitAuthors on GitObject {
+          ... on Commit {
+            authors (first:10) {
+              nodes {
+                user { login }
+                name
+              }
+            }
+          }
+        }
+        query {
+          repository (owner:"${this.#owner}", name:"${this.#repo}") {
+            ${shas.map((s) => {
+              return `_${s}: object (expression: "${s}") { ...CommitAuthors }`
+            })}
+          }
+        }`
+    )
+    for (const [key, commit] of Object.entries(repository)) {
+      if (commit) {
+        authorsByCommit[key.slice(1)] = commit.authors.nodes
+          .map((a) => a.user && a.user.login ? `@${a.user.login}` : a.name)
+          .filter(Boolean)
+      }
+    }
+    return authorsByCommit
+  }
+
+  async #getPullRequestForCommits (commits) {
+    const shas = commits
+      .filter(c => !c.pullRequest?.number)
+      .map(c => c.sha)
+      .filter(Boolean)
+
+    if (!shas.length) {
+      return {}
+    }
+
+    const pullRequestsByCommit = {}
+    for (const sha of shas) {
+      pullRequestsByCommit[sha] = await this.#rest.repos.listPullRequestsAssociatedWithCommit({
+        owner: this.#owner,
+        repo: this.#repo,
+        commit_sha: sha,
+        per_page: 1,
+      })
+        .then((r) => r.data[0].number)
+        .catch(() => null)
+    }
+    return pullRequestsByCommit
+  }
+
+  #buildEntry (commit, { authors = [], pullRequest }) {
+    const entry = []
+
+    if (commit.sha) {
+      // A link to the commit
+      entry.push(link(code(commit.sha.slice(0, 7)), this.#ghUrl('commit', commit.sha)))
+    }
+
+    // A link to the pull request if the commit has one
+    const commitPullRequest = commit.pullRequest?.number ?? pullRequest
+    if (commitPullRequest) {
+      entry.push(link(`#${commitPullRequest}`, this.#ghUrl('pull', commitPullRequest)))
+    }
+
+    // The title of the commit, with the optional scope as a prefix
+    const scope = commit.scope && `${commit.scope}:`
+    const subject = wrapSpecs(commit.bareMessage)
+    entry.push([scope, subject].filter(Boolean).join(' '))
+
+    // A list og the authors github handles or names
+    if (authors.length) {
+      entry.push(`(${authors.join(', ')})`)
+    }
+
+    return entry.join(' ')
+  }
+
+  async buildNotes (commits, { version, previousTag, currentTag, changelogSections }) {
+    // get authors for commits for each sha
+    const authorsByCommit = await this.#getAuthorsForCommits(commits)
+
+    // when rebase merging multiple commits with a single PR, only the first commit
+    // will have a pr number when coming from release-please. this check will manually
+    // lookup commits without a pr number and find one if it exists
+    const pullRequestByCommit = await this.#getPullRequestForCommits(commits)
+
+    const changelog = new Changelog({
+      version,
+      url: previousTag
+        ? this.#ghUrl('compare', `${previousTag.toString()}...${currentTag.toString()}`)
+        : null,
+      sections: changelogSections,
+    })
+
+    for (const commit of commits) {
+      // Collect commits by type
+      changelog.add(commit.type, this.#buildEntry(commit, {
+        authors: authorsByCommit[commit.sha],
+        pullRequest: pullRequestByCommit[commit.sha],
+      }))
+
+      // And breaking changes to its own section
+      changelog.add(Changelog.BREAKING, ...commit.notes
+        .filter(n => n.title === 'BREAKING CHANGE')
+        .map(n => n.text))
+    }
+
+    return changelog.toString()
+  }
+}
+
+module.exports = ChangelogNotes

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

@@ -0,0 +1,107 @@
+const localeCompare = require('@isaacs/string-locale-compare')('en')
+const { ManifestPlugin } = require('release-please/build/src/plugin.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 { DEPS, link, wrapSpecs } = require('./util.js')
+
+const WORKSPACE_MESSAGE = (name, version) => `${DEPS}(workspace): ${name}@${version}`
+const WORKSPACE_SCOPE = /(?<scope>workspace): `?(?<name>\S+?)[@\s](?<version>\S+?)`?$/gm
+
+module.exports = class extends ManifestPlugin {
+  static WORKSPACE_MESSAGE = WORKSPACE_MESSAGE
+
+  #releasesByPackage = new Map()
+  #pathsByComponent = new Map()
+
+  async preconfigure (strategiesByPath) {
+    // First build a list of all releases that will happen based on
+    // the conventional commits
+    for (const path in strategiesByPath) {
+      const component = await strategiesByPath[path].getComponent()
+      const packageName = await await strategiesByPath[path].getDefaultPackageName()
+      this.#pathsByComponent.set(component, path)
+      this.#releasesByPackage.set(packageName, { path, component })
+    }
+
+    return strategiesByPath
+  }
+
+  run (candidates) {
+    this.#rewriteWorkspaceChangelogItems(candidates)
+    this.#sortReleases(candidates)
+    return candidates
+  }
+
+  // I don't like how release-please formats workspace changelog entries
+  // so this rewrites them to look like the rest of our changelog. This can't
+  // be part of the changelog plugin since they are written after that by the
+  // node-workspace plugin. A possible PR to release-please could add an option
+  // to customize these or run them through the changelog notes generator.
+  #rewriteWorkspaceChangelogItems (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_SCOPE, (...args) => {
+            const { scope, name, version } = args.pop()
+            const { path, component } = this.#releasesByPackage.get(name)
+            const { tagSeparator, includeVInTag } = this.repositoryConfig[path]
+            const { repository: { owner, repo } } = this.github
+            const tag = new TagName(version, component, tagSeparator, includeVInTag).toString()
+            const url = `https://github.com/${owner}/${repo}/releases/tag/${tag}`
+            return `${link(scope, url)}: ${wrapSpecs(`${name}@${version}`)}`
+          })
+
+        // remove the other release please dependencies list which always starts with
+        // the following line and then each line is indented. so we search for the line
+        // and remove and indented lines until the next non indented line.
+        let foundRemoveStart = false
+        let foundRemoveEnd = false
+        release.notes = release.notes
+          .split('\n')
+          .filter((line) => {
+            if (line === '* The following workspace dependencies were updated') {
+              foundRemoveStart = true
+            } else if (foundRemoveStart && !foundRemoveEnd) {
+              // TODO: test when inserted dependencies is not the last thing in the changelog
+              /* istanbul ignore next */
+              if (!line || !line.startsWith(' ')) {
+                foundRemoveEnd = true
+              }
+            }
+            // If we found the start, remove all lines until we've found the end
+            return foundRemoveStart ? foundRemoveEnd : true
+          })
+          .join('\n')
+
+        // 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
+  // release please pre sorts based on graph order so
+  #sortReleases (candidates) {
+    for (const candidate of candidates) {
+      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
+        }
+        if (bPath === ROOT_PROJECT_PATH) {
+          return 1
+        }
+        return localeCompare(aPath, bPath)
+      })
+    }
+  }
+}

package/lib/release/node-workspace.js

@@ -0,0 +1,95 @@
+const { NodeWorkspace } = require('release-please/build/src/plugins/node-workspace')
+const { parseConventionalCommits } = require('release-please/build/src/commit')
+const { DEPS } = require('./util')
+const { WORKSPACE_MESSAGE } = require('./node-workspace-format')
+
+// This adds a preconfigure method to the release-please node-workspace plugin
+// which fixes https://github.com/googleapis/release-please/issues/2089 for our
+// use case. We should attempt to upstream this to release-please but it
+// fundamentally changes the way the node-workspace plugin behaves so it might
+// not be easy to land. For now we extend the base plugin and add one method
+// which is much better than previously when we needed to fork and maintain
+// release-please ourselves.
+class NpmNodeWorkspace extends NodeWorkspace {
+  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(
+        parseConventionalCommits(commitsByPath[path]),
+        releasesByPath[path]
+      )
+      // Release please types say this sometimes will return undefined but I could not
+      // get any scenario where that was the case. If it was undefined we would want to
+      // just ignore it anyway.
+      /* istanbul ignore else */
+      if (pullRequest) {
+        candidates.push({
+          path,
+          pullRequest,
+          config: this.repositoryConfig[path],
+        })
+      }
+    }
+
+    // Then build the graph of all those releases + any other connected workspaces
+    const { allPackages, candidatesByPackage } = await this.buildAllPackages(candidates)
+    const graph = await this.buildGraph(allPackages)
+    const packageNamesToUpdate = this.packageNamesToUpdate(graph, candidatesByPackage)
+    const graphPackages = this.buildGraphOrder(graph, packageNamesToUpdate)
+
+    // Then build a list of all the updated versions
+    const updatedVersions = {}
+    for (const pkg of graphPackages) {
+      const path = this.pathFromPackage(pkg)
+      const packageName = this.packageNameFromPackage(pkg)
+      const existingCandidate = candidatesByPackage[packageName]
+
+      if (existingCandidate) {
+        // If there is an existing pull request use that version
+        updatedVersions[packageName] = 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 releasePullRequest = await strategiesByPath[path].buildReleasePullRequest(
+          parseConventionalCommits([{ message: `${DEPS}: ${Math.random()}` }]),
+          releasesByPath[path]
+        )
+        updatedVersions[packageName] = releasePullRequest?.version
+      }
+    }
+
+    // Then go through all the packages again and add deps commits for each
+    // updated workspace
+    for (const pkg of graphPackages) {
+      const path = this.pathFromPackage(pkg)
+      const packageName = this.packageNameFromPackage(pkg)
+      const graphPackage = graph.get(packageName)
+
+      // Update dependency versions add a deps commit to each path so it gets
+      // processed later. This else never happens in our cases because our
+      // packages always have deps, but keeping this around to make it easier to
+      // upstream in the future.
+      /* istanbul ignore else */
+      if (graphPackage.deps) {
+        for (const depName of graphPackage.deps) {
+          const depVersion = updatedVersions[depName]
+          // Same as the above check, we always have a version here but technically
+          // we could not in which it would be safe to ignore it.
+          /* istanbul ignore else */
+          if (depVersion) {
+            commitsByPath[path].push({
+              message: WORKSPACE_MESSAGE(depName, depVersion.toString()),
+            })
+          }
+        }
+      }
+    }
+
+    return strategiesByPath
+  }
+}
+
+module.exports = NpmNodeWorkspace

package/lib/release/release-manager.js

@@ -0,0 +1,287 @@
+const { Octokit } = require('@octokit/rest')
+const core = require('@actions/core')
+const { join } = require('path')
+const semver = require('semver')
+const assert = require('assert')
+const dedent = require('dedent')
+const mapWorkspaces = require('@npmcli/map-workspaces')
+const { request: fetch } = require('undici')
+const { getPublishTag, block, noop } = require('./util')
+
+class ReleaseManager {
+  #octokit
+  #owner
+  #repo
+  #cwd
+  #pr
+  #backport
+  #defaultTag
+  #lockfile
+  #publish
+
+  #info
+
+  constructor ({
+    token,
+    repo,
+    cwd = process.cwd(),
+    pr,
+    backport,
+    defaultTag,
+    lockfile,
+    publish,
+    silent,
+  }) {
+    assert(token, 'GITHUB_TOKEN is required')
+    assert(repo, 'GITHUB_REPOSITORY is required')
+    assert(cwd, 'cwd is required')
+    assert(pr, 'pr is required')
+    assert(defaultTag, 'defaultTag is required')
+
+    this.#octokit = new Octokit({ auth: token })
+    this.#owner = repo.split('/')[0]
+    this.#repo = repo.split('/')[1]
+    this.#cwd = cwd
+    this.#pr = pr
+    this.#backport = backport
+    this.#defaultTag = defaultTag
+    this.#lockfile = lockfile
+    this.#publish = publish
+
+    this.#info = silent ? noop : core.info
+  }
+
+  static async run (options) {
+    const manager = new ReleaseManager(options)
+    return manager.run()
+  }
+
+  async run () {
+    const { data: pullRequest } = await this.#octokit.rest.pulls.get({
+      owner: this.#owner,
+      repo: this.#repo,
+      pull_number: this.#pr,
+    })
+
+    const [release, workspaces] = await this.#getPrReleases({ pullRequest })
+    const releaseItems = await this.#getReleaseProcess({ release, workspaces })
+
+    this.#info(`Filtered ${releaseItems.length} release process items:`)
+    this.#info(releaseItems.map(r => r.split('\n')[0].replace('- [ ] ', '')).join(', '))
+
+    const checklist = releaseItems
+      .join('\n\n')
+      .replace(/<PR-NUMBER>/g, pullRequest.number)
+      .replace(/<RELEASE-BRANCH>/g, pullRequest.head.ref)
+      .replace(/<BASE-BRANCH>/g, pullRequest.base.ref)
+      .replace(/<MAJOR>/g, release.major)
+      .replace(/<X\.Y\.Z>/g, release.version)
+      .replace(/<GITHUB-RELEASE-LINK>/g, release.url)
+      .replace(/<PUBLISH-FLAGS>/g, release.flags)
+      .replace(/^(\s*\S.*)(-w <WS-PKG-N>)$/gm, workspaces.map(w => `$1${w.flags}`).join('\n'))
+      .trim()
+
+    return `### Release Checklist for ${release.tag}\n\n${checklist}`
+  }
+
+  async #getPrReleases ({ pullRequest }) {
+    return /<details><summary>.*<\/summary>/.test(pullRequest.body)
+      ? await this.#getPrMonoRepoReleases({ pullRequest })
+      : [this.#getPrRootRelease({ pullRequest }), []]
+  }
+
+  async #getPrMonoRepoReleases ({ pullRequest }) {
+    const releases = pullRequest.body.match(/<details><summary>.*<\/summary>/g)
+    this.#info(`Found ${releases.length} releases`)
+
+    const workspacesComponents = [...await mapWorkspaces({
+      cwd: this.#cwd,
+      pkg: require(join(this.#cwd, 'package.json')),
+    })]
+      .reduce((acc, [k]) => {
+        const wsComponentName = k.startsWith('@') ? k.split('/')[1] : k
+        acc[wsComponentName] = k
+        return acc
+      }, {})
+
+    const MONO_VERSIONS = /<details><summary>(?:(.*?):\s)?(.*?)<\/summary>/
+
+    return releases.reduce((acc, r) => {
+      const [, name, version] = r.match(MONO_VERSIONS)
+
+      const release = this.#getPrReleaseInfo({
+        pullRequest,
+        name,
+        version,
+        workspaces: workspacesComponents,
+      })
+
+      if (release.isRoot) {
+        this.#info(`Found root: ${JSON.stringify(release)}`)
+        acc[0] = release
+      } else {
+        this.#info(`Found workspace: ${JSON.stringify(release)}`)
+        acc[1].push(release)
+      }
+
+      return acc
+    }, [null, []])
+  }
+
+  #getPrRootRelease ({ pullRequest }) {
+    this.#info('Found no monorepo, checking for single root version')
+
+    const match = pullRequest.body.match(/\n##\s\[(.*?)\]/)
+    assert(match, 'Could not find single root version in body')
+
+    const version = match[1]
+    this.#info(`Found version: ${version}`)
+
+    return this.#getPrReleaseInfo({ pullRequest, version })
+  }
+
+  #getPrReleaseInfo ({ pullRequest, workspaces = {}, name = null, version: rawVersion }) {
+    const version = semver.parse(rawVersion)
+    const prerelease = !!version.prerelease.length
+    const tag = `${name ? `${name}-` : ''}v${rawVersion}`
+    const publishTag = getPublishTag(rawVersion, {
+      backport: this.#backport,
+      defaultTag: this.#defaultTag,
+    })
+
+    return {
+      isRoot: !name,
+      tag,
+      prerelease,
+      version: rawVersion,
+      major: version.major,
+      url: `https://github.com/${pullRequest.base.repo.full_name}/releases/tag/${tag}`,
+      flags: [
+        workspaces[name] ? `-w ${workspaces[name]}` : null,
+        `--tag=${publishTag}`,
+      ].filter(Boolean).join(' '),
+    }
+  }
+
+  async #getReleaseProcess ({ release, workspaces }) {
+    const RELEASE_LIST_ITEM = /^\d+\.\s/gm
+
+    this.#info(`Fetching release process from repo wiki: ${this.#owner}/${this.#repo}`)
+
+    const releaseProcess = await fetch(
+      `https://raw.githubusercontent.com/wiki/${this.#owner}/${this.#repo}/Release-Process.md`
+    )
+      .then(r => {
+        // If the url fails with anything but a 404 we want the process to blow
+        // up because that means something is very wrong. This is a rare edge
+        // case that isn't worth testing.
+        /* istanbul ignore else */
+        if (r.statusCode === 200) {
+          this.#info('Found release process from wiki')
+          return r.body.text()
+        } else if (r.statusCode === 404) {
+          this.#info('No release process found in wiki, falling back to default process')
+          return this.#getReleaseSteps()
+        } else {
+          throw new Error(`Release process fetch failed with status: ${r.statusCode}`)
+        }
+      })
+
+    // XXX: the release steps need to always be the last thing in the doc for this to work
+    const releaseLines = releaseProcess.split('\n')
+    const releaseStartLine = releaseLines.reduce((acc, l, i) => l.match(/^#+\s/) ? i : acc, 0)
+    const section = releaseLines.slice(releaseStartLine).join('\n')
+
+    return section
+      .split({
+        [Symbol.split]: (str) => {
+          const [, ...matches] = str.split(RELEASE_LIST_ITEM)
+          this.#info(`Found ${matches.length} release items`)
+          return matches.map((m) => `- [ ] <STEP_INDEX>. ${m}`.trim())
+        },
+      })
+      .filter((item) => {
+        if (release.prerelease && item.includes('> NOT FOR PRERELEASE')) {
+          return false
+        }
+
+        if (!workspaces.length && item.includes('Publish workspaces')) {
+          return false
+        }
+
+        return true
+      })
+      .map((item, index) => item.replace('<STEP_INDEX>', index + 1))
+  }
+
+  #getReleaseSteps () {
+    const R = `-R ${this.#owner}/${this.#repo}`
+
+    const manualSteps = `
+      1. Checkout the release branch and test
+  
+          ${block('sh')}
+          gh pr checkout <PR-NUMBER> --force
+          npm ${this.#lockfile ? 'ci' : 'update'}
+          npm test
+          gh pr checks <PR-NUMBER> ${R} --watch
+          ${block()}
+  
+      1. Publish workspaces
+  
+          ${block('sh')}
+          npm publish -w <WS-PKG-N>
+          ${block()}
+  
+      1. Publish
+  
+          ${block('sh')}
+          npm publish <PUBLISH-FLAGS>
+          ${block()}
+  
+      1. Merge release PR
+  
+          ${block('sh')}
+          gh pr merge <PR-NUMBER> ${R} --squash
+          git checkout <BASE-BRANCH>
+          git fetch
+          git reset --hard origin/<BASE-BRANCH>
+          ${block()}
+    `
+
+    const autoSteps = `
+      1. Approve this PR
+  
+          ${block('sh')}
+          gh pr review <PR-NUMBER> ${R} --approve
+          ${block()}
+  
+      1. Merge release PR :rotating_light: Merging this will auto publish :rotating_light:
+  
+          ${block('sh')}
+          gh pr merge <PR-NUMBER> ${R} --squash
+          ${block()}
+    `
+
+    /* eslint-disable max-len */
+    const alwaysSteps = `
+      1. Check For Release Tags
+  
+          Release Please will run on the just pushed release commit and create GitHub releases and tags for each package.
+  
+          ${block('sh')}
+          gh run watch ${R} $(gh run list ${R} -w release -b <BASE-BRANCH> -L 1 --json databaseId -q ".[0].databaseId")
+          ${block()}
+    `
+    /* eslint-enable max-len */
+
+    return [
+      this.#publish ? autoSteps : manualSteps,
+      alwaysSteps,
+    ]
+      .map(v => dedent(v))
+      .join('\n\n')
+  }
+}
+
+module.exports = ReleaseManager