bulk-release 3.0.4 → 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,134 +1,45 @@
 import os from 'node:os'
 import {createRequire} from 'node:module'
-import {$, within, fs, glob, path} from 'zx-extra'
+import {$, within} from 'zx-extra'
 import {queuefy} from 'queuefy'
-import {topo, traverseQueue} from './depot/deps.js'
+
 import {createReport, log} from './log.js'
+import {topo} from './depot/deps.js'
 import {exec} from './depot/exec.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'
 
-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'
+const ZBR_VERSION = createRequire(import.meta.url)('../../../../package.json').version
 
-const PARCELS_DIR = 'parcels'
+export const run = async ({cwd = process.cwd(), env: _env, flags = {}} = {}) => within(async () => {
+  if (flags.v || flags.version)
+    return console.log(ZBR_VERSION)
 
-export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within(async () => {
-  $.memo = new Map()
-
-  const {version: zbrVersion} = createRequire(import.meta.url)('../../../../package.json')
-  if (flags.v || flags.version) {
-    console.log(zbrVersion)
-    return
-  }
+  const env = {...process.env, ..._env}
+  log.secret(env.GH_TOKEN, env.GITHUB_TOKEN, env.NPM_TOKEN)
+  log.info(`zx-bulk-release@${ZBR_VERSION}`)
 
-  // --deliver [dir]: standalone delivery from pre-packed tars.
-  if (flags.deliver) {
-    const dir = typeof flags.deliver === 'string' ? flags.deliver : PARCELS_DIR
-    const tars = await glob(path.join(dir, 'parcel.*.tar'))
-    if (!tars.length) {
-      log.info(`deliver: no parcels in ${dir}, nothing to do`)
-      return
-    }
-    const _env = {...process.env, ...env}
-    log.secret(_env.GH_TOKEN, _env.GITHUB_TOKEN, _env.NPM_TOKEN)
-    log.info(`deliver: ${tars.length} tar(s) from ${dir}`)
-    const delivered = await deliver(tars, _env)
-    log.info(`deliver: done, ${delivered} delivered`)
-    return
-  }
+  if (flags.verify)  return runVerify({cwd, flags})
+  if (flags.deliver) return runDeliver({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
-    const pkg = packages[name]
-    await contextify(pkg, ctx)
-    return cb(pkg)
-  })})
-
-  report
-    .log(`zx-bulk-release@${zbrVersion}`)
-    .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) {
-        report.setStatus('skipped', pkg.name)
-        pkg.skipped = true
-        return
-      }
-      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) {
-        report.setStatus('success', pkg.name)
-        return
-      }
-
-      report.setStatus('packing', pkg.name)
-      await pack(pkg)
-
-      // --pack <dir>: pack only, skip delivery.
-      if (flags.pack) {
-        report.setStatus('packed', pkg.name)
-        return
-      }
-
-      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: _env, cwd}) => {
+export const createContext = async ({flags, env, cwd}) => {
   const {packages, queue, root, prev, graphs} = await topo({cwd, flags})
   const report = createReport({packages, queue, flags})
-  const env = {...process.env, ..._env}
-
-  log.secret(env.GH_TOKEN, env.GITHUB_TOKEN, env.NPM_TOKEN)
 
   $.report  = report
   $.env     = env
   $.verbose = !!(flags.debug || env.DEBUG) || $.verbose
   $.quiet   = !$.verbose
+  $.memo    = new Map()
 
-  return {
-    cwd, env, flags, root, packages, queue, prev, graphs, report,
-    channels,
-    run: queuefy(exec, flags.concurrency || os.cpus().length),
-  }
+  return {cwd, env, flags, root, packages, queue, prev, graphs, report, channels,
+    run: queuefy(exec, flags.concurrency || os.cpus().length)}
 }

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 = () => {