bulk-release 2.21.0 → 3.0.0

package/src/test/js/utils/mock.js

@@ -0,0 +1,132 @@
+import {PassThrough} from 'node:stream'
+import {EventEmitter} from 'node:events'
+import {tempy} from 'zx-extra'
+
+export const tmpDir = tempy.temporaryDirectory()
+
+function proc(stdout = '', code = 0) {
+  const p = new EventEmitter()
+  p.stdout = new PassThrough()
+  p.stderr = new PassThrough()
+  p.stdin = new PassThrough()
+  p.pid = 1
+  process.nextTick(() => {
+    p.stdout.end(stdout)
+    p.stderr.end('')
+    p.emit('close', code, null)
+    p.emit('exit', code, null)
+  })
+  return p
+}
+
+export function createMock(responses = []) {
+  const calls = []
+  const spawn = (cmd, args) => {
+    const command = args?.[args.length - 1] || cmd
+    calls.push(command)
+    for (const [pattern, output, code] of responses) {
+      if (typeof pattern === 'string' ? command.includes(pattern) : pattern.test(command))
+        return proc(output, code ?? 0)
+    }
+    return proc('')
+  }
+  return {spawn, calls}
+}
+
+export const has = (calls, pattern) =>
+  calls.some(c => typeof pattern === 'string' ? c.includes(pattern) : pattern.test(c))
+
+export const gitResponses = (overrides = {}) => [
+  ['git rev-parse --show-toplevel', overrides.root ?? tmpDir],
+  ['git rev-parse HEAD', overrides.sha ?? 'abc1234567890'],
+  ['git config --get remote.origin.url', overrides.origin ?? 'https://github.com/test-org/test-repo.git'],
+  ['git tag -l', overrides.tags ?? ''],
+  [/git log .+--format/, overrides.log ?? ''],
+  ['git config user.name', ''],
+  ['git config user.email', ''],
+  [/git tag -m/, ''],
+  ['git push', ''],
+  ['git fetch', ''],
+  ['git clone', ''],
+  ['git init', ''],
+  ['git add', ''],
+  ['git commit', ''],
+  [/git remote/, ''],
+  [/git config --unset/, ''],
+]
+
+export const npmResponses = (overrides = {}) => [
+  ['npm --version', overrides.npmVersion ?? '10.0.0'],
+  ['npm publish', ''],
+  ['npm view', overrides.view ?? ''],
+]
+
+export const defaultResponses = (overrides = {}) => [
+  ...gitResponses(overrides),
+  ...npmResponses(overrides),
+  [/curl/, overrides.curl ?? '{}'],
+  [/echo/, ''],
+]
+
+export const makePkg = (overrides = {}) => ({
+  name: overrides.name ?? 'test-pkg',
+  version: overrides.version ?? '1.0.1',
+  absPath: overrides.absPath ?? `${tmpDir}/packages/test-pkg`,
+  relPath: overrides.relPath ?? 'packages/test-pkg',
+  manifest: {
+    name: overrides.name ?? 'test-pkg',
+    version: overrides.version ?? '1.0.1',
+    private: overrides.private ?? false,
+    ...overrides.manifest,
+  },
+  config: {
+    buildCmd: 'echo build',
+    testCmd: 'echo test',
+    gitCommitterName: 'Bot',
+    gitCommitterEmail: 'bot@test.com',
+    ghBasicAuth: 'x-access-token:ghp_test',
+    ghToken: 'ghp_test',
+    npmPublish: true,
+    npmFetch: false,
+    changelog: 'changelog',
+    ...overrides.config,
+  },
+  changes: overrides.changes ?? [{group: 'Fixes', releaseType: 'patch', change: 'fix: test'}],
+  releaseType: overrides.releaseType ?? 'patch',
+  tag: overrides.tag ?? '2026.1.1-test-pkg.1.0.1-f0',
+  latest: overrides.latest ?? {tag: null, meta: null},
+  ctx: overrides.ctx ?? null,
+  ...overrides.extra,
+})
+
+export const makeCtx = (overrides = {}) => ({
+  cwd: overrides.cwd ?? tmpDir,
+  env: {PATH: process.env.PATH, HOME: process.env.HOME, GH_TOKEN: 'ghp_test', NPM_TOKEN: 'npm_test', ...overrides.env},
+  flags: {build: true, test: true, publish: true, ...overrides.flags},
+  root: {absPath: tmpDir, ...overrides.root},
+  packages: overrides.packages ?? {},
+  queue: overrides.queue ?? [],
+  prev: overrides.prev ?? {},
+  graphs: overrides.graphs ?? {},
+  report: overrides.report ?? makeReport(),
+  channels: overrides.channels ?? [],
+  run: overrides.run ?? (async () => {}),
+  git: {sha: 'abc1234567890', root: tmpDir, ...overrides.git},
+})
+
+export const makeReport = () => {
+  const events = []
+  return {
+    status: 'initial',
+    events,
+    packages: {},
+    log(...chunks) { events.push({level: 'info', msg: chunks}); return this },
+    warn(...chunks) { events.push({level: 'warn', msg: chunks}); return this },
+    error(...chunks) { events.push({level: 'error', msg: chunks}); return this },
+    set() { return this },
+    get() { return this },
+    setStatus() { return this },
+    getStatus() { return this },
+    save() { return this },
+  }
+}

