feat(scripts): enhacne output streaming

Author: dangreen

packages/scripts/package.json

@@ -35,6 +35,8 @@
     "postpublish": "del ./package"
   },
   "dependencies": {
+    "@simple-libs/child-process-utils": "^1.0.1",
+    "@simple-libs/stream-utils": "^1.1.0",
     "argue-cli": "^2.0.0",
     "dotenv": "^16.0.0",
     "p-limit": "^5.0.0"

packages/scripts/src/utils/run.js

@@ -4,27 +4,53 @@ import { spawn } from './spawn.js'
 import { getArgs } from './args.js'
 
 /**
- * Run package manager scripts serial.
+ * Run package manager scripts parallel.
  * @param {string} pm
  * @param {string[][]} scripts
  * @param {{ scripts?: Record<string, string> }} pkg - package.json
- * @returns Exit code
+ * @param {number} concurrency - Number of concurrent processes.
+ * @returns Exit code.
  */
-export async function runSerial(pm, scripts, pkg) {
-  const cmds = scripts.map(script => getArgs(pm, script, pkg))
-  let exitCode = 0
-  let result
+export async function run(pm, scripts, pkg, concurrency) {
+  const limit = pLimit(concurrency)
+  /** @type {Promise<ReturnType<typeof spawn>>[]} */
+  const tasks = scripts.map(script => new Promise(
+    resolve => limit(() => {
+      const [bin, args] = getArgs(pm, script, pkg)
+      const child = spawn(bin, args)
+
+      resolve(child)
 
-  for (const [bin, args] of cmds) {
-    result = await spawn(bin, args)
-    exitCode = exitCode || result.exitCode
+      return child.exitCode
+    })
+  ))
+  let finalExitCode = 0
 
-    if (result.output) {
-      process.stdout.write(result.output)
+  for await (const task of tasks) {
+    for await (const data of task.output) {
+      if (data.source === 'stdout') {
+        process.stdout.write(data.chunk)
+      } else
+        if (data.source === 'stderr') {
+          process.stderr.write(data.chunk)
+        }
     }
+
+    finalExitCode = finalExitCode || await task.exitCode
   }
 
-  return exitCode
+  return finalExitCode
+}
+
+/**
+ * Run package manager scripts serial.
+ * @param {string} pm
+ * @param {string[][]} scripts
+ * @param {{ scripts?: Record<string, string> }} pkg - package.json
+ * @returns Exit code
+ */
+export function runSerial(pm, scripts, pkg) {
+  return run(pm, scripts, pkg, 1)
 }
 
 /**
@@ -34,19 +60,6 @@ export async function runSerial(pm, scripts, pkg) {
  * @param {{ scripts?: Record<string, string> }} pkg - package.json
  * @returns Exit code.
  */
-export async function runParallel(pm, scripts, pkg) {
-  const limit = pLimit(cpus().length)
-  const cmds = scripts.map(script => getArgs(pm, script, pkg))
-  const tasks = cmds.map(([bin, args]) => limit(() => spawn(bin, args, false)))
-  let exitCode = 0
-  /** @type {{ exitCode: number, output?: string | Error }} */
-  let result
-
-  for (const task of tasks) {
-    result = await task
-    exitCode = exitCode || result.exitCode
-    process.stdout.write(result.output)
-  }
-
-  return exitCode
+export function runParallel(pm, scripts, pkg) {
+  return run(pm, scripts, pkg, cpus().length)
 }

packages/scripts/src/utils/spawn.js

@@ -1,37 +1,26 @@
 import { spawn as spawnChild } from 'child_process'
+import { exitCode } from '@simple-libs/child-process-utils'
+import { mergeReadables } from '@simple-libs/stream-utils'
 
 /**
  * Spawn child process.
  * @param {string} cmd
  * @param {string[]} args
- * @param {boolean} stdio
- * @returns {Promise<{ exitCode: number, output?: string | Error }>} Output.
+ * @returns Output.
  */
-export function spawn(cmd, args, stdio = true) {
-  return new Promise((resolve) => {
-    const env = {
+export function spawn(cmd, args) {
+  const child = spawnChild(cmd, args, {
+    env: {
       FORCE_COLOR: true,
       ...process.env
     }
-    const options = {
-      env,
-      stdio: stdio ? 'inherit' : 'pipe'
-    }
-    const child = spawnChild(cmd, args, options)
-    let output = ''
-    const onData = (data) => {
-      output += data.toString()
-    }
-    const onDone = (error) => {
-      resolve({
-        exitCode: child.exitCode,
-        output: output || (typeof error === 'number' ? '' : `${error}\n`)
-      })
-    }
-
-    child.stdout?.on('data', onData)
-    child.stderr?.on('data', onData)
-    child.on('close', onDone)
-    child.on('error', onDone)
   })
+
+  return {
+    output: mergeReadables({
+      stdout: child.stdout,
+      stderr: child.stderr
+    }),
+    exitCode: exitCode(child)
+  }
 }