@decaf-ts/utils
Version:
module management utils for decaf-ts
219 lines • 27.5 kB
JavaScript
import { spawn, } from "child_process";
import { StandardOutputWriter } from "../writers/StandardOutputWriter";
import { AbortCode } from "./constants";
import { Logging } from "@decaf-ts/logging";
/**
* @description Creates a locked version of a function.
* @summary This higher-order function takes a function and returns a new function that ensures
* sequential execution of the original function, even when called multiple times concurrently.
* It uses a Promise-based locking mechanism to queue function calls.
*
* @template R - The return type of the input function.
*
* @param f - The function to be locked. It can take any number of parameters and return a value of type R.
* @return A new function with the same signature as the input function, but with sequential execution guaranteed.
*
* @function lockify
*
* @mermaid
* sequenceDiagram
* participant Caller
* participant LockedFunction
* participant OriginalFunction
* Caller->>LockedFunction: Call with params
* LockedFunction->>LockedFunction: Check current lock
* alt Lock is resolved
* LockedFunction->>OriginalFunction: Execute with params
* OriginalFunction-->>LockedFunction: Return result
* LockedFunction-->>Caller: Return result
* else Lock is pending
* LockedFunction->>LockedFunction: Queue execution
* LockedFunction-->>Caller: Return promise
* Note over LockedFunction: Wait for previous execution
* LockedFunction->>OriginalFunction: Execute with params
* OriginalFunction-->>LockedFunction: Return result
* LockedFunction-->>Caller: Resolve promise with result
* end
* LockedFunction->>LockedFunction: Update lock
*
* @memberOf @decaf-ts/utils
*/
export function lockify(f) {
let lock = Promise.resolve();
return (...params) => {
const result = lock.then(() => f(...params));
lock = result.catch(() => { });
return result;
};
}
export function chainAbortController(argument0, ...remainder) {
let signals;
let controller;
// normalize args
if (argument0 instanceof AbortSignal) {
controller = new AbortController();
signals = [argument0, ...remainder];
}
else {
controller = argument0;
signals = remainder;
}
// if the controller is already aborted, exit early
if (controller.signal.aborted) {
return controller;
}
const handler = () => controller.abort();
for (const signal of signals) {
// check before adding! (and assume there is no possible way that the signal could
// abort between the `if` check and adding the event listener)
if (signal.aborted) {
controller.abort();
break;
}
signal.addEventListener("abort", handler, {
once: true,
signal: controller.signal,
});
}
return controller;
}
export function spawnCommand(output, command, opts, abort, logger) {
function spawnInner(command, controller) {
const [cmd, argz] = output.parseCommand(command);
logger.info(`Running command: ${cmd}`);
logger.debug(`with args: ${argz.join(" ")}`);
const childProcess = spawn(cmd, argz, {
...opts,
cwd: opts.cwd || process.cwd(),
env: Object.assign({}, process.env, opts.env, { PATH: process.env.PATH }),
shell: opts.shell || false,
signal: controller.signal,
});
logger.verbose(`pid : ${childProcess.pid}`);
return childProcess;
}
const m = command.match(/[<>$#]/g);
if (m)
throw new Error(`Invalid command: ${command}. contains invalid characters: ${m}`);
if (command.includes(" | ")) {
const cmds = command.split(" | ");
const spawns = [];
const controllers = new Array(cmds.length);
controllers[0] = abort;
for (let i = 0; i < cmds.length; i++) {
if (i !== 0)
controllers[i] = chainAbortController(controllers[i - 1].signal);
spawns.push(spawnInner(cmds[i], controllers[i]));
if (i === 0)
continue;
spawns[i - 1].stdout.pipe(spawns[i].stdin);
}
return spawns[cmds.length - 1];
}
return spawnInner(command, abort);
}
/**
* @description Executes a command asynchronously with customizable output handling.
* @summary This function runs a shell command as a child process, providing fine-grained
* control over its execution and output handling. It supports custom output writers,
* allows for command abortion, and captures both stdout and stderr.
*
* @template R - The type of the resolved value from the command execution.
*
* @param command - The command to run, either as a string or an array of strings.
* @param opts - Spawn options for the child process. Defaults to an empty object.
* @param outputConstructor - Constructor for the output writer. Defaults to StandardOutputWriter.
* @param args - Additional arguments to pass to the output constructor.
* @return {CommandResult} A promise that resolves to the command result of type R.
*
* @function runCommand
*
* @mermaid
* sequenceDiagram
* participant Caller
* participant runCommand
* participant OutputWriter
* participant ChildProcess
* Caller->>runCommand: Call with command and options
* runCommand->>OutputWriter: Create new instance
* runCommand->>OutputWriter: Parse command
* runCommand->>ChildProcess: Spawn process
* ChildProcess-->>runCommand: Return process object
* runCommand->>ChildProcess: Set up event listeners
* loop For each stdout data
* ChildProcess->>runCommand: Emit stdout data
* runCommand->>OutputWriter: Handle stdout data
* end
* loop For each stderr data
* ChildProcess->>runCommand: Emit stderr data
* runCommand->>OutputWriter: Handle stderr data
* end
* ChildProcess->>runCommand: Emit error (if any)
* runCommand->>OutputWriter: Handle error
* ChildProcess->>runCommand: Emit exit
* runCommand->>OutputWriter: Handle exit
* OutputWriter-->>runCommand: Resolve or reject promise
* runCommand-->>Caller: Return CommandResult
*
* @memberOf @decaf-ts/utils
*/
export function runCommand(command, opts = {}, outputConstructor = (StandardOutputWriter), ...args) {
const logger = Logging.for(runCommand);
const abort = new AbortController();
const result = {
abort: abort,
command: command,
logs: [],
errs: [],
};
const lock = new Promise((resolve, reject) => {
let output;
try {
output = new outputConstructor(command, {
resolve,
reject,
}, ...args);
result.cmd = spawnCommand(output, command, opts, abort, logger);
}
catch (e) {
return reject(new Error(`Error running command ${command}: ${e}`));
}
result.cmd.stdout.setEncoding("utf8");
result.cmd.stdout.on("data", (chunk) => {
chunk = chunk.toString();
result.logs.push(chunk);
output.data(chunk);
});
result.cmd.stderr.on("data", (data) => {
data = data.toString();
result.errs.push(data);
output.error(data);
});
result.cmd.once("error", (err) => {
output.exit(err.message, result.errs);
});
result.cmd.once("exit", (code = 0) => {
if (abort.signal.aborted && code === null)
code = AbortCode;
output.exit(code, code === 0 ? result.logs : result.errs);
});
});
Object.assign(result, {
promise: lock,
pipe: async (cb) => {
const l = logger.for("pipe");
try {
l.verbose(`Executing pipe function ${command}...`);
const result = await lock;
l.verbose(`Piping output to ${cb.name}: ${result}`);
return cb(result);
}
catch (e) {
l.error(`Error piping command output: ${e}`);
throw e;
}
},
});
return result;
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../src/utils/utils.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ChildProcessWithoutNullStreams,\n  spawn,\n  SpawnOptionsWithoutStdio,\n} from \"child_process\";\nimport { StandardOutputWriter } from \"../writers/StandardOutputWriter\";\nimport { CommandResult } from \"./types\";\nimport { OutputWriterConstructor } from \"../writers/types\";\nimport { AbortCode } from \"./constants\";\nimport { Logger, Logging } from \"@decaf-ts/logging\";\n\n/**\n * @description Creates a locked version of a function.\n * @summary This higher-order function takes a function and returns a new function that ensures\n * sequential execution of the original function, even when called multiple times concurrently.\n * It uses a Promise-based locking mechanism to queue function calls.\n *\n * @template R - The return type of the input function.\n *\n * @param f - The function to be locked. It can take any number of parameters and return a value of type R.\n * @return A new function with the same signature as the input function, but with sequential execution guaranteed.\n *\n * @function lockify\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant LockedFunction\n *   participant OriginalFunction\n *   Caller->>LockedFunction: Call with params\n *   LockedFunction->>LockedFunction: Check current lock\n *   alt Lock is resolved\n *     LockedFunction->>OriginalFunction: Execute with params\n *     OriginalFunction-->>LockedFunction: Return result\n *     LockedFunction-->>Caller: Return result\n *   else Lock is pending\n *     LockedFunction->>LockedFunction: Queue execution\n *     LockedFunction-->>Caller: Return promise\n *     Note over LockedFunction: Wait for previous execution\n *     LockedFunction->>OriginalFunction: Execute with params\n *     OriginalFunction-->>LockedFunction: Return result\n *     LockedFunction-->>Caller: Resolve promise with result\n *   end\n *   LockedFunction->>LockedFunction: Update lock\n *\n * @memberOf @decaf-ts/utils\n */\nexport function lockify<R>(f: (...params: unknown[]) => R) {\n  let lock: Promise<R | void> = Promise.resolve();\n  return (...params: unknown[]) => {\n    const result = lock.then(() => f(...params));\n    lock = result.catch(() => {});\n    return result;\n  };\n}\n\nexport function chainAbortController(\n  controller: AbortController,\n  ...signals: AbortSignal[]\n): AbortController;\nexport function chainAbortController(\n  ...signals: AbortSignal[]\n): AbortController;\nexport function chainAbortController(\n  argument0: AbortController | AbortSignal,\n  ...remainder: AbortSignal[]\n): AbortController {\n  let signals: AbortSignal[];\n  let controller: AbortController;\n\n  // normalize args\n  if (argument0 instanceof AbortSignal) {\n    controller = new AbortController();\n    signals = [argument0, ...remainder];\n  } else {\n    controller = argument0;\n    signals = remainder;\n  }\n\n  // if the controller is already aborted, exit early\n  if (controller.signal.aborted) {\n    return controller;\n  }\n\n  const handler = () => controller.abort();\n\n  for (const signal of signals) {\n    // check before adding! (and assume there is no possible way that the signal could\n    // abort between the `if` check and adding the event listener)\n    if (signal.aborted) {\n      controller.abort();\n      break;\n    }\n    signal.addEventListener(\"abort\", handler, {\n      once: true,\n      signal: controller.signal,\n    });\n  }\n\n  return controller;\n}\n\nexport function spawnCommand<R = string>(\n  output: StandardOutputWriter<R>,\n  command: string,\n  opts: SpawnOptionsWithoutStdio,\n  abort: AbortController,\n  logger: Logger\n): ChildProcessWithoutNullStreams {\n  function spawnInner(command: string, controller: AbortController) {\n    const [cmd, argz] = output.parseCommand(command);\n    logger.info(`Running command: ${cmd}`);\n    logger.debug(`with args: ${argz.join(\" \")}`);\n    const childProcess = spawn(cmd, argz, {\n      ...opts,\n      cwd: opts.cwd || process.cwd(),\n      env: Object.assign({}, process.env, opts.env, { PATH: process.env.PATH }),\n      shell: opts.shell || false,\n      signal: controller.signal,\n    });\n    logger.verbose(`pid : ${childProcess.pid}`);\n    return childProcess;\n  }\n\n  const m = command.match(/[<>$#]/g);\n  if (m)\n    throw new Error(\n      `Invalid command: ${command}. contains invalid characters: ${m}`\n    );\n  if (command.includes(\" | \")) {\n    const cmds = command.split(\" | \");\n    const spawns = [];\n    const controllers = new Array(cmds.length);\n    controllers[0] = abort;\n    for (let i = 0; i < cmds.length; i++) {\n      if (i !== 0)\n        controllers[i] = chainAbortController(controllers[i - 1].signal);\n      spawns.push(spawnInner(cmds[i], controllers[i]));\n      if (i === 0) continue;\n      spawns[i - 1].stdout.pipe(spawns[i].stdin);\n    }\n    return spawns[cmds.length - 1];\n  }\n\n  return spawnInner(command, abort);\n}\n\n/**\n * @description Executes a command asynchronously with customizable output handling.\n * @summary This function runs a shell command as a child process, providing fine-grained\n * control over its execution and output handling. It supports custom output writers,\n * allows for command abortion, and captures both stdout and stderr.\n *\n * @template R - The type of the resolved value from the command execution.\n *\n * @param command - The command to run, either as a string or an array of strings.\n * @param opts - Spawn options for the child process. Defaults to an empty object.\n * @param outputConstructor - Constructor for the output writer. Defaults to StandardOutputWriter.\n * @param args - Additional arguments to pass to the output constructor.\n * @return {CommandResult} A promise that resolves to the command result of type R.\n *\n * @function runCommand\n *\n * @mermaid\n * sequenceDiagram\n *   participant Caller\n *   participant runCommand\n *   participant OutputWriter\n *   participant ChildProcess\n *   Caller->>runCommand: Call with command and options\n *   runCommand->>OutputWriter: Create new instance\n *   runCommand->>OutputWriter: Parse command\n *   runCommand->>ChildProcess: Spawn process\n *   ChildProcess-->>runCommand: Return process object\n *   runCommand->>ChildProcess: Set up event listeners\n *   loop For each stdout data\n *     ChildProcess->>runCommand: Emit stdout data\n *     runCommand->>OutputWriter: Handle stdout data\n *   end\n *   loop For each stderr data\n *     ChildProcess->>runCommand: Emit stderr data\n *     runCommand->>OutputWriter: Handle stderr data\n *   end\n *   ChildProcess->>runCommand: Emit error (if any)\n *   runCommand->>OutputWriter: Handle error\n *   ChildProcess->>runCommand: Emit exit\n *   runCommand->>OutputWriter: Handle exit\n *   OutputWriter-->>runCommand: Resolve or reject promise\n *   runCommand-->>Caller: Return CommandResult\n *\n * @memberOf @decaf-ts/utils\n */\nexport function runCommand<R = string>(\n  command: string,\n  opts: SpawnOptionsWithoutStdio = {},\n  outputConstructor: OutputWriterConstructor<\n    R,\n    StandardOutputWriter<R>,\n    Error\n  > = StandardOutputWriter<R>,\n  ...args: unknown[]\n): CommandResult<R> {\n  const logger = Logging.for(runCommand);\n  const abort = new AbortController();\n\n  const result: Omit<CommandResult, \"promise\" | \"pipe\"> = {\n    abort: abort,\n    command: command,\n    logs: [],\n    errs: [],\n  };\n\n  const lock = new Promise<R>((resolve, reject) => {\n    let output;\n    try {\n      output = new outputConstructor(\n        command,\n        {\n          resolve,\n          reject,\n        },\n        ...args\n      );\n\n      result.cmd = spawnCommand<R>(output, command, opts, abort, logger);\n    } catch (e: unknown) {\n      return reject(new Error(`Error running command ${command}: ${e}`));\n    }\n\n    result.cmd.stdout.setEncoding(\"utf8\");\n\n    result.cmd.stdout.on(\"data\", (chunk: any) => {\n      chunk = chunk.toString();\n      result.logs.push(chunk);\n      output.data(chunk);\n    });\n\n    result.cmd.stderr.on(\"data\", (data: any) => {\n      data = data.toString();\n      result.errs.push(data);\n      output.error(data);\n    });\n\n    result.cmd.once(\"error\", (err: Error) => {\n      output.exit(err.message, result.errs);\n    });\n\n    result.cmd.once(\"exit\", (code: number = 0) => {\n      if (abort.signal.aborted && code === null) code = AbortCode as any;\n      output.exit(code, code === 0 ? result.logs : result.errs);\n    });\n  });\n\n  Object.assign(result, {\n    promise: lock,\n    pipe: async <E>(cb: (r: R) => E) => {\n      const l = logger.for(\"pipe\");\n      try {\n        l.verbose(`Executing pipe function ${command}...`);\n        const result: R = await lock;\n        l.verbose(`Piping output to ${cb.name}: ${result}`);\n        return cb(result);\n      } catch (e: unknown) {\n        l.error(`Error piping command output: ${e}`);\n        throw e;\n      }\n    },\n  });\n\n  return result as CommandResult<R>;\n}\n"]}