zx-bulk-release 3.0.4 → 3.0.5

package/CHANGELOG.md

@@ -1,3 +1,8 @@
+## [3.0.5](https://github.com/semrel-extra/zx-bulk-release/compare/v3.0.4...v3.0.5) (2026-04-11)
+
+### Fixes & improvements
+* perf: minor code imprs ([2564f3f](https://github.com/semrel-extra/zx-bulk-release/commit/2564f3fd8fdd42c08a2aa32e1e9f2cfee7d3199d))
+
 ## [3.0.4](https://github.com/semrel-extra/zx-bulk-release/compare/v3.0.3...v3.0.4) (2026-04-11)
 
 ### Fixes & improvements

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zx-bulk-release",
   "alias": "bulk-release",
-  "version": "3.0.4",
+  "version": "3.0.5",
   "description": "zx-based alternative for multi-semantic-release",
   "type": "module",
   "exports": {

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

@@ -74,8 +74,9 @@ const pool = async (tasks, concurrency, fn) => {
 
 // Parcels grouped by package, sorted by semver asc (latest last).
 // Groups run in parallel (concurrency-limited), entries within a group — sequential.
-export const deliver = async (tars, env = process.env, {concurrency = 4} = {}) => {
-  const groups = new Map()
+export const inspect = async (tars, env = process.env) => {
+  const parcels = []
+  const skipped = []
 
   for (const tarPath of tars) {
     const fname = path.basename(tarPath)
@@ -83,22 +84,46 @@ export const deliver = async (tars, env = process.env, {concurrency = 4} = {}) =
       const p = await openParcel(tarPath, env)
       if (!p) continue
       if (p.warn) {
-        log.warn(`skipping ${fname}: ${p.warn}`)
-        if (p.tarPath) await fs.writeFile(tarPath, 'skip')
+        skipped.push({file: fname, reason: p.warn, tarPath: p.tarPath})
         continue
       }
-      const key = p.resolved.name || p.resolved.channel
-      if (!groups.has(key)) groups.set(key, [])
-      groups.get(key).push(p)
+      parcels.push(p)
     } catch (e) {
-      log.warn(`skipping ${fname}: ${e.message}`)
+      skipped.push({file: fname, reason: e.message})
     }
   }
 
+  // group by package, sort by semver asc within each group
+  const groups = new Map()
+  for (const p of parcels) {
+    const key = p.resolved.name || p.resolved.channel
+    if (!groups.has(key)) groups.set(key, [])
+    groups.get(key).push(p)
+  }
   for (const g of groups.values())
     g.sort((a, b) => semver.compare(a.resolved.version || '0.0.0', b.resolved.version || '0.0.0'))
 
-  let delivered = 0
+  return {groups, skipped, total: tars.length, pending: parcels.length}
+}
+
+export const deliver = async (tars, env = process.env, {concurrency = 4, dryRun = false} = {}) => {
+  const {groups, skipped, total, pending} = await inspect(tars, env)
+
+  for (const {file, reason, tarPath} of skipped) {
+    log.warn(`skipping ${file}: ${reason}`)
+    if (!dryRun && tarPath) await fs.writeFile(tarPath, 'skip')
+  }
+
+  const entries = []
+  const toEntry = ({resolved}) => ({channel: resolved.channel, name: resolved.name, version: resolved.version})
+
+  if (dryRun) {
+    for (const group of groups.values())
+      for (const p of group)
+        entries.push(toEntry(p))
+    return {total, pending: entries.length, delivered: 0, skipped: skipped.length, entries}
+  }
+
   await pool([...groups.values()], concurrency, async (group) => {
     for (const {ch, resolved, destDir, tarPath} of group) {
       await within(async () => {
@@ -106,9 +131,9 @@ export const deliver = async (tars, env = process.env, {concurrency = 4} = {}) =
         await ch.run(resolved, destDir)
       })
       await fs.writeFile(tarPath, 'released')
-      delivered++
+      entries.push(toEntry({resolved}))
     }
   })
 
-  return delivered
+  return {total, pending, delivered: entries.length, skipped: skipped.length, entries}
 }

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

@@ -1,11 +1,11 @@
 import os from 'node:os'
 import {createRequire} from 'node:module'
-import {$, within, fs, glob, path} from 'zx-extra'
+import {$, within, glob, path} from 'zx-extra'
 import {queuefy} from 'queuefy'
-import {topo, traverseQueue} from './depot/deps.js'
+
 import {createReport, log} from './log.js'
+import {topo, traverseQueue} 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'
@@ -13,48 +13,58 @@ 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 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 () => {
+  if (flags.v || flags.version)
+    return console.log(ZBR_VERSION)
+
+  const env = {...process.env, ..._env}
+  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})
 
-export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within(async () => {
   $.memo = new Map()
+  $.report = report
 
-  const {version: zbrVersion} = createRequire(import.meta.url)('../../../../package.json')
-  if (flags.v || flags.version) {
-    console.log(zbrVersion)
-    return
-  }
+  report.setStatus('inspecting')
 
-  // --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
-  }
+  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`)
+}
 
+// 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
-    const pkg = packages[name]
-    await contextify(pkg, ctx)
-    return cb(pkg)
+    await contextify(packages[name], ctx)
+    return cb(packages[name])
   })})
 
   report
-    .log(`zx-bulk-release@${zbrVersion}`)
     .log('queue:', queue)
     .log('graphs', ctx.graphs)
 
@@ -74,36 +84,16 @@ export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within
     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)
+      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')
@@ -112,23 +102,18 @@ export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within
     await clean(ctx)
   }
   report.setStatus('success').log('Great success!')
-})
+}
 
-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)}
 }