package/src/test/js/{test-utils.js → utils/repo.js}

@@ -2,7 +2,7 @@ import {fs, path, tempy, $, sleep} from 'zx-extra'
 import {fileURLToPath} from 'node:url'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
-export const fixtures = path.resolve(__dirname, '../fixtures')
+export const fixtures = path.resolve(__dirname, '../../fixtures')
 
 export const createNpmRegistry = () => {
   let p
@@ -10,8 +10,8 @@ export const createNpmRegistry = () => {
   return {
     address: $.env.NPM_REGISTRY || 'http://localhost:4873',
     async start() {
-      fs.removeSync(path.resolve(__dirname, '../../../storage'))
-      const config = path.resolve(__dirname, '../../../verdaccio.config.yaml')
+      fs.removeSync(path.resolve(__dirname, '../../../../storage'))
+      const config = path.resolve(__dirname, '../../../../verdaccio.config.yaml')
       p = $({preferLocal: true})`verdaccio --config ${config}`
 
       return sleep(1000)

package/src/main/js/processor/publishers/changelog.js

@@ -1,26 +0,0 @@
-import {$} from 'zx-extra'
-import {queuefy} from 'queuefy'
-import {fetchRepo, pushCommit} from '../api/git.js'
-import {formatReleaseNotes} from '../generators/notes.js'
-import {log} from '../log.js'
-import {asTuple, msgJoin} from '../../util.js'
-
-const run = queuefy(async (pkg) => {
-  const {absPath: cwd, config: {changelog: opts, gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
-  if (!opts) return
-
-  log.info('push changelog')
-  const [branch = 'changelog', file = `${pkg.name.replace(/[^a-z0-9-]/ig, '')}-changelog.md`, ..._msg] = asTuple(opts, ['branch', 'file', 'msg'])
-  const _cwd = await fetchRepo({cwd, branch, basicAuth})
-  const msg = msgJoin(_msg, pkg, 'chore: update changelog ${{name}}')
-  const releaseNotes = await formatReleaseNotes(pkg)
-
-  await $({cwd: _cwd})`echo ${releaseNotes}"\n$(cat ./${file})" > ./${file}`
-  await pushCommit({cwd, branch, msg, gitCommitterEmail, gitCommitterName, basicAuth})
-})
-
-export default {
-  name: 'changelog',
-  when: (pkg) => !!pkg.config.changelog,
-  run,
-}

package/src/main/js/processor/publishers/gh-pages.js

@@ -1,32 +0,0 @@
-import {queuefy} from 'queuefy'
-import {path} from 'zx-extra'
-import {log} from '../log.js'
-import {pushCommit} from '../api/git.js'
-import {asTuple, msgJoin} from '../../util.js'
-
-const run = queuefy(async (pkg) => {
-  const {config: {ghPages: opts, gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
-  if (!opts) return
-
-  const [branch = 'gh-pages', from = 'docs', to = '.', ..._msg] = asTuple(opts, ['branch', 'from', 'to', 'msg'])
-  const msg = msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}')
-
-  log.info(`publish docs to ${branch}`)
-
-  await pushCommit({
-    cwd: path.join(pkg.absPath, from),
-    from: '.',
-    to,
-    branch,
-    msg,
-    gitCommitterEmail,
-    gitCommitterName,
-    basicAuth,
-  })
-})
-
-export default {
-  name: 'gh-pages',
-  when: (pkg) => !!pkg.config.ghPages,
-  run,
-}

package/src/main/js/processor/publishers/gh-release.js

@@ -1,41 +0,0 @@
-import {log} from '../log.js'
-import {getRepo, getRoot} from '../api/git.js'
-import {ghCreateRelease, ghDeleteReleaseByTag, ghUploadAssets} from '../api/gh.js'
-import {formatTag} from '../generators/tag.js'
-import {formatReleaseNotes} from '../generators/notes.js'
-
-const run = async (pkg) => {
-  const {ghBasicAuth: basicAuth, ghToken, ghAssets, ghApiUrl} = pkg.config
-  if (!ghToken) return null
-
-  log.info('create gh release')
-
-  const now = Date.now()
-  const {name, version, absPath: cwd, tag = formatTag({name, version})} = pkg
-  const {repoName} = await getRepo(cwd, {basicAuth})
-  const body = await formatReleaseNotes(pkg)
-  const res = await ghCreateRelease({ghApiUrl, ghToken, repoName, tag, body})
-
-  if (ghAssets?.length) {
-    // GH API returns a pseudo-url `...releases/110103594/assets{?name,label}` — strip the template.
-    const uploadUrl = res.upload_url.slice(0, res.upload_url.indexOf('{'))
-    await ghUploadAssets({ghToken, ghAssets, uploadUrl, cwd})
-  }
-
-  log.info(`duration gh release: ${Date.now() - now}`)
-}
-
-const undo = async (pkg, {tag}) => {
-  const {ghBasicAuth: basicAuth, ghToken, ghApiUrl} = pkg.config
-  if (!ghToken) return
-  const cwd = await getRoot(pkg.absPath)
-  const {repoName} = await getRepo(cwd, {basicAuth})
-  await ghDeleteReleaseByTag({ghApiUrl, ghToken, repoName, tag})
-}
-
-export default {
-  name: 'gh-release',
-  when: (pkg) => !!pkg.config.ghToken,
-  run,
-  undo,
-}

package/src/main/js/processor/publishers/meta.js

@@ -1,58 +0,0 @@
-// Meta publisher: pushes meta artifacts to the `meta` branch and undoes them on rollback.
-// The meta payload itself is built by the generator (../generators/meta.js).
-
-import {queuefy} from 'queuefy'
-import {fs, path} from 'zx-extra'
-import {log} from '../log.js'
-import {fetchRepo, pushCommit} from '../api/git.js'
-import {formatTag} from '../generators/tag.js'
-import {prepareMeta, getArtifactPath, isAssetMode} from '../generators/meta.js'
-
-// Push the meta artifact to the `meta` branch. No-op in asset mode (handled by gh-release).
-const pushMetaBranch = queuefy(async (pkg) => {
-  const {type} = pkg.config.meta
-  if (type === null || isAssetMode(type)) return
-
-  log.info('push artifact to branch \'meta\'')
-
-  const {name, version, meta, tag = formatTag({name, version}), absPath: cwd, config: {gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
-  const msg = `chore: release meta ${name} ${version}`
-  const files = [{relpath: `${getArtifactPath(tag)}.json`, contents: meta}]
-
-  await pushCommit({cwd, to: '.', branch: 'meta', msg, files, gitCommitterEmail, gitCommitterName, basicAuth})
-})
-
-// Remove a meta artifact for a given tag from the meta branch.
-// Returns true if something was removed and pushed.
-const removeMetaArtifact = async (pkg, {tag, version, reason}) => {
-  const {config: {meta: {type}, ghBasicAuth: basicAuth, gitCommitterName, gitCommitterEmail}} = pkg
-  // Asset-mode meta lives inside the GH release; deleting the release already removes it.
-  if (type === null || isAssetMode(type)) return false
-
-  const cwd = pkg.ctx?.git?.root || pkg.absPath
-  const metaCwd = await fetchRepo({cwd, branch: 'meta', basicAuth})
-  const artifactPath = getArtifactPath(tag)
-  const candidates = [
-    path.resolve(metaCwd, `${artifactPath}.json`),
-    path.resolve(metaCwd, artifactPath),
-  ]
-  let removed = false
-  for (const p of candidates) {
-    if (fs.existsSync(p)) {
-      await fs.remove(p)
-      removed = true
-    }
-  }
-  if (removed) {
-    await pushCommit({cwd, branch: 'meta', msg: `chore: ${reason} ${pkg.name} ${version}`, gitCommitterName, gitCommitterEmail, basicAuth})
-  }
-  return removed
-}
-
-export default {
-  name: 'meta',
-  when:    (pkg) => pkg.config.meta.type !== null,
-  prepare: prepareMeta,
-  run:     pushMetaBranch,
-  undo:    removeMetaArtifact,
-}

package/src/main/js/processor/publishers/npm.js

@@ -1,15 +0,0 @@
-import {npmPublish} from '../api/npm.js'
-
-// Domain predicate: does this package get published to npm?
-// Private packages and those with `npmPublish: false` are git-tag-only —
-// the tag itself IS the release.
-export const isNpmPublished = (pkg) =>
-  !pkg.manifest.private && pkg.config.npmPublish !== false
-
-export default {
-  name:     'npm',
-  when:     isNpmPublished,
-  run:      (pkg) => npmPublish(pkg),
-  snapshot: true,
-  // No undo: npm unpublish is unreliable (time-limited, cached by mirrors).
-}

package/src/main/js/processor/steps/publish.js

@@ -1,39 +0,0 @@
-import {memoizeBy} from '../../util.js'
-import {exec} from '../exec.js'
-import {log} from '../log.js'
-import {npmPersist} from '../api/npm.js'
-import {pushTag} from '../api/git.js'
-import {formatTag} from '../generators/tag.js'
-import {isNpmPublished} from '../publishers/npm.js'
-import {rollbackRelease} from './teardown.js'
-
-const pushReleaseTag = async (pkg, ctx) => {
-  const {name, version, tag = formatTag({name, version}), config: {gitCommitterEmail, gitCommitterName}} = pkg
-  ctx.git.tag = tag
-  log.info(`push release tag ${tag}`)
-  await pushTag({cwd: ctx.git.root, tag, gitCommitterEmail, gitCommitterName})
-}
-
-export const publish = memoizeBy(async (pkg, ctx = pkg.ctx) => {
-  if (pkg.version !== pkg.manifest.version)
-    throw new Error('package.json version not synced')
-
-  const {run = exec, publishers = [], flags} = ctx
-  const snapshot = !!flags.snapshot
-  const active = publishers.filter(p => (!snapshot || p.snapshot) && p.when(pkg))
-
-  await npmPersist(pkg)
-
-  // Prepare phase: serial pkg mutations (e.g. meta injects into ghAssets) — must finish before any run().
-  for (const p of active) await p.prepare?.(pkg)
-
-  if (!snapshot) await pushReleaseTag(pkg, ctx)
-  try {
-    await Promise.all(active.map(p => p.run(pkg, run)))
-  } catch (e) {
-    // Roll back full release for npm-published packages; git-tag-only packages keep their tag — it IS the release.
-    if (!snapshot && isNpmPublished(pkg)) await rollbackRelease(pkg, ctx)
-    throw e
-  }
-  pkg.published = true
-})

package/src/main/js/processor/steps/teardown.js

@@ -1,58 +0,0 @@
-// Release teardown: undo a published (or half-published) release.
-//
-// Two entry points share the same core:
-//   - rollbackRelease: called inline from publish.js on mid-publish failure (tag known from pkg.ctx).
-//   - recover:         standalone --recover mode — detect orphan tags (tagged but missing on npm) and tear them down.
-//
-// Teardown walks the publishers registry in reverse and calls undo() on each that applies.
-
-import {log} from '../log.js'
-import {deleteRemoteTag} from '../api/git.js'
-import {fetchManifest} from '../api/npm.js'
-import {isNpmPublished} from '../publishers/npm.js'
-
-// Tear down a release: undo every applicable publisher, then delete the git tag.
-// Failures in individual undo steps are warned, not thrown — teardown is best-effort.
-const teardownRelease = async (pkg, ctx, {tag, version, reason}) => {
-  if (!pkg.config.ghBasicAuth) throw new Error(`${reason} requires git credentials (GH_TOKEN)`)
-
-  for (const p of [...ctx.publishers].reverse()) {
-    if (!p.undo || !p.when(pkg)) continue
-    try {
-      const result = await p.undo(pkg, {tag, version, reason})
-      if (result !== false) log.info(`${reason}: ${p.name} undone for '${tag}'`)
-    } catch (e) {
-      log.warn(`${reason}: ${p.name} undo failed`, e)
-    }
-  }
-
-  await deleteRemoteTag({cwd: ctx.git.root, tag})
-}
-
-// Rollback a release that failed mid-publish (called inline from publish.js).
-// Uses the current release tag; skips the npm existence check — we already know it failed.
-export const rollbackRelease = async (pkg, ctx = pkg.ctx) => {
-  const tag = ctx.git.tag
-  if (!tag) return
-  log.info(`rollback: cleaning up failed release for tag '${tag}'`)
-  await teardownRelease(pkg, ctx, {tag, version: pkg.version, reason: 'rollback'})
-}
-
-// Standalone recovery: if a tag exists but the package is missing from npm, treat it as an orphan and tear down.
-export const recover = async (pkg, ctx = pkg.ctx) => {
-  if (!isNpmPublished(pkg)) return false
-
-  const {tag} = pkg.latest
-  if (!tag) return false
-
-  const manifest = await fetchManifest({
-    name: pkg.name,
-    version: tag.version,
-    config: pkg.config,
-  }, {nothrow: true})
-  if (manifest) return false
-
-  log.info(`recover: tag '${tag.ref}' exists but ${pkg.name}@${tag.version} not found on npm, rolling back failed release`)
-  await teardownRelease(pkg, ctx, {tag: tag.ref, version: tag.version, reason: 'recover'})
-  return true
-}