bulk-release 2.12.2 → 2.13.0

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.13.0](https://github.com/semrel-extra/zx-bulk-release/compare/v2.12.2...v2.13.0) (2023-12-05)
+
+### Fixes & improvements
+* fix: avoid polynomial regex on flags parsing ([c080fb8](https://github.com/semrel-extra/zx-bulk-release/commit/c080fb8246d71ad5e366ae6931b06db3ff86233b))
+* fix: sanitize paths on extract ([3f67b9f](https://github.com/semrel-extra/zx-bulk-release/commit/3f67b9f89b44589930c5dcce96237c0c5c3294f1))
+* refactor: decompose processor.js ([a498a7f](https://github.com/semrel-extra/zx-bulk-release/commit/a498a7f5900396e42b6b2a6478028e128ab6ec1f))
+* fix: throw error if declared gh asset is empty ([d2dc6f6](https://github.com/semrel-extra/zx-bulk-release/commit/d2dc6f6b457a3178671b0d6349d42234b8052c7e))
+* fix: handle empty files collection on gh assets push ([c9dbb5b](https://github.com/semrel-extra/zx-bulk-release/commit/c9dbb5bf3c5b4ff4ce11603e541feae784574f10))
+* perf: replace external `curl`, `wget` and `tar` with node `fetch` and `tar-stream` ([496c73b](https://github.com/semrel-extra/zx-bulk-release/commit/496c73b68172c42e5930d185f1008d487928e7fc))
+
+### Features
+* feat: configurable meta push ([0042af3](https://github.com/semrel-extra/zx-bulk-release/commit/0042af34d31ff6d3783c3953ece167a9dc78fb45))
+* feat: let release meta be published as gh assets ([3d333e1](https://github.com/semrel-extra/zx-bulk-release/commit/3d333e1fb6d61adb5bd05ac3a90e19a3a5402843))
+
 ## [2.12.2](https://github.com/semrel-extra/zx-bulk-release/compare/v2.12.1...v2.12.2) (2023-11-20)
 
 ### Fixes & improvements

package/README.md

@@ -25,7 +25,7 @@
 * macOS / linux
 * Node.js >= 16.0.0
 * npm >=7 / yarn >= 3
-* wget
+* ~~wget~~
 * tar
 * git
 
@@ -210,8 +210,11 @@ Anyway, it's still possible to override the default config by `tagFormat` option
 
 
 ### Meta
+Each release gathers its own meta. It is _recommended_ to store the data somehow to ensure flow reliability.: 
+* Set `meta: {type: 'asset'}` to persist as gh asset.
+* If set `meta: {type: null}` the required data will be fetched from the npm artifact.
+* Otherwise, it will be pushed as a regular git commit to the `meta` branch (default behaviour).
 
-Each release pushes its result to the `meta` branch.  
 `2022-6-26-semrel-extra-zxbr-test-c-1-3-1-f0.json`
 ```json
 {
@@ -333,6 +336,7 @@ zx-bulk-release
 * [googleapis/release-please](https://github.com/googleapis/release-please)
 * [generic-semantic-version-processing](https://about.gitlab.com/blog/2021/09/28/generic-semantic-version-processing/)
 * [jchip/fynpo](https://github.com/jchip/fynpo)
+* [lerna-lite/lerna-lite](https://github.com/lerna-lite/lerna-lite)
 
 ## License 
 [MIT](./LICENSE)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bulk-release",
   "alias": "bulk-release",
-  "version": "2.12.2",
+  "version": "2.13.0",
   "description": "zx-based alternative for multi-semantic-release",
   "type": "module",
   "exports": {
@@ -20,18 +20,22 @@
   "scripts": {
     "test": "NPM_REGISTRY='http://localhost:4873' NPM_TOKEN='mRv6eIuiaggXGb9ZDFCtBA==' c8 uvu ./src/test -i fixtures -i utils && c8 report -r lcov",
     "test:it": "NPM_REGISTRY='http://localhost:4873' NPM_TOKEN='mRv6eIuiaggXGb9ZDFCtBA==' node ./src/test/js/integration.test.js",
-    "docs": "mkdir -p docs && cp ./README.md ./docs/README.md"
+    "docs": "mkdir -p docs && cp ./README.md ./docs/README.md",
+    "publish:beta": "npm publish --tag beta --no-git-tag-version",
+    "build": "esbuild src/main/js/index.js --platform=node --outdir=target --bundle --format=esm --external:typescript"
   },
   "dependencies": {
     "@semrel-extra/topo": "^1.14.0",
-    "cosmiconfig": "^8.3.6",
+    "cosmiconfig": "^9.0.0",
     "queuefy": "^1.2.1",
+    "tar-stream": "^3.1.6",
     "zx-extra": "^2.6.4"
   },
   "devDependencies": {
     "c8": "^8.0.1",
+    "esbuild": "^0.19.8",
     "uvu": "^0.5.6",
-    "verdaccio": "^5.27.0"
+    "verdaccio": "^5.27.1"
   },
   "publishConfig": {
     "access": "public"

package/src/main/js/{changelog.js → api/changelog.js}

@@ -1,9 +1,9 @@
 import {$} from 'zx-extra'
 import {queuefy} from 'queuefy'
 import {fetchRepo, getRepo, pushCommit} from './git.js'
-import {log} from './log.js'
-import {formatTag} from './meta.js'
-import {msgJoin} from './util.js'
+import {log} from '../log.js'
+import {formatTag} from '../processor/meta.js'
+import {msgJoin} from '../util.js'
 
 export const pushChangelog = queuefy(async (pkg) => {
   const {absPath: cwd, config: {changelog: opts, gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg

package/src/main/js/{gh.js → api/gh.js}

@@ -1,10 +1,10 @@
 import {queuefy} from 'queuefy'
 import {$, path, tempy, glob, fs} from 'zx-extra'
-import {log} from './log.js'
+import {log} from '../log.js'
 import {getRepo, pushCommit} from './git.js'
-import {formatTag} from './meta.js'
+import {formatTag} from '../processor/meta.js'
 import {formatReleaseNotes} from './changelog.js'
-import {asArray, getCommonPath, msgJoin} from './util.js'
+import {asArray, getCommonPath, msgJoin} from '../util.js'
 
 // https://docs.github.com/en/rest/releases/releases?apiVersion=2022-11-28#create-a-release
 export const ghRelease = async (pkg) => {
@@ -23,10 +23,17 @@ export const ghRelease = async (pkg) => {
     body: releaseNotes
   })
 
-  const {stdout} = await $.o({cwd})`curl -H 'Authorization: token ${ghToken}' -H 'Accept: application/vnd.github.v3+json' https://api.github.com/repos/${repoName}/releases -d ${releaseData}`
-  const res = JSON.parse(stdout.toString().trim())
-
-  if (ghAssets) {
+  const res = await (await fetch(`https://api.github.com/repos/${repoName}/releases`, {
+    method: 'POST',
+    headers: {
+      Accept: 'application/vnd.github.v3+json',
+      Authorization: `token ${ghToken}`,
+      'X-GitHub-Api-Version': '2022-11-28'
+    },
+    body: releaseData
+  })).json()
+
+  if (ghAssets?.length) {
     // Lol. GH API literally returns pseudourl `...releases/110103594/assets{?name,label}` as shown in the docs
     const uploadUrl = res.upload_url.slice(0, res.upload_url.indexOf('{'))
     await ghUploadAssets({ghToken, ghAssets, uploadUrl, cwd})
@@ -62,13 +69,24 @@ export const ghPages = queuefy(async (pkg) => {
 export const ghPrepareAssets = async (assets, _cwd) => {
   const temp = tempy.temporaryDirectory()
 
-  await Promise.all(assets.map(async ({name, source = 'target/**/*', zip, cwd = _cwd, strip = true}) => {
-    const patterns = asArray(source)
+  await Promise.all(assets.map(async ({name, contents, source = 'target/**/*', zip, cwd = _cwd, strip = true}) => {
     const target = path.join(temp, name)
+
+    if (contents) {
+      await fs.outputFile(target, contents, 'utf8')
+      return
+    }
+
+    const patterns = asArray(source)
     if (patterns.some(s => s.includes('*'))) {
       zip = true
     }
     const files = await glob(patterns, {cwd, absolute: false, onlyFiles: true})
+
+    if (files.length === 0) {
+      throw new Error(`gh asset not found: ${name} ${source}`)
+    }
+
     if (!zip && files.length === 1) {
       await fs.copy(path.join(cwd, files[0]), target)
       return
@@ -86,7 +104,24 @@ export const ghUploadAssets = async ({ghToken, ghAssets, uploadUrl, cwd}) => {
 
   return Promise.all(ghAssets.map(async ({name}) => {
     const url = `${uploadUrl}?name=${name}`
-    return $.o({cwd: temp})`curl -H 'Authorization: token ${ghToken}' -H 'Accept: application/vnd.github.v3+json' -H 'Content-Type: application/octet-stream' ${url} --data-binary '@${name}'`
+    // return $.o({cwd: temp})`curl -H 'Authorization: token ${ghToken}' -H 'Accept: application/vnd.github.v3+json' -H 'Content-Type: application/octet-stream' ${url} --data-binary '@${name}'`
+    return fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/octet-stream',
+        Accept: 'application/vnd.github.v3+json',
+        Authorization: `token ${ghToken}`,
+        'X-GitHub-Api-Version': '2022-11-28'
+      },
+      body: await fs.readFile(path.join(temp, name))
+    })
   }))
 }
 
+export const ghGetAsset = async ({repoName, tag, name}) => {
+  return (await fetch(`https://github.com/${repoName}/releases/download/${tag}/${name}`, {
+    headers: {
+      // Accept: 'application/vnd.github.v3+json'
+    }
+  })).text()
+}

package/src/main/js/{git.js → api/git.js}

@@ -1,6 +1,6 @@
 import {$, ctx, fs, path, tempy, copy} from 'zx-extra'
-import {log} from './log.js'
-import {memoizeBy} from './util.js'
+import {log} from '../log.js'
+import {memoizeBy} from '../util.js'
 
 export const fetchRepo = memoizeBy(async ({cwd: _cwd, branch, origin: _origin, basicAuth}) => ctx(async ($) => {
   const origin = _origin || (await getRepo(_cwd, {basicAuth})).repoAuthedUrl
@@ -59,9 +59,15 @@ export const getSha = async (cwd) => (await $.o({cwd})`git rev-parse HEAD`).toSt
 
 export const getRoot = memoizeBy(async (cwd) => (await $.o({cwd})`git rev-parse --show-toplevel`).toString().trim())
 
+export const parseOrigin = (originUrl) => {
+  const [, , repoHost, repoName] = originUrl.replace(':', '/').replace(/\.git/, '').match(/.+(@|\/\/)([^/]+)\/(.+)$/) || []
+
+  return {repoHost, repoName}
+}
+
 export const getRepo = memoizeBy(async (cwd, {basicAuth} = {}) => {
   const originUrl = await getOrigin(cwd)
-  const [, , repoHost, repoName] = originUrl.replace(':', '/').replace(/\.git/, '').match(/.+(@|\/\/)([^/]+)\/(.+)$/) || []
+  const {repoHost, repoName} = parseOrigin(originUrl)
   const repoPublicUrl = `https://${repoHost}/${repoName}`
   const repoAuthedUrl = basicAuth && repoHost && repoName
     ? `https://${basicAuth}@${repoHost}/${repoName}.git`

package/src/main/js/{npm.js → api/npm.js}

@@ -1,5 +1,8 @@
-import {log} from './log.js'
+import {log} from '../log.js'
 import {$, fs, INI, fetch, tempy} from 'zx-extra'
+import {unzip} from '../util.js'
+
+// https://stackoverflow.com/questions/19978452/how-to-extract-single-file-from-tar-gz-archive-using-node-js
 
 export const fetchPkg = async (pkg) => {
   const id = `${pkg.name}@${pkg.version}`
@@ -10,9 +13,20 @@ export const fetchPkg = async (pkg) => {
     const {npmRegistry, npmToken, npmConfig} = pkg.config
     const tarballUrl = getTarballUrl(npmRegistry, pkg.name, pkg.version)
     const bearerToken = getBearerToken(npmRegistry, npmToken, npmConfig)
-    const authorization = bearerToken ? `--header='Authorization: ${bearerToken}'` : ''
+    const headers = bearerToken ? {Authorization: bearerToken} : {}
     log({pkg})(`fetching '${id}' from ${npmRegistry}`)
-    await $.raw`wget --timeout=15 --connect-timeout=5 ${authorization} -qO- ${tarballUrl} | tar -xvz --strip-components=1 --exclude='package.json' -C ${cwd}`
+
+    // https://stackoverflow.com/questions/46946380/fetch-api-request-timeout
+    const controller = new AbortController()
+    const timeoutId = setTimeout(() => controller.abort(), 15_000)
+    const tarball = await fetch(tarballUrl, {
+      method: 'GET',
+      headers,
+      signal: controller.signal
+    })
+    clearTimeout(timeoutId)
+
+    await unzip(tarball.body, {cwd, strip: 1, omit: ['package.json']})
 
     log({pkg})(`fetch duration '${id}': ${Date.now() - now}`)
     pkg.fetched = true

package/src/main/js/config.js

@@ -19,26 +19,40 @@ export const defaultConfig = {
   changelog:  'changelog',
   npmFetch:   true,
   ghRelease:  true,
+  meta:       true,
   // npmPublish: true,
   // ghPages: 'gh-pages'
 }
 
 export const getPkgConfig = async (...cwds) =>
   normalizePkgConfig((await Promise.all(cwds.map(
-    cwd => cosmiconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILES }).search(cwd).then(r => r?.config)
+    cwd => cosmiconfig(CONFIG_NAME, {
+      searchPlaces: CONFIG_FILES,
+      searchStrategy: 'global', // https://github.com/cosmiconfig/cosmiconfig/releases/tag/v9.0.0
+    })
+      .search(cwd)
+      .then(r => r?.config)
   ))).find(Boolean) || defaultConfig)
 
 export const normalizePkgConfig = (config, env) => ({
   ...parseEnv(env),
   ...config,
   releaseRules: config.releaseRules || config.semanticRules,
-  npmFetch: config.npmFetch || config.fetch || config.fetchPkg,
-  buildCmd: config.buildCmd || config.cmd,
+  npmFetch:     config.npmFetch || config.fetch || config.fetchPkg,
+  buildCmd:     config.buildCmd || config.cmd,
   get ghBasicAuth() {
     return this.ghUser && this.ghToken ? `${this.ghUser}:${this.ghToken}` : false
-  }
+  },
+  meta: normalizeMetaConfig(config.meta)
 })
 
+export const normalizeMetaConfig = (meta) =>
+  meta === true
+    ? normalizeMetaConfig('commit')
+    : typeof meta === 'string'
+      ? { type: meta } // 'commit' | 'asset' | 'tag'
+      : { type: 'none' }
+
 export const parseEnv = ({GH_USER, GH_USERNAME, GITHUB_USER, GITHUB_USERNAME, GH_TOKEN, GITHUB_TOKEN, NPM_TOKEN, NPM_REGISTRY, NPMRC, NPM_USERCONFIG, NPM_CONFIG_USERCONFIG, NPM_PROVENANCE, GIT_COMMITTER_NAME, GIT_COMMITTER_EMAIL} = process.env) =>
   ({
     ghUser:             GH_USER || GH_USERNAME || GITHUB_USER || GITHUB_USERNAME,

package/src/main/js/index.js

@@ -1 +1 @@
-export {run} from './processor.js'
+export {run} from './processor/release.js'

package/src/main/js/{deps.js → processor/deps.js}

@@ -53,7 +53,7 @@ export const subsWorkspace = (decl, actual) => {
 
 export const topo = async ({flags = {}, cwd} = {}) => {
   const ignore = typeof flags.ignore === 'string'
-    ? flags.ignore.split(/\s*,\s*/)
+    ? flags.ignore.split(',').map(c => c.trim())
     : Array.isArray(flags.ignore)
       ? flags.ignore
       : []

package/src/main/js/processor/exec.js

@@ -0,0 +1,16 @@
+import {tpl} from '../util.js'
+import {log} from '../log.js'
+import {$} from 'zx-extra'
+
+export const exec = async (pkg, name) => {
+  const cmd = tpl(pkg.config[name], {...pkg, ...pkg.context})
+  const now = Date.now()
+
+  if (cmd) {
+    log({pkg})(`run ${name} '${cmd}'`)
+    const result = await $.o({cwd: pkg.absPath, quote: v => v, preferLocal: true})`${cmd}`
+
+    log({pkg})(`duration ${name}: ${Date.now() - now}`)
+    return result
+  }
+}

package/src/main/js/{meta.js → processor/meta.js}

@@ -3,12 +3,13 @@
 import {Buffer} from 'node:buffer'
 import {queuefy} from 'queuefy'
 import {semver, $, fs, path} from 'zx-extra'
-import {log} from './log.js'
-import {fetchRepo, pushCommit, getTags as getGitTags, pushTag} from './git.js'
-import {fetchManifest} from './npm.js'
+import {log} from '../log.js'
+import {fetchRepo, pushCommit, getTags as getGitTags, pushTag, getRepo} from '../api/git.js'
+import {fetchManifest} from '../api/npm.js'
+import {ghGetAsset} from '../api/gh.js'
 
 export const pushReleaseTag = async (pkg) => {
-  const {name, version, tag = formatTag({name, version}),config: {gitCommitterEmail, gitCommitterName}} = pkg
+  const {name, version, tag = formatTag({name, version}), config: {gitCommitterEmail, gitCommitterName}} = pkg
   const cwd = pkg.context.git.root
 
   pkg.context.git.tag = tag
@@ -17,33 +18,55 @@ export const pushReleaseTag = async (pkg) => {
   await pushTag({cwd, tag, gitCommitterEmail, gitCommitterName})
 }
 
-export const pushMeta = queuefy(async (pkg) => {
-  log({pkg})('push artifact to branch \'meta\'')
-
-  const {name, version, tag = formatTag({name, version}), absPath: cwd, config: {gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
-  const to = '.'
-  const branch = 'meta'
-  const msg = `chore: release meta ${name} ${version}`
+export const prepareMeta = async (pkg) => {
+  const {absPath: cwd} = pkg
   const hash = (await $.o({cwd})`git rev-parse HEAD`).toString().trim()
-  const meta = {
+  pkg.meta = {
     META_VERSION: '1',
-    name: pkg.name,
     hash,
+    name: pkg.name,
     version: pkg.version,
     dependencies: pkg.dependencies,
     devDependencies: pkg.devDependencies,
     peerDependencies: pkg.peerDependencies,
     optionalDependencies: pkg.optionalDependencies,
   }
+}
+
+export const pushMeta = queuefy(async (pkg) => {
+  const {type} = pkg.config.meta
+
+  if (type === null) {
+    return
+  }
+
+  if (!pkg.meta) {
+    await prepareMeta(pkg)
+  }
+
+  if (type === 'asset' || type === 'assets') {
+    pkg.config.ghAssets = [...pkg.config.ghAssets || [], {
+      name: 'meta.json',
+      contents: JSON.stringify(pkg.meta, null, 2)
+    }]
+    return
+  }
+
+  log({pkg})('push artifact to branch \'meta\'')
+
+  const {name, version, meta, tag = formatTag({name, version}), absPath: cwd, config: {gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
+  const to = '.'
+  const branch = 'meta'
+  const msg = `chore: release meta ${name} ${version}`
   const files = [{relpath: `${getArtifactPath(tag)}.json`, contents: meta}]
 
   await pushCommit({cwd, to, branch, msg, files, gitCommitterEmail, gitCommitterName, basicAuth})
 })
 
 export const getLatest = async (pkg) => {
-  const {absPath: cwd, name, config: {ghBasicAuth: basicAuth}} = pkg
+  const {absPath: cwd, name } = pkg
   const tag = await getLatestTag(cwd, name)
-  const meta = await getLatestMeta(cwd, tag?.ref, basicAuth) || await fetchManifest(pkg, {nothrow: true})
+  const meta = await getLatestMeta(pkg, tag)
 
   return {
     tag,
@@ -192,9 +215,16 @@ export const parseDateTag = (date) => new Date(date.replaceAll('.', '-')+'Z')
 
 export const getArtifactPath = (tag) => tag.toLowerCase().replace(/[^a-z0-9-]/g, '-')
 
-export const getLatestMeta = async (cwd, tag, basicAuth) => {
+export const getLatestMeta = async (pkg, tag) => {
   if (!tag) return
 
+  const {absPath: cwd, config: {ghBasicAuth: basicAuth}} = pkg
+  const {repoName} = await getRepo(cwd, {basicAuth})
+
+  try {
+    return JSON.parse(await ghGetAsset({repoName, tag, name: 'meta.json'}))
+  } catch {}
+
   try {
     const _cwd = await fetchRepo({cwd, branch: 'meta', basicAuth})
     return await Promise.any([
@@ -202,4 +232,6 @@ export const getLatestMeta = async (cwd, tag, basicAuth) => {
       fs.readJson(path.resolve(_cwd, getArtifactPath(tag), 'meta.json'))
     ])
   } catch {}
+
+  return fetchManifest(pkg, {nothrow: true})
 }

package/src/main/js/processor/release.js

@@ -0,0 +1,95 @@
+import os from 'node:os'
+import {createRequire} from 'node:module'
+import {$, within} from 'zx-extra'
+import {queuefy} from 'queuefy'
+import {topo, traverseQueue} from './deps.js'
+import {createReport} from '../log.js'
+import {exec} from './exec.js'
+import {contextify} from '../steps/contextify.js'
+import {analyze} from '../steps/analyze.js'
+import {build} from '../steps/build.js'
+import {publish} from '../steps/publish.js'
+import {clean} from '../steps/clean.js'
+
+export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within(async () => {
+  const {version: zbrVersion} = createRequire(import.meta.url)('../../../../package.json')
+  if (flags.v || flags.version) {
+    console.log(zbrVersion)
+    return
+  }
+
+  const context = await createContext({flags, env, cwd})
+  const {report, packages, queue, prev, graphs} = context
+  const _exec = queuefy(exec, flags.concurrency || os.cpus().length)
+
+  report
+    .log()(`zx-bulk-release@${zbrVersion}`)
+    .log()('queue:', queue)
+    .log()('graphs', graphs)
+
+  try {
+    await traverseQueue({queue, prev, async cb(name) {
+      report.setStatus('analyzing', name)
+      const pkg = packages[name]
+      await contextify(pkg, context)
+      await analyze(pkg)
+      report
+        .set('config', pkg.config, name)
+        .set('version', pkg.version, name)
+        .set('prevVersion', pkg.latest.tag?.version || pkg.manifest.version, name)
+        .set('releaseType', pkg.releaseType, name)
+        .set('tag', pkg.tag, name)
+    }})
+
+    report.setStatus('pending')
+
+    await traverseQueue({queue, prev, async cb(name) {
+      const pkg = packages[name]
+
+      if (!pkg.releaseType) {
+        report.setStatus('skipped', name)
+        return
+      }
+      if (flags.build !== false) {
+        report.setStatus('building', name)
+        await build(pkg, _exec)
+      }
+      if (!flags.dryRun && flags.publish !== false) {
+        report.setStatus('publishing', name)
+        await publish(pkg, _exec)
+      }
+
+      report.setStatus('success', name)
+    }})
+  } catch (e) {
+    report
+      .log({level: 'error'})(e, e.stack)
+      .set('error', e)
+      .setStatus('failure')
+    throw e
+  } finally {
+    await clean(cwd, packages)
+  }
+  report
+    .setStatus('success')
+    .log()('Great success!')
+})
+
+export const createContext = async ({flags, env, cwd}) => {
+  const { packages, queue, root, prev, graphs } = await topo({cwd, flags})
+  const report = createReport({packages, queue, flags})
+
+  $.report =        report
+  $.env =           {...process.env, ...env}
+  $.verbose =       !!(flags.debug || $.env.DEBUG ) || $.verbose
+
+  return {
+    report,
+    packages,
+    root,
+    queue,
+    prev,
+    graphs,
+    flags
+  }
+}

package/src/main/js/{analyze.js → steps/analyze.js}

@@ -1,8 +1,8 @@
 import {semver} from 'zx-extra'
-import {updateDeps} from './deps.js'
-import {formatTag} from './meta.js';
-import {log} from './log.js'
-import {getCommits} from './git.js'
+import {log} from '../log.js'
+import {getCommits} from '../api/git.js'
+import {updateDeps} from '../processor/deps.js'
+import {formatTag} from '../processor/meta.js';
 
 export const analyze = async (pkg) => {
   const semanticChanges = await getSemanticChanges(pkg.absPath, pkg.latest.tag?.ref, undefined, pkg.config.releaseRules)

package/src/main/js/steps/build.js

@@ -0,0 +1,23 @@
+import {memoizeBy} from '../util.js'
+import {$, within} from 'zx-extra'
+import {fetchPkg} from '../api/npm.js'
+import {traverseDeps} from '../processor/deps.js'
+import {exec} from '../processor/exec.js'
+
+export const build = memoizeBy(async (pkg, run = exec, flags = {}, self = build) => within(async () => {
+  $.scope = pkg.name
+
+  await Promise.all([
+    traverseDeps({pkg, packages: pkg.context.packages, cb: async({pkg}) => self(pkg, run, flags, self)}),
+    pkg.manifest.private !== true && pkg.changes.length === 0 && pkg.config.npmFetch && flags.npmFetch !== false
+      ? fetchPkg(pkg)
+      : Promise.resolve()
+  ])
+
+  if (!pkg.fetched) {
+    await run(pkg, 'buildCmd')
+    await run(pkg, 'testCmd')
+  }
+
+  pkg.built = true
+}))

package/src/main/js/steps/clean.js

@@ -0,0 +1,7 @@
+import {unsetUserConfig} from '../api/git.js'
+import {npmRestore} from '../api/npm.js'
+
+export const clean = async (cwd, packages) => {
+  await unsetUserConfig(cwd)
+  await Promise.all(Object.values(packages).map(npmRestore))
+}

package/src/main/js/steps/contextify.js

@@ -0,0 +1,19 @@
+import {getPkgConfig} from '../config.js'
+import {getLatest} from '../processor/meta.js'
+import {getRoot, getSha} from '../api/git.js'
+import {$} from 'zx-extra'
+
+// Inspired by https://docs.github.com/en/actions/learn-github-actions/contexts
+export const contextify = async (pkg, {packages, root, flags}) => {
+  pkg.config = await getPkgConfig(pkg.absPath, root.absPath)
+  pkg.latest = await getLatest(pkg)
+  pkg.context = {
+    git: {
+      sha: await getSha(pkg.absPath),
+      root: await getRoot(pkg.absPath)
+    },
+    env: $.env,
+    flags,
+    packages
+  }
+}

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

@@ -0,0 +1,40 @@
+import {memoizeBy} from '../util.js'
+import {exec} from '../processor/exec.js'
+import {$, within} from 'zx-extra'
+import {npmPersist, npmPublish} from '../api/npm.js'
+import {prepareMeta, pushMeta, pushReleaseTag} from '../processor/meta.js'
+import {pushChangelog} from '../api/changelog.js'
+import {ghPages, ghRelease} from '../api/gh.js'
+
+export const publish = memoizeBy(async (pkg, run = exec) => within(async () => {
+  $.scope = pkg.name
+
+  // Debug
+  // https://www.npmjs.com/package/@packasso/preset-ts-tsc-uvu/v/0.0.0?activeTab=code
+  // https://github.com/qiwi/packasso/actions/runs/4514909191/jobs/7951564982#step:7:817
+  // https://github.com/qiwi/packasso/blob/meta/2023-3-24-packasso-preset-ts-tsc-uvu-0-21-0-f0.json
+  if (pkg.version !== pkg.manifest.version) {
+    throw new Error('package.json version not synced')
+  }
+
+  await npmPersist(pkg)
+  await prepareMeta(pkg)
+
+  if (pkg.context.flags.snapshot) {
+    await Promise.all([
+      npmPublish(pkg),
+      run(pkg, 'publishCmd')
+    ])
+  } else {
+    await pushReleaseTag(pkg)
+    await Promise.all([
+      pushMeta(pkg),
+      pushChangelog(pkg),
+      npmPublish(pkg),
+      ghRelease(pkg),
+      ghPages(pkg),
+      run(pkg, 'publishCmd')
+    ])
+  }
+  pkg.published = true
+}))

package/src/main/js/util.js

@@ -1,3 +1,8 @@
+import zlib from 'node:zlib'
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import tar from 'tar-stream'
+
 export const tpl = (str, context) =>
   str?.replace(/\$\{\{\s*([.a-z0-9]+)\s*}}/gi, (matched, key) => get(context, key) ?? '')
 
@@ -60,3 +65,52 @@ export const getCommonPath = files => {
 
   return p.slice(0, p.lastIndexOf('/') + 1)
 }
+
+export const safePath = v => path.resolve('/', v).slice(1)
+
+// https://stackoverflow.com/questions/19978452/how-to-extract-single-file-from-tar-gz-archive-using-node-js
+export const unzip = (stream, {pick, omit, cwd = process.cwd(), strip = 0} = {}) => new Promise((resolve, reject) => {
+  const extract = tar.extract()
+  const results = []
+
+  extract.on('entry', ({name, type}, stream, cb)=>  {
+    const _name = safePath(strip ? name.split('/').slice(strip).join('/') : name)
+    const fp = path.join(cwd, _name)
+
+    let data = ''
+    stream.on('data', (chunk) => {
+      if (type !== 'file') {
+        return
+      }
+      if (omit?.includes(_name)) {
+        return
+      }
+      if (pick && !pick.includes(_name)) {
+        return
+      }
+
+      data +=chunk
+    })
+
+    stream.on('end', () => {
+      if (data) {
+        results.push(
+          fs.mkdir(path.dirname(fp), {recursive: true})
+            .then(() => fs.writeFile(fp, data, 'utf8'))
+        )
+      }
+      cb()
+    })
+
+    stream.resume()
+  })
+
+  extract.on('finish', ()=> {
+    resolve(Promise.all(results))
+  })
+
+  // fs.createReadStream('archive.tar.gz')
+  stream
+    .pipe(zlib.createGunzip())
+    .pipe(extract)
+})

package/src/main/js/processor.js

@@ -1,180 +0,0 @@
-import os from 'node:os'
-import {createRequire} from 'node:module'
-import {$, within} from 'zx-extra'
-import {queuefy} from 'queuefy'
-import {analyze} from './analyze.js'
-import {pushChangelog} from './changelog.js'
-import {getPkgConfig} from './config.js'
-import {topo, traverseDeps, traverseQueue} from './deps.js'
-import {ghPages, ghRelease} from './gh.js'
-import {getRoot, getSha, unsetUserConfig} from './git.js'
-import {log, createReport} from './log.js'
-import {getLatest, pushMeta, pushReleaseTag} from './meta.js'
-import {fetchPkg, npmPersist, npmPublish, npmRestore} from './npm.js'
-import {memoizeBy, tpl} from './util.js'
-
-export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within(async () => {
-  const {version: zbrVersion} = createRequire(import.meta.url)('../../../package.json')
-  if (flags.v || flags.version) {
-    console.log(zbrVersion)
-    return
-  }
-
-  const context = await createContext({flags, env, cwd})
-  const {report, packages, queue, prev, graphs} = context
-  const _runCmd = queuefy(runCmd, flags.concurrency || os.cpus().length)
-
-  report
-    .log()(`zx-bulk-release@${zbrVersion}`)
-    .log()('queue:', queue)
-    .log()('graphs', graphs)
-
-  try {
-    await traverseQueue({queue, prev, async cb(name) {
-      report.setStatus('analyzing', name)
-      const pkg = packages[name]
-      await contextify(pkg, context)
-      await analyze(pkg)
-      report
-        .set('config', pkg.config, name)
-        .set('version', pkg.version, name)
-        .set('prevVersion', pkg.latest.tag?.version || pkg.manifest.version, name)
-        .set('releaseType', pkg.releaseType, name)
-        .set('tag', pkg.tag, name)
-    }})
-
-    report.setStatus('pending')
-
-    await traverseQueue({queue, prev, async cb(name) {
-      const pkg = packages[name]
-
-      if (!pkg.releaseType) {
-        report.setStatus('skipped', name)
-        return
-      }
-      if (flags.build !== false) {
-        report.setStatus('building', name)
-        await build(pkg, _runCmd)
-      }
-      if (!flags.dryRun && flags.publish !== false) {
-        report.setStatus('publishing', name)
-        await publish(pkg, _runCmd)
-      }
-
-      report.setStatus('success', name)
-    }})
-  } catch (e) {
-    report
-      .log({level: 'error'})(e, e.stack)
-      .set('error', e)
-      .setStatus('failure')
-    throw e
-  } finally {
-    await clean(cwd, packages)
-  }
-  report
-    .setStatus('success')
-    .log()('Great success!')
-})
-
-export const runCmd = async (pkg, name) => {
-  const cmd = tpl(pkg.config[name], {...pkg, ...pkg.context})
-  const now = Date.now()
-
-  if (cmd) {
-    log({pkg})(`run ${name} '${cmd}'`)
-    const result = await $.o({cwd: pkg.absPath, quote: v => v, preferLocal: true})`${cmd}`
-
-    log({pkg})(`duration ${name}: ${Date.now() - now}`)
-    return result
-  }
-}
-
-const createContext = async ({flags, env, cwd}) => {
-  const { packages, queue, root, prev, graphs } = await topo({cwd, flags})
-  const report =    createReport({packages, queue, flags})
-
-  $.report =        report
-  $.env =           {...process.env, ...env}
-  $.verbose =       !!(flags.debug || $.env.DEBUG ) || $.verbose
-
-  return {
-    report,
-    packages,
-    root,
-    queue,
-    prev,
-    graphs,
-    flags
-  }
-}
-
-// Inspired by https://docs.github.com/en/actions/learn-github-actions/contexts
-const contextify = async (pkg, {packages, root, flags}) => {
-  pkg.config = await getPkgConfig(pkg.absPath, root.absPath)
-  pkg.latest = await getLatest(pkg)
-  pkg.context = {
-    git: {
-      sha: await getSha(pkg.absPath),
-      root: await getRoot(pkg.absPath)
-    },
-    env: $.env,
-    flags,
-    packages
-  }
-}
-
-const build = memoizeBy(async (pkg, run = runCmd, flags = {}, self = build) => within(async () => {
-  $.scope = pkg.name
-
-  await Promise.all([
-    traverseDeps({pkg, packages: pkg.context.packages, cb: async({pkg}) => self(pkg, run, flags, self)}),
-    pkg.manifest.private !== true && pkg.changes.length === 0 && pkg.config.npmFetch && flags.npmFetch !== false
-      ? fetchPkg(pkg)
-      : Promise.resolve()
-  ])
-
-  if (!pkg.fetched) {
-    await run(pkg, 'buildCmd')
-    await run(pkg, 'testCmd')
-  }
-
-  pkg.built = true
-}))
-
-const publish = memoizeBy(async (pkg, run = runCmd) => within(async () => {
-  $.scope = pkg.name
-
-  // Debug
-  // https://www.npmjs.com/package/@packasso/preset-ts-tsc-uvu/v/0.0.0?activeTab=code
-  // https://github.com/qiwi/packasso/actions/runs/4514909191/jobs/7951564982#step:7:817
-  // https://github.com/qiwi/packasso/blob/meta/2023-3-24-packasso-preset-ts-tsc-uvu-0-21-0-f0.json
-  if (pkg.version !== pkg.manifest.version) {
-    throw new Error('package.json version not synced')
-  }
-
-  await npmPersist(pkg)
-
-  if (pkg.context.flags.snapshot) {
-    await Promise.all([
-      npmPublish(pkg),
-      run(pkg, 'publishCmd')
-    ])
-  } else {
-    await pushReleaseTag(pkg)
-    await Promise.all([
-      pushMeta(pkg),
-      pushChangelog(pkg),
-      npmPublish(pkg),
-      ghRelease(pkg),
-      ghPages(pkg),
-      run(pkg, 'publishCmd')
-    ])
-  }
-  pkg.published = true
-}))
-
-const clean = async (cwd, packages) => {
-  await unsetUserConfig(cwd)
-  await Promise.all(Object.values(packages).map(npmRestore))
-}