zx-bulk-release 2.1.6 → 2.2.1

package/CHANGELOG.md

@@ -1,3 +1,17 @@
+## [2.2.1](https://github.com/semrel-extra/zx-bulk-release/compare/v2.2.0...v2.2.1) (2023-03-23)
+
+### Fixes & improvements
+* perf: make parallel internal `publish` tasks ([87f388e](https://github.com/semrel-extra/zx-bulk-release/commit/87f388ea2ff5cce96cca600903d80260f13f0908))
+* refactor: improve internal reporter ([cc62df7](https://github.com/semrel-extra/zx-bulk-release/commit/cc62df762c0581db159ddd2fae8d90b085911884))
+
+## [2.2.0](https://github.com/semrel-extra/zx-bulk-release/compare/v2.1.6...v2.2.0) (2023-03-23)
+
+### Fixes & improvements
+* fix: fix basicAuth tpl ([b6af2f5](https://github.com/semrel-extra/zx-bulk-release/commit/b6af2f51a2e13ddb5a3b6b1ef288595aae61e746))
+
+### Features
+* feat: inherit gh and npm creds from pkg release configs ([f07dd4f](https://github.com/semrel-extra/zx-bulk-release/commit/f07dd4fa0cf9d26942780ccf0c34406b345dae39))
+
 ## [2.1.6](https://github.com/semrel-extra/zx-bulk-release/compare/v2.1.5...v2.1.6) (2023-03-22)
 
 ### Fixes & improvements

package/README.md

@@ -146,9 +146,10 @@ By default, it omits the packages marked as `private`. You can override this by
 
 ### `analyze`
 Determines pkg changes, release type, next version etc.
+
 ```js
 export const analyze = async (pkg, packages, root) => {
-  pkg.config = await getConfig(pkg.absPath, root.absPath)
+  pkg.config = await getPkgConfig(pkg.absPath, root.absPath)
   pkg.latest = await getLatest(pkg)
 
   const semanticChanges = await getSemanticChanges(pkg.absPath, pkg.latest.tag?.ref)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zx-bulk-release",
-  "version": "2.1.6",
+  "version": "2.2.1",
   "description": "zx-based alternative for multi-semantic-release",
   "type": "module",
   "exports": {

package/src/main/js/analyze.js

@@ -1,7 +1,8 @@
-import {ctx, semver} from 'zx-extra'
+import {semver} from 'zx-extra'
 import {updateDeps} from './deps.js'
-import {formatTag} from './tag.js';
+import {formatTag} from './meta.js';
 import {log} from './log.js'
+import {getCommits} from './git.js'
 
 export const analyze = async (pkg, packages) => {
   const semanticChanges = await getSemanticChanges(pkg.absPath, pkg.latest.tag?.ref)
@@ -25,22 +26,8 @@ export const semanticRules = [
   {group: 'BREAKING CHANGES', releaseType: 'major', keywords: ['BREAKING CHANGE', 'BREAKING CHANGES']},
 ]
 
-export const getPkgCommits = async (cwd, since) => ctx(async ($) => {
-  const range = since ? `${since}..HEAD` : 'HEAD'
-
-  $.cwd = cwd
-  return (await $.raw`git log ${range} --format=+++%s__%b__%h__%H -- .`)
-    .toString()
-    .split('+++')
-    .filter(Boolean)
-    .map(msg => {
-      const [subj, body, short, hash] = msg.split('__').map(raw => raw.trim())
-      return {subj, body, short, hash}
-    })
-})
-
-export const getSemanticChanges = async (cwd, since) => {
-  const commits = await getPkgCommits(cwd, since)
+export const getSemanticChanges = async (cwd, from, to) => {
+  const commits = await getCommits(cwd, from, to)
 
   return analyzeCommits(commits)
 }

package/src/main/js/changelog.js

@@ -0,0 +1,42 @@
+import {$} from 'zx-extra'
+import {log} from './log.js'
+import {fetchRepo, getRepo, pushCommit} from './git.js'
+import {msgJoin} from './util.js'
+import {formatTag} from './meta.js'
+
+export const pushChangelog = async (pkg) => {
+  const {absPath: cwd, config: {changelog: opts, gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
+  if (!opts) return
+
+  log({pkg})('push changelog')
+  const [branch = 'changelog', file = `${pkg.name.replace(/[^a-z0-9-]/ig, '')}-changelog.md`, ..._msg] = typeof opts === 'string'
+    ? opts.split(' ')
+    : [opts.branch, opts.file, opts.msg]
+  const _cwd = await fetchRepo({cwd, branch, basicAuth})
+  const msg = msgJoin(_msg, pkg, 'chore: update changelog ${{name}}')
+  const releaseNotes = await formatReleaseNotes(pkg)
+
+  await $.o({cwd: _cwd})`echo ${releaseNotes}"\n$(cat ./${file})" > ./${file}`
+  await pushCommit({cwd, branch, msg, gitCommitterEmail, gitCommitterName, basicAuth})
+}
+
+export const formatReleaseNotes = async (pkg) => {
+  const {name, version, absPath: cwd, config: {ghBasicAuth: basicAuth}} = pkg
+  const {repoPublicUrl} = await getRepo(cwd, {basicAuth})
+  const tag = formatTag({name, version})
+  const releaseDiffRef = `## [${name}@${version}](${repoPublicUrl}/compare/${pkg.latest.tag?.ref}...${tag}) (${new Date().toISOString().slice(0, 10)})`
+  const releaseDetails = Object.values(pkg.changes
+    .reduce((acc, {group, subj, short, hash}) => {
+      const {commits} = acc[group] || (acc[group] = {commits: [], group})
+      const commitRef = `* ${subj}${short ? ` [${short}](${repoPublicUrl}/commit/${hash})` : ''}`
+
+      commits.push(commitRef)
+
+      return acc
+    }, {}))
+    .map(({group, commits}) => `
+### ${group}
+${commits.join('\n')}`).join('\n')
+
+  return releaseDiffRef + '\n' + releaseDetails + '\n'
+}

package/src/main/js/config.js

@@ -1,4 +1,5 @@
 import { cosmiconfig } from 'cosmiconfig'
+import { camelize } from './util.js'
 
 const CONFIG_NAME = 'release'
 const CONFIG_FILES = [
@@ -15,22 +16,26 @@ const CONFIG_FILES = [
 
 export const defaultConfig = {
   cmd: 'yarn && yarn build && yarn test',
-  npmFetch: true,
   changelog: 'changelog',
+  npmFetch: true,
   ghRelease: true,
   // npmPublish: true,
   // ghPages: 'gh-pages'
 }
 
-export const getConfig = async (...cwds) =>
-  normalizeConfig((await Promise.all(cwds.map(
+export const getPkgConfig = async (...cwds) =>
+  normalizePkgConfig((await Promise.all(cwds.map(
     cwd => cosmiconfig(CONFIG_NAME, { searchPlaces: CONFIG_FILES }).search(cwd).then(r => r?.config)
   ))).find(Boolean) || defaultConfig)
 
-export const normalizeConfig = config => ({
+export const normalizePkgConfig = (config, env) => ({
+  ...parseEnv(env),
   ...config,
   npmFetch: config.npmFetch || config.fetch || config.fetchPkg,
-  buildCmd: config.buildCmd || config.cmd
+  buildCmd: config.buildCmd || config.cmd,
+  get ghBasicAuth() {
+    return this.ghUser && this.ghToken ? `${this.ghUser}:${this.ghToken}` : false
+  }
 })
 
 export const parseEnv = (env = process.env) => {
@@ -47,5 +52,4 @@ export const parseEnv = (env = process.env) => {
   }
 }
 
-const camelize = s => s.replace(/-./g, x => x[1].toUpperCase())
 export const normalizeFlags = (flags = {}) => Object.entries(flags).reduce((acc, [k, v]) => ({...acc, [camelize(k)]: v}), {})

package/src/main/js/gh.js

@@ -0,0 +1,48 @@
+import {log} from './log.js'
+import {getRepo, pushCommit} from './git.js'
+import {formatTag} from './meta.js'
+import {formatReleaseNotes} from './changelog.js'
+import {$, path} from 'zx-extra'
+import {msgJoin} from './util.js'
+
+export const ghRelease = async (pkg) => {
+  log({pkg})(`create gh release`)
+
+  const {ghBasicAuth: basicAuth, ghToken} = pkg.config
+  if (!ghToken) return null
+
+  const {name, version, absPath: cwd} = pkg
+  const {repoName} = await getRepo(cwd, {basicAuth})
+  const tag = formatTag({name, version})
+  const releaseNotes = await formatReleaseNotes(pkg)
+  const releaseData = JSON.stringify({
+    name: tag,
+    tag_name: tag,
+    body: releaseNotes
+  })
+
+  await $.o({cwd})`curl -H 'Authorization: token ${ghToken}' -H 'Accept: application/vnd.github.v3+json' https://api.github.com/repos/${repoName}/releases -d ${releaseData}`
+}
+
+export const ghPages = async (pkg) => {
+  const {config: {ghPages: opts, gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
+  if (!opts) return
+
+  const [branch = 'gh-pages', from = 'docs', to = '.', ..._msg] = typeof opts === 'string'
+    ? opts.split(' ')
+    : [opts.branch, opts.from, opts.to, opts.msg]
+  const msg = msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}')
+
+  log({pkg})(`publish docs to ${branch}`)
+
+  await pushCommit({
+    cwd: path.join(pkg.absPath, from),
+    from: '.',
+    to,
+    branch,
+    msg,
+    gitCommitterEmail,
+    gitCommitterName,
+    basicAuth
+  })
+}

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

@@ -1,16 +1,15 @@
 import {$, ctx, fs, path, tempy, copy} from 'zx-extra'
-import {parseEnv} from './config.js'
 import {log} from './log.js'
 import {keyByValue} from './util.js'
 
 const branches = {}
-export const fetch = async ({cwd: _cwd, branch, origin: _origin}) => ctx(async ($) => {
+export const fetchRepo = async ({cwd: _cwd, branch, origin: _origin, basicAuth}) => ctx(async ($) => {
   const root = await getRoot(_cwd)
   const id = `${root}:${branch}`
 
   if (branches[id]) return branches[id]
 
-  const origin = _origin || (await parseRepo(_cwd)).repoAuthedUrl
+  const origin = _origin || (await getRepo(_cwd, {basicAuth})).repoAuthedUrl
   const cwd = tempy.temporaryDirectory()
   $.cwd = cwd
   try {
@@ -25,14 +24,13 @@ export const fetch = async ({cwd: _cwd, branch, origin: _origin}) => ctx(async (
   return branches[id]
 })
 
-export const push = async ({cwd, from, to, branch, origin, msg, ignoreFiles, files = []}) => ctx(async ($) => {
+export const pushCommit = async ({cwd, from, to, branch, origin, msg, ignoreFiles, files = [], basicAuth, gitCommitterEmail, gitCommitterName}) => ctx(async ($) => {
   let retries = 3
   let _cwd
 
   while (retries > 0) {
     try {
-      const {gitCommitterEmail, gitCommitterName} = parseEnv($.env)
-      _cwd = await fetch({cwd, branch, origin})
+      _cwd = await fetchRepo({cwd, branch, origin, basicAuth})
 
       for (let {relpath, contents} of files) {
         const _contents = typeof contents === 'string' ? contents : JSON.stringify(contents, null, 2)
@@ -56,22 +54,21 @@ export const push = async ({cwd, from, to, branch, origin, msg, ignoreFiles, fil
     } catch (e) {
       retries -= 1
       branches[keyByValue(branches, _cwd)] = null
-      console.warn('git push failed', 'retries left', retries, e)
+      log({level: 'warn'})('git push failed', 'retries left', retries, e)
     }
   }
 })
 
 const repos = {}
-export const parseRepo = async (_cwd) => {
+export const getRepo = async (_cwd, {basicAuth} = {}) => {
   const cwd = await getRoot(_cwd)
   if (repos[cwd]) return repos[cwd]
 
-  const {ghToken, ghUser} = parseEnv($.env)
   const originUrl = await getOrigin(cwd)
   const [, , repoHost, repoName] = originUrl.replace(':', '/').replace(/\.git/, '').match(/.+(@|\/\/)([^/]+)\/(.+)$/) || []
   const repoPublicUrl = `https://${repoHost}/${repoName}`
-  const repoAuthedUrl = ghToken && ghUser && repoHost && repoName
-    ? `https://${ghUser}:${ghToken}@${repoHost}/${repoName}.git`
+  const repoAuthedUrl = basicAuth && repoHost && repoName
+    ? `https://${basicAuth}@${repoHost}/${repoName}.git`
     : originUrl
 
   repos[cwd] = {
@@ -95,3 +92,24 @@ export const getOrigin = async (cwd) => {
 }
 
 export const getRoot = async (cwd) => (await $.o({cwd})`git rev-parse --show-toplevel`).toString().trim()
+
+export const getSha = async (cwd) => (await $.o({cwd})`git rev-parse HEAD`).toString().trim()
+
+export const getCommits = async (cwd, from, to = 'HEAD') => ctx(async ($) => {
+  const ref = from ? `${from}..${to}` : to
+
+  $.cwd = cwd
+  return (await $.raw`git log ${ref} --format=+++%s__%b__%h__%H -- .`)
+    .toString()
+    .split('+++')
+    .filter(Boolean)
+    .map(msg => {
+      const [subj, body, short, hash] = msg.split('__').map(raw => raw.trim())
+      return {subj, body, short, hash}
+    })
+})
+
+export const getTags = async (cwd, ref = '') =>
+  (await $.o({cwd})`git tag -l ${ref}`)
+    .toString()
+    .split('\n')

package/src/main/js/log.js

@@ -1,9 +1,69 @@
-import {$} from 'zx-extra'
+import {$, fs} from 'zx-extra'
+import {get, set, tpl} from './util.js'
 
 export const log = (ctx) => {
-  if ($.state) {
-    return $.state.log(ctx)
+  if ($.report) {
+    return $.report.log(ctx)
   }
 
   return console.log
 }
+
+export const createReport = ({logger = console, file = null} = {}) => ({
+  logger,
+  file,
+  status: 'initial',
+  queue: [],
+  packages: {},
+  events: [],
+  setPackages(packages) {
+    this.packages = Object.entries(packages).reduce((acc, [name, {manifest: {version}, absPath, relPath}]) => {
+      acc[name] = {
+        status: 'initial',
+        name,
+        version,
+        path: absPath,
+        relPath
+      }
+      return acc
+    }, {})
+    return this
+  },
+  get(key, pkgName) {
+    return get(
+      pkgName ? this.packages[pkgName] : this,
+      key
+    )
+  },
+  set(key, value, pkgName) {
+    set(
+      pkgName ? this.packages[pkgName] : this,
+      key,
+      value
+    )
+    return this
+  },
+  setStatus(status, name) {
+    this.set('status', status, name)
+    this.save()
+    return this
+  },
+  getStatus(status, name) {
+    return this.get('status', name)
+  },
+  log(ctx = {}) {
+    return function (...chunks) {
+      const {pkg, scope = pkg?.name || '~', level = 'info'} = ctx
+      const msg = chunks.map(c => typeof c === 'string' ? tpl(c, ctx) : c)
+      const event = {msg, scope, date: Date.now(), level}
+      this.events.push(event)
+      logger[level](`[${scope}]`, ...msg)
+
+      return this
+    }.bind(this)
+  },
+  save() {
+    this.file && fs.outputJsonSync(this.file, this)
+    return this
+  }
+})

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

@@ -1,14 +1,14 @@
 // Semantic tags processing
 
-import {ctx, semver, $} from 'zx-extra'
+import {ctx, semver, $, fs, path} from 'zx-extra'
 import {Buffer} from 'buffer'
-import {parseEnv} from './config.js'
 import {log} from './log.js'
+import {fetchRepo, pushCommit, getTags as getGitTags} from './git.js'
+import {fetchManifest} from './npm.js'
 
 export const pushTag = (pkg) => ctx(async ($) => {
-  const {absPath: cwd, name, version} = pkg
+  const {absPath: cwd, name, version, config: {gitCommitterEmail, gitCommitterName}} = pkg
   const tag = formatTag({name, version})
-  const {gitCommitterEmail, gitCommitterName} = parseEnv($.env)
 
   pkg.context.git.tag = tag
   log({pkg})(`push release tag ${tag}`)
@@ -20,6 +20,41 @@ export const pushTag = (pkg) => ctx(async ($) => {
   await $`git push origin ${tag}`
 })
 
+export const pushMeta = async (pkg) => {
+  log({pkg})('push artifact to branch \'meta\'')
+
+  const {name, version, absPath: cwd, config: {gitCommitterEmail, gitCommitterName, ghBasicAuth: basicAuth}} = pkg
+  const tag = formatTag({name, version})
+  const to = '.'
+  const branch = 'meta'
+  const msg = `chore: release meta ${name} ${version}`
+  const hash = (await $.o({cwd})`git rev-parse HEAD`).toString().trim()
+  const meta = {
+    META_VERSION: '1',
+    name: pkg.name,
+    hash,
+    version: pkg.version,
+    dependencies: pkg.dependencies,
+    devDependencies: pkg.devDependencies,
+    peerDependencies: pkg.peerDependencies,
+    optionalDependencies: pkg.optionalDependencies,
+  }
+  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} = pkg
+  const tag = await getLatestTag(cwd, name)
+  const meta = await getLatestMeta(cwd, tag?.ref) || await fetchManifest(pkg, {nothrow: true})
+
+  return {
+    tag,
+    meta
+  }
+}
+
 const f0 = {
   parse(tag) {
     if (!tag.endsWith('-f0')) return null
@@ -102,9 +137,8 @@ export const parseTag = (tag) => f0.parse(tag) || f1.parse(tag) || lerna.parse(t
 
 export const formatTag = (tag) => f0.format(tag) || f1.format(tag) || null
 
-export const getTags = async (cwd) =>
-  (await $.o({cwd})`git tag -l`).toString()
-    .split('\n')
+export const getTags = async (cwd, ref = '') =>
+  (await getGitTags(cwd, ref))
     .map(tag => parseTag(tag.trim()))
     .filter(Boolean)
     .sort((a, b) => semver.rcompare(a.version, b.version))
@@ -118,3 +152,19 @@ export const getLatestTaggedVersion = async (cwd, name) =>
 export const formatDateTag = (date = new Date()) => `${date.getUTCFullYear()}.${date.getUTCMonth() + 1}.${date.getUTCDate()}`
 
 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) => {
+  if (!tag) return null
+
+  try {
+    const _cwd = await fetchRepo({cwd, branch: 'meta'})
+    return await Promise.any([
+      fs.readJson(path.resolve(_cwd, `${getArtifactPath(tag)}.json`)),
+      fs.readJson(path.resolve(_cwd, getArtifactPath(tag), 'meta.json'))
+    ])
+  } catch {}
+
+  return null
+}

package/src/main/js/npm.js

@@ -1,14 +1,13 @@
-import {parseEnv} from './config.js'
 import {log} from './log.js'
 import {$, ctx, fs, path, INI, fetch} from 'zx-extra'
 
-export const fetchPkg = async (pkg, {env = $.env} = {}) => {
+export const fetchPkg = async (pkg) => {
   const id = `${pkg.name}@${pkg.version}`
 
   try {
     log({pkg})(`fetching '${id}'`)
     const cwd = pkg.absPath
-    const {npmRegistry, npmToken, npmConfig} = parseEnv(env)
+    const {npmRegistry, npmToken, npmConfig} = pkg.config
     const bearerToken = getBearerToken(npmRegistry, npmToken, npmConfig)
     const tarball = getTarballUrl(npmRegistry, pkg.name, pkg.version)
     await $.raw`wget --timeout=10 --header='Authorization: ${bearerToken}' -qO- ${tarball} | tar -xvz --strip-components=1 --exclude='package.json' -C ${cwd}`
@@ -19,8 +18,8 @@ export const fetchPkg = async (pkg, {env = $.env} = {}) => {
   }
 }
 
-export const fetchManifest = async (pkg, {nothrow, env = $.env} = {}) => {
-  const {npmRegistry, npmToken, npmConfig} = parseEnv(env)
+export const fetchManifest = async (pkg, {nothrow} = {}) => {
+  const {npmRegistry, npmToken, npmConfig} = pkg.config
   const bearerToken = getBearerToken(npmRegistry, npmToken, npmConfig)
   const url = getManifestUrl(npmRegistry, pkg.name, pkg.version)
 
@@ -36,9 +35,9 @@ export const fetchManifest = async (pkg, {nothrow, env = $.env} = {}) => {
 }
 
 export const npmPublish = (pkg) => ctx(async ($) => {
-  const {absPath: cwd, name, version, manifest} = pkg
-  if (manifest.private || pkg.config?.npmPublish === false) return
-  const {npmRegistry, npmToken, npmConfig} = parseEnv($.env)
+  const {absPath: cwd, name, version, manifest, config} = pkg
+  if (manifest.private || config?.npmPublish === false) return
+  const {npmRegistry, npmToken, npmConfig} = config
   const npmrc = npmConfig ? npmConfig : path.resolve(cwd, '.npmrc')
 
   log({pkg})(`publish npm package ${name} ${version} to ${npmRegistry}`)

package/src/main/js/processor.js

@@ -1,69 +1,76 @@
 import os from 'node:os'
-import {$, within} from 'zx-extra'
-import {log} from './log.js'
-import {topo, traverseQueue} from './deps.js'
+import {$, fs, within} from 'zx-extra'
+import {queuefy} from 'queuefy'
 import {analyze} from './analyze.js'
-import {build} from './build.js'
-import {getLatest, publish} from './publish.js'
-import {createState} from './state.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} from './git.js'
+import {log, createReport} from './log.js'
+import {getLatest, pushMeta, pushTag} from './meta.js'
+import {fetchPkg, npmPublish} from './npm.js'
 import {memoizeBy, tpl} from './util.js'
-import {queuefy} from 'queuefy'
-import {getConfig} from "./config.js";
 
 export const run = async ({cwd = process.cwd(), env, flags = {}} = {}) => within(async () => {
-  const {state, build, publish} = createContext(flags, env)
+  const {report, build, publish} = createContext(flags, env)
 
-  log()('zx-bulk-release')
+  report.log()('zx-bulk-release')
 
   try {
-    const {packages, queue, root, sources, next, prev, nodes} = await topo({cwd, flags})
-    log()('queue:', queue)
-
-    state.setQueue(queue, packages)
+    const {packages, queue, root, prev, graphs} = await topo({cwd, flags})
+    report
+      .log()('queue:', queue)
+      .log()('graphs', graphs)
+      .set('queue', queue)
+      .setPackages(packages)
 
     await traverseQueue({queue, prev, async cb(name) {
-      state.setStatus('analyzing', name)
+      report.setStatus('analyzing', name)
       const pkg = packages[name]
       await contextify(pkg, packages, root)
       await analyze(pkg, packages)
-      state.set('config', pkg.config, name)
-      state.set('version', pkg.version, name)
-      state.set('prevVersion', pkg.latest.tag?.version || pkg.manifest.version, name)
-      state.set('releaseType', pkg.releaseType, name)
-      state.set('tag', pkg.tag, name)
+      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)
     }})
 
-    state.setStatus('pending')
+    report.setStatus('pending')
 
     await traverseQueue({queue, prev, async cb(name) {
       const pkg = packages[name]
 
       if (!pkg.releaseType) {
-        state.setStatus('skipped', name)
+        report.setStatus('skipped', name)
         return
       }
 
-      state.setStatus('building', name)
+      report.setStatus('building', name)
       await build(pkg, packages)
 
       if (flags.dryRun) {
-        state.setStatus('success', name)
+        report.setStatus('success', name)
         return
       }
 
-      state.setStatus('publishing', name)
+      report.setStatus('publishing', name)
       await publish(pkg)
 
-      state.setStatus('success', name)
+      report.setStatus('success', name)
     }})
   } catch (e) {
-    log({level: 'error'})(e)
-    state.set('error', e)
-    state.setStatus('failure')
+    report
+      .log({level: 'error'})(e)
+      .set('error', e)
+      .setStatus('failure')
     throw e
   }
-  state.setStatus('success')
-  log()('Great success!')
+  report
+    .setStatus('success')
+    .log()('Great success!')
 })
 
 export const runCmd = async (pkg, name) => {
@@ -76,17 +83,17 @@ export const runCmd = async (pkg, name) => {
 }
 
 const createContext = (flags, env) => {
-  const state = createState({file: flags.report})
+  const report = createReport({file: flags.report})
   const _runCmd = queuefy(runCmd, flags.concurrency || os.cpus().length)
   const _build = memoizeBy((pkg, packages) => build(pkg, packages, _runCmd, _build))
   const _publish = memoizeBy((pkg) => publish(pkg, _runCmd))
 
-  $.state = state
+  $.report = report
   $.env = {...process.env, ...env}
   $.verbose = !!(flags.debug || $.env.DEBUG ) || $.verbose
 
   return {
-    state,
+    report,
     runCmd: _runCmd,
     build: _build,
     publish: _publish
@@ -94,15 +101,47 @@ const createContext = (flags, env) => {
 }
 
 // Inspired by https://docs.github.com/en/actions/learn-github-actions/contexts
-export const contextify = async (pkg, packages, root) => {
-  pkg.config = await getConfig(pkg.absPath, root.absPath)
+const contextify = async (pkg, packages, root) => {
+  pkg.config = await getPkgConfig(pkg.absPath, root.absPath)
   pkg.latest = await getLatest(pkg)
   pkg.context = {
     git: {
-      sha: (await $`git rev-parse HEAD`).toString().trim(),
-      root: (await $`git rev-parse --show-toplevel`).toString().trim(),
+      sha: await getSha(pkg.absPath),
+      root: await getRoot(pkg.absPath)
     },
     env: $.env,
     packages
   }
 }
+
+const build = async (pkg, packages, run = runCmd, self = build) => {
+  if (pkg.built) return
+
+  await Promise.all([
+    traverseDeps(pkg, packages, async (_, {pkg}) => self(pkg, packages, run, self)),
+    pkg.changes.length === 0 && pkg.config.npmFetch
+      ? fetchPkg(pkg)
+      : Promise.resolve()
+  ])
+
+  if (!pkg.fetched) {
+    await run(pkg, 'buildCmd')
+    await run(pkg, 'testCmd')
+  }
+
+  pkg.built = true
+}
+
+const publish = async (pkg, run = runCmd) => {
+  await fs.writeJson(pkg.manifestPath, pkg.manifest, {spaces: 2})
+  await pushTag(pkg)
+
+  await Promise.all([
+    pushMeta(pkg),
+    pushChangelog(pkg),
+    npmPublish(pkg),
+    ghRelease(pkg),
+    ghPages(pkg),
+    run(pkg, 'publishCmd')
+  ])
+}

package/src/main/js/util.js

@@ -55,3 +55,5 @@ export const memoizeBy = (fn, memo = new Map(), getKey = v => v) => (...args) =>
   memo.set(key, value)
   return value
 }
+
+export const camelize = s => s.replace(/-./g, x => x[1].toUpperCase())

package/src/main/js/build.js

@@ -1,21 +0,0 @@
-import {traverseDeps} from './deps.js'
-import {fetchPkg} from './npm.js'
-import {runCmd} from './processor.js'
-
-export const build = async (pkg, packages, run = runCmd, self = build) => {
-  if (pkg.built) return true
-
-  await traverseDeps(pkg, packages, async (_, {pkg}) => self(pkg, packages, run, self))
-
-  if (pkg.changes.length === 0 && pkg.config.npmFetch) {
-    await fetchPkg(pkg)
-  }
-
-  if (!pkg.fetched) {
-    await run(pkg, 'buildCmd')
-    await run(pkg, 'testCmd')
-  }
-
-  pkg.built = true
-  return true
-}

package/src/main/js/publish.js

@@ -1,146 +0,0 @@
-import {fs, path, $} from 'zx-extra'
-import {formatTag, getLatestTag, pushTag} from './tag.js'
-import {push, fetch, parseRepo} from './repo.js'
-import {parseEnv} from './config.js'
-import {fetchManifest, npmPublish} from './npm.js'
-import {msgJoin} from './util.js'
-import {runCmd} from './processor.js'
-import {log} from './log.js'
-
-export const publish = async (pkg, run = runCmd) => {
-  await fs.writeJson(pkg.manifestPath, pkg.manifest, {spaces: 2})
-  await pushTag(pkg)
-  await pushMeta(pkg)
-  await pushChangelog(pkg)
-  await npmPublish(pkg)
-  await ghRelease(pkg)
-  await ghPages(pkg)
-  await run(pkg, 'publishCmd')
-}
-
-export const pushMeta = async (pkg) => {
-  log({pkg})('push artifact to branch \'meta\'')
-
-  const {name, version, absPath: cwd} = pkg
-  const tag = formatTag({name, version})
-  const to = '.'
-  const branch = 'meta'
-  const msg = `chore: release meta ${name} ${version}`
-  const hash = (await $.o({cwd})`git rev-parse HEAD`).toString().trim()
-  const meta = {
-    META_VERSION: '1',
-    name: pkg.name,
-    hash,
-    version: pkg.version,
-    dependencies: pkg.dependencies,
-    devDependencies: pkg.devDependencies,
-    peerDependencies: pkg.peerDependencies,
-    optionalDependencies: pkg.optionalDependencies,
-  }
-  const files = [{relpath: `${getArtifactPath(tag)}.json`, contents: meta}]
-
-  await push({cwd, to, branch, msg, files})
-}
-
-export const ghRelease = async (pkg) => {
-  log({pkg})(`create gh release`)
-
-  const {ghToken} = parseEnv($.env)
-  if (!ghToken) return null
-
-  const {name, version, absPath: cwd} = pkg
-  const {repoName} = await parseRepo(cwd)
-  const tag = formatTag({name, version})
-  const releaseNotes = await formatReleaseNotes(pkg)
-  const releaseData = JSON.stringify({
-    name: tag,
-    tag_name: tag,
-    body: releaseNotes
-  })
-
-  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 pushChangelog = async (pkg) => {
-  const {config: {changelog: opts}} = pkg
-  if (!opts) return
-
-  log({pkg})('push changelog')
-  const [branch = 'changelog', file = `${pkg.name.replace(/[^a-z0-9-]/ig, '')}-changelog.md`, ..._msg] = typeof opts === 'string'
-    ? opts.split(' ')
-    : [opts.branch, opts.file, opts.msg]
-  const _cwd = await fetch({cwd: pkg.absPath, branch})
-  const msg = msgJoin(_msg, pkg, 'chore: update changelog ${{name}}')
-  const releaseNotes = await formatReleaseNotes(pkg)
-
-  await $.o({cwd: _cwd})`echo ${releaseNotes}"\n$(cat ./${file})" > ./${file}`
-  await push({cwd: pkg.absPath, branch, msg})
-}
-
-const formatReleaseNotes = async (pkg) => {
-  const {name, version, absPath: cwd} = pkg
-  const {repoPublicUrl} = await parseRepo(cwd)
-  const tag = formatTag({name, version})
-  const releaseDiffRef = `## [${name}@${version}](${repoPublicUrl}/compare/${pkg.latest.tag?.ref}...${tag}) (${new Date().toISOString().slice(0, 10)})`
-  const releaseDetails = Object.values(pkg.changes
-    .reduce((acc, {group, subj, short, hash}) => {
-      const {commits} = acc[group] || (acc[group] = {commits: [], group})
-      const commitRef = `* ${subj}${short ? ` [${short}](${repoPublicUrl}/commit/${hash})` : ''}`
-
-      commits.push(commitRef)
-
-      return acc
-    }, {}))
-    .map(({group, commits}) => `
-### ${group}
-${commits.join('\n')}`).join('\n')
-
-  return releaseDiffRef + '\n' + releaseDetails + '\n'
-}
-
-const ghPages = async (pkg) => {
-  const {config: {ghPages: opts}} = pkg
-  if (!opts) return
-
-  const [branch = 'gh-pages', from = 'docs', to = '.', ..._msg] = typeof opts === 'string'
-    ? opts.split(' ')
-    : [opts.branch, opts.from, opts.to, opts.msg]
-  const msg = msgJoin(_msg, pkg, 'docs: update docs ${{name}} ${{version}}')
-
-  log({pkg})(`publish docs to ${branch}`)
-
-  await push({
-    cwd: path.join(pkg.absPath, from),
-    from: '.',
-    to,
-    branch,
-    msg
-  })
-}
-
-export const getArtifactPath = (tag) => tag.toLowerCase().replace(/[^a-z0-9-]/g, '-')
-
-export const getLatestMeta = async (cwd, tag) => {
-  if (!tag) return null
-
-  try {
-    const _cwd = await fetch({cwd, branch: 'meta'})
-    return await Promise.any([
-      fs.readJson(path.resolve(_cwd, `${getArtifactPath(tag)}.json`)),
-      fs.readJson(path.resolve(_cwd, getArtifactPath(tag), 'meta.json'))
-    ])
-  } catch {}
-
-  return null
-}
-
-export const getLatest = async (pkg) => {
-  const {absPath: cwd, name} = pkg
-  const tag = await getLatestTag(cwd, name)
-  const meta = await getLatestMeta(cwd, tag?.ref) || await fetchManifest(pkg, {nothrow: true})
-
-  return {
-    tag,
-    meta
-  }
-}

package/src/main/js/state.js

@@ -1,56 +0,0 @@
-import {get, set, tpl} from './util.js'
-import {fs} from 'zx-extra'
-
-export const createState = ({logger = console, file = null} = {}) => ({
-  logger,
-  file,
-  status: 'initial',
-  queue: [],
-  packages: [],
-  events: [],
-  setQueue(queue, packages) {
-    this.queue = queue
-    this.packages = queue.map(name => {
-      const {manifest: {version}, absPath, relPath} = packages[name]
-      return {
-        status: 'initial',
-        name,
-        version,
-        path: absPath,
-        relPath
-      }
-    })
-  },
-  get(key, pkgName) {
-    return get(
-      pkgName ? this.packages.find(({name}) => name === pkgName) : this,
-      key
-    )
-  },
-  set(key, value, pkgName) {
-    set(
-      pkgName ? this.packages.find(({name}) => name === pkgName) : this,
-      key,
-      value
-    )
-  },
-  setStatus(status, name) {
-    this.set('status', status, name)
-    this.save()
-  },
-  getStatus(status, name) {
-    return this.get('status', name)
-  },
-  log(ctx = {}) {
-    return function (...chunks) {
-      const {pkg, scope = pkg?.name || '~', level = 'info'} = ctx
-      const msg = chunks.map(c => typeof c === 'string' ? tpl(c, ctx) : c)
-      const event = {msg, scope, date: Date.now(), level}
-      this.events.push(event)
-      logger[level](`[${scope}]`, ...msg)
-    }.bind(this)
-  },
-  save() {
-    this.file && fs.outputJsonSync(this.file, this)
-  }
-})