bulk-release 3.0.5 → 3.1.0

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

@@ -0,0 +1,83 @@
+import {glob, path, fs} from 'zx-extra'
+import {log} from '../log.js'
+import {parcelChannel} from '../courier/directive.js'
+
+const PARCELS_DIR = 'parcels'
+
+export const runVerify = async ({cwd, flags}) => {
+  const inputDir = typeof flags.verify === 'string' ? flags.verify : PARCELS_DIR
+  const contextPath = typeof flags.context === 'string' ? flags.context : path.resolve(cwd, '.zbr-context.json')
+  const outputDir = path.resolve(cwd, PARCELS_DIR)
+
+  log.info(`verifying parcels in ${inputDir} against ${contextPath}`)
+
+  let context
+  try { context = await fs.readJson(contextPath) } catch { context = null }
+  if (!context || context.status !== 'proceed') {
+    throw new Error(`no valid context at ${contextPath}`)
+  }
+
+  const tars = await glob(path.join(inputDir, 'parcel.*.tar'))
+  if (!tars.length) {
+    log.info('no parcels to verify')
+    return
+  }
+
+  const {sha7, packages: expected} = context
+  const errors = []
+  const verified = []
+
+  for (const tarPath of tars) {
+    const name = path.basename(tarPath)
+
+    // sha7 prefix must match
+    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
+    }
+
+    // match to an expected package by tag
+    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)
+  }
+
+  if (errors.length) {
+    for (const e of errors) log.error(`verify: ${e}`)
+    throw new Error(`parcel verification failed: ${errors.length} error(s)`)
+  }
+
+  // copy verified parcels to output
+  if (path.resolve(inputDir) !== outputDir) {
+    await fs.ensureDir(outputDir)
+    for (const tarPath of verified) {
+      await fs.copy(tarPath, path.join(outputDir, path.basename(tarPath)))
+    }
+    log.info(`${verified.length} parcel(s) verified and copied to ${outputDir}`)
+  } else {
+    log.info(`${verified.length} parcel(s) verified in place`)
+  }
+}

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

@@ -1,21 +1,17 @@
 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
 
 export const run = async ({cwd = process.cwd(), env: _env, flags = {}} = {}) => within(async () => {
@@ -26,83 +22,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}`)
+  if (flags.verify)  return runVerify({cwd, flags})
+  if (flags.deliver) return runDeliver({env, flags})
 
-  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`)
-}
-
-// 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/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 = () => {