bulk-release 3.0.5 → 3.1.1

package/src/main/js/post/{courier/parcel.js → parcel/build.js}

@@ -9,6 +9,18 @@ const gitFields = (a, pkg) => ({
 })
 
 const entry = {
+  'git-tag': (pkg, ctx) => ({
+    channel: 'git-tag',
+    manifest: {
+      channel: 'git-tag',
+      name: pkg.name, version: pkg.version, tag: pkg.tag,
+      cwd: ctx.git.root,
+      gitCommitterName: '${{GIT_COMMITTER_NAME}}',
+      gitCommitterEmail: '${{GIT_COMMITTER_EMAIL}}',
+    },
+    files: [],
+  }),
+
   npm: (pkg, ctx, a) => ({
     channel: 'npm',
     manifest: {
@@ -24,6 +36,7 @@ const entry = {
     channel: 'gh-release',
     manifest: {
       channel: 'gh-release',
+      name: pkg.name, version: pkg.version,
       tag: pkg.tag, repoHost: a.repoHost, repoName: a.repoName, releaseNotes: a.releaseNotes,
       token: '${{GH_TOKEN}}', apiUrl: pkg.config.ghApiUrl,
       assets: pkg.config.ghAssets ? [...pkg.config.ghAssets] : undefined,
@@ -35,7 +48,7 @@ const entry = {
     const [branch = 'gh-pages', , to = '.', ..._msg] = asTuple(pkg.config.ghPages, ['branch', 'from', 'to', 'msg'])
     return {
       channel: 'gh-pages',
-      manifest: {channel: 'gh-pages', branch, to, msg: msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}'), ...gitFields(a, pkg)},
+      manifest: {channel: 'gh-pages', name: pkg.name, version: pkg.version, branch, to, msg: msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}'), ...gitFields(a, pkg)},
       files: a.docsDir ? [{name: 'docs', source: a.docsDir}] : [],
     }
   },
@@ -44,7 +57,7 @@ const entry = {
     const [branch = 'changelog', file = `${pkg.name.replace(/[^a-z0-9-]/ig, '')}-changelog.md`, ..._msg] = asTuple(pkg.config.changelog, ['branch', 'file', 'msg'])
     return {
       channel: 'changelog',
-      manifest: {channel: 'changelog', releaseNotes: a.releaseNotes, branch, file, msg: msgJoin(_msg, pkg, 'chore: update changelog ${{name}}'), ...gitFields(a, pkg)},
+      manifest: {channel: 'changelog', name: pkg.name, version: pkg.version, releaseNotes: a.releaseNotes, branch, file, msg: msgJoin(_msg, pkg, 'chore: update changelog ${{name}}'), ...gitFields(a, pkg)},
       files: [],
     }
   },

package/src/main/js/post/parcel/directive.js

@@ -0,0 +1,81 @@
+import {fs, path, glob} from 'zx-extra'
+import {packTar, unpackTar} from '../tar.js'
+import {log} from '../log.js'
+
+const GIT_CHANNELS = new Set(['git-tag', 'gh-release', 'changelog', 'gh-pages', 'meta'])
+
+// parcel.{sha7}.{channel}.{...}.tar — channel is the 3rd dot-segment
+export const parcelChannel = (name) => name.replace(/\.tar$/, '').split('.')[2]
+
+const splitSteps = (channelNames) => {
+  const git = channelNames.filter(n => GIT_CHANNELS.has(n))
+  const ext = channelNames.filter(n => !GIT_CHANNELS.has(n))
+  return [git, ext].filter(s => s.length)
+}
+
+export const buildDirective = async (ctx, packedPkgs, outputDir) => {
+  const {sha, timestamp} = packedPkgs[0].ctx.git
+  const packages = {}
+  const parcels = []
+
+  for (const pkg of packedPkgs) {
+    const pkgParcels = (pkg.tars || []).map(t => path.basename(t))
+    packages[pkg.name] = {
+      version:  pkg.version,
+      tag:      pkg.tag,
+      deliver:  splitSteps(pkg.activeTransport || []),
+      parcels:  pkgParcels,
+    }
+    parcels.push(...pkgParcels)
+  }
+
+  const sha7 = sha.slice(0, 7)
+  const manifest = {
+    channel: 'directive',
+    sha, timestamp: Number(timestamp),
+    queue: packedPkgs.map(p => p.name),
+    packages, parcels,
+  }
+
+  const tarPath = path.join(outputDir, `parcel.${sha7}.directive.${timestamp}.tar`)
+  await packTar(tarPath, manifest, [])
+  return tarPath
+}
+
+export const parseDirective = async (tarPath) => {
+  const content = await fs.readFile(tarPath, 'utf8').catch(() => null)
+  if (content === 'released' || content === 'conflict') return null
+
+  const {manifest} = await unpackTar(tarPath, tarPath + '.d')
+  if (manifest.channel !== 'directive') return null
+  return manifest
+}
+
+export const scanDirectives = async (dir) => {
+  const tars = await glob(path.join(dir, 'parcel.*.directive.*.tar'))
+  const result = []
+
+  for (const tarPath of tars) {
+    const d = await parseDirective(tarPath)
+    if (d) result.push({...d, tarPath})
+  }
+
+  return result.sort((a, b) => a.timestamp - b.timestamp)
+}
+
+export const invalidateOrphans = async (dir, directive) => {
+  const sha7 = directive.sha.slice(0, 7)
+  const owned = new Set(directive.parcels || [])
+  const all = await glob(path.join(dir, `parcel.${sha7}.*.tar`))
+  let count = 0
+
+  for (const tarPath of all) {
+    const name = path.basename(tarPath)
+    if (parcelChannel(name) === 'directive') continue
+    if (owned.has(name)) continue
+    await fs.writeFile(tarPath, 'orphan')
+    count++
+  }
+
+  if (count) log.info(`invalidated ${count} orphan parcel(s) for ${sha7}`)
+}

package/src/main/js/post/parcel/index.js

@@ -0,0 +1,4 @@
+export {buildParcels} from './build.js'
+export {buildDirective, parseDirective, scanDirectives, invalidateOrphans, parcelChannel} from './directive.js'
+export {verifyParcels} from './verify.js'
+export const PARCELS_DIR = 'parcels'

package/src/main/js/post/parcel/verify.js

@@ -0,0 +1,46 @@
+import {path} from 'zx-extra'
+import {parcelChannel} from './directive.js'
+
+export const verifyParcels = (tars, context) => {
+  const {sha7, packages: expected} = context
+  const errors = []
+  const verified = []
+
+  for (const tarPath of tars) {
+    const name = path.basename(tarPath)
+
+    if (!name.startsWith(`parcel.${sha7}.`)) {
+      errors.push(`sha mismatch: ${name}`)
+      continue
+    }
+
+    const channel = parcelChannel(name)
+    if (!channel) {
+      errors.push(`malformed name: ${name}`)
+      continue
+    }
+
+    if (channel === 'directive') {
+      verified.push(tarPath)
+      continue
+    }
+
+    const belongsTo = Object.entries(expected).find(([, pkg]) =>
+      pkg.tag && name.includes(`.${pkg.tag}.`)
+    )
+    if (!belongsTo) {
+      errors.push(`unexpected parcel (no matching package): ${name}`)
+      continue
+    }
+
+    const [pkgName, pkg] = belongsTo
+    if (!pkg.channels.includes(channel)) {
+      errors.push(`unexpected channel '${channel}' for ${pkgName}: ${name}`)
+      continue
+    }
+
+    verified.push(tarPath)
+  }
+
+  return {verified, errors}
+}

package/src/main/js/post/release.js

@@ -1,24 +1,52 @@
 import os from 'node:os'
 import {createRequire} from 'node:module'
-import {$, within, glob, path} from 'zx-extra'
+import {$, within} from 'zx-extra'
 import {queuefy} from 'queuefy'
 
 import {createReport, log} from './log.js'
-import {topo, traverseQueue} from './depot/deps.js'
+import {topo} from './depot/deps.js'
 import {exec} from './depot/exec.js'
-import {contextify} from './depot/steps/contextify.js'
-import {analyze} from './depot/steps/analyze.js'
-import {build} from './depot/steps/build.js'
-import {pack} from './depot/steps/pack.js'
-import {publish} from './depot/steps/publish.js'
-import {clean} from './depot/steps/clean.js'
-import {test} from './depot/steps/test.js'
-import {deliver, defaultOrder as channels} from './courier/index.js'
+import {defaultOrder as channels} from './courier/index.js'
+import {runReceive} from './modes/receive.js'
+import {runVerify} from './modes/verify.js'
+import {runDeliver} from './modes/deliver.js'
+import {runPack} from './modes/pack.js'
 
-const PARCELS_DIR = 'parcels'
 const ZBR_VERSION = createRequire(import.meta.url)('../../../../package.json').version
 
+const HELP = `
+zx-bulk-release v${ZBR_VERSION}
+
+Usage: npx zx-bulk-release [options]
+
+Modes:
+  (no flags)              All-in-one: analyze, build, test, pack, deliver
+  --receive               Analyze & preflight. Writes .zbr-context.json. Run BEFORE deps install.
+  --pack [dir]            Build, test, pack tars to dir.                          [default: parcels]
+  --verify [dir]          Validate parcels against context, copy to parcels/.     [default: parcels]
+  --deliver [dir]         Deliver parcels through channels.                       [default: parcels]
+
+Options:
+  --context <path>        Path to .zbr-context.json (with --verify).     [default: .zbr-context.json]
+  --dry-run, --no-publish Disable any publish / remote-mutating logic.
+  --no-build              Skip buildCmd.
+  --no-test               Skip testCmd.
+  --snapshot              Publish snapshot versions to npm only.
+  --ignore <a,b>          Packages to ignore.
+  --include-private       Include private packages.
+  --concurrency <n>       Build/publish thread limit.                        [default: os.cpus().length]
+  --only-workspace-deps   Recognize only workspace: deps as graph edges.
+  --no-npm-fetch          Disable npm artifact fetching.
+  --report <path>         Persist release state to file.
+  --debug                 Enable verbose mode.
+  -v, --version           Print version.
+  -h, --help              Show this help.
+`.trim()
+
 export const run = async ({cwd = process.cwd(), env: _env, flags = {}} = {}) => within(async () => {
+  if (flags.h || flags.help)
+    return console.log(HELP)
+
   if (flags.v || flags.version)
     return console.log(ZBR_VERSION)
 
@@ -26,83 +54,13 @@ export const run = async ({cwd = process.cwd(), env: _env, flags = {}} = {}) =>
   log.secret(env.GH_TOKEN, env.GITHUB_TOKEN, env.NPM_TOKEN)
   log.info(`zx-bulk-release@${ZBR_VERSION}`)
 
-  return flags.deliver
-    ? runDeliver({env, flags})
-    : runPipeline({cwd, env, flags})
-})
-
-// --deliver [dir]
-const runDeliver = async ({env, flags}) => {
-  const dir = typeof flags.deliver === 'string' ? flags.deliver : PARCELS_DIR
-  const report = createReport({flags})
-
-  $.memo = new Map()
-  $.report = report
-
-  report.setStatus('inspecting')
-
-  const tars = await glob(path.join(dir, 'parcel.*.tar'))
-  if (!tars.length) return report.setStatus('success').log(`no parcels in ${dir}`)
-
-  report.setStatus('delivering').log(`parcels: ${tars.length}`)
-  const result = await deliver(tars, env, {dryRun: flags.dryRun})
-  report.set('delivery', result).setStatus('success')
-
-  for (const {channel, name, version} of result.entries)
-    log.info(`${channel} ${name}@${version}`)
-  log.info(`done: ${result.delivered} delivered, ${result.skipped} skipped`)
-}
+  if (flags.verify)  return runVerify({cwd, flags})
+  if (flags.deliver) return runDeliver({env, flags})
 
-// full pipeline (legacy / --pack)
-const runPipeline = async ({cwd, env, flags}) => {
   const ctx = await createContext({flags, env, cwd})
-  const {report, packages, queue, prev} = ctx
-
-  const forEachPkg = (cb) => traverseQueue({queue, prev, cb: (name) => within(async () => {
-    $.scope = name
-    await contextify(packages[name], ctx)
-    return cb(packages[name])
-  })})
-
-  report
-    .log('queue:', queue)
-    .log('graphs', ctx.graphs)
-
-  try {
-    await forEachPkg(async (pkg) => {
-      report.setStatus('analyzing', pkg.name)
-      await analyze(pkg)
-      report.set({
-        config:      pkg.config,
-        version:     pkg.version,
-        prevVersion: pkg.latest.tag?.version || pkg.manifest.version,
-        releaseType: pkg.releaseType,
-        tag:         pkg.tag,
-      }, pkg.name)
-    })
-
-    report.setStatus('pending')
-
-    await forEachPkg(async (pkg) => {
-      if (!pkg.releaseType) { pkg.skipped = true; return report.setStatus('skipped', pkg.name) }
-      if (flags.build !== false) { report.setStatus('building',  pkg.name); await build(pkg) }
-      if (flags.test  !== false) { report.setStatus('testing',   pkg.name); await test(pkg)  }
-      if (flags.dryRun || flags.publish === false) return report.setStatus('success', pkg.name)
-
-      report.setStatus('packing',    pkg.name); await pack(pkg)
-      if (flags.pack) return report.setStatus('packed', pkg.name)
-
-      report.setStatus('publishing', pkg.name); await publish(pkg)
-      report.setStatus('success',    pkg.name)
-    })
-  } catch (e) {
-    report.error(e, e.stack).set('error', e).setStatus('failure')
-    throw e
-  } finally {
-    await clean(ctx)
-  }
-  report.setStatus('success').log('Great success!')
-}
+  if (flags.receive) return runReceive({cwd, env, flags}, ctx)
+  return runPack({cwd, env, flags}, ctx)
+})
 
 export const createContext = async ({flags, env, cwd}) => {
   const {packages, queue, root, prev, graphs} = await topo({cwd, flags})

package/src/main/js/post/tar.js

@@ -26,7 +26,7 @@ export const packTar = async (tarPath, manifest, files = []) => {
 export const hashFile = async (filePath) => {
   const hash = crypto.createHash('sha1')
   await pipeline(createReadStream(filePath), hash)
-  return hash.digest('hex').slice(0, 8)
+  return hash.digest('hex').slice(0, 6)
 }
 
 const addDir = async (pack, prefix, dirPath) => {

package/src/main/js/util.js

@@ -72,3 +72,19 @@ export const memoizeBy = (fn, getKey = v => v) => {
 export const camelize = s => s.replace(/-./g, x => x[1].toUpperCase())
 
 export const asArray = v => Array.isArray(v) ? v : [v]
+
+export const pool = async (tasks, concurrency, fn) => {
+  const active = new Set()
+  let i = 0
+  await new Promise((resolve, reject) => {
+    const next = () => {
+      if (i >= tasks.length && active.size === 0) return resolve()
+      while (active.size < concurrency && i < tasks.length) {
+        const t = tasks[i++]
+        const p = fn(t).then(() => { active.delete(p); next() }, reject)
+        active.add(p)
+      }
+    }
+    next()
+  })
+}

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

@@ -112,7 +112,7 @@ export const makeCtx = (overrides = {}) => ({
   report: overrides.report ?? makeReport(),
   channels: overrides.channels ?? [],
   run: overrides.run ?? (async () => {}),
-  git: {sha: 'abc1234567890', root: tmpDir, ...overrides.git},
+  git: {sha: 'abc1234567890', root: tmpDir, timestamp: '1700000000', ...overrides.git},
 })
 
 export const makeReport = () => {