@datatruck/cli 0.34.0 → 0.34.2

package/lib/tasks/MariadbTask.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MariadbTask = exports.mariadbTaskName = void 0;
+const async_process_1 = require("../utils/async-process");
 const cli_1 = require("../utils/cli");
 const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
-const process_1 = require("../utils/process");
 const tar_1 = require("../utils/tar");
 const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
@@ -92,15 +92,15 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         await (0, fs_1.forEachFile)(sourcePath, () => {
             total++;
         });
-        let p1;
         let lastLineText;
+        const controller = new AbortController();
         const pathRegex = /((Copying|Streaming) .+) to/;
         const onData = async (line) => {
             const { text } = parseLine(line);
             lastLineText = text;
             if (line.includes("[ERROR] InnoDB: Unsupported redo log format.") ||
                 line.includes("Error: cannot read redo log header")) {
-                p1.kill();
+                controller.abort();
             }
             else {
                 const matches = pathRegex.exec(text);
@@ -121,41 +121,34 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         const stats = { xbFiles: total };
         await (0, promises_1.writeFile)((0, path_1.join)(snapshotPath, "stats.dtt.json"), JSON.stringify(stats));
         if (compress) {
-            const p0 = (0, fs_2.createWriteStream)((0, path_1.join)(snapshotPath, "db.xb.gz"));
-            p1 = (0, process_1.createProcess)(command, args, {
+            const fileStream = (0, fs_2.createWriteStream)((0, path_1.join)(snapshotPath, "db.xb.gz"));
+            const dumpProcess = new async_process_1.AsyncProcess(command, args, {
                 $log: {
                     exec: this.verbose,
                     stderr: this.verbose,
                 },
-                $stderr: {
-                    parseLines: true,
-                    onData,
-                },
-                $onExitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
+                $controller: controller,
+                $exitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
             });
-            const p2 = (0, process_1.createProcess)(compress.command, compress.args);
-            p1.stdout.pipe(p2.stdin, { end: true });
-            p2.stdout.pipe(p0, { end: true });
-            await Promise.all([p1, p2, (0, fs_1.waitForClose)(p0)]);
+            const compressProcess = new async_process_1.AsyncProcess(compress.command, compress.args);
+            await Promise.all([
+                dumpProcess.stdout.pipe(compressProcess.stdin),
+                dumpProcess.stderr.parseLines(onData),
+                compressProcess.stdout.pipe(fileStream),
+            ]);
         }
         else {
-            p1 = (0, process_1.createProcess)(command, args, {
+            const dumpProcess = new async_process_1.AsyncProcess(command, args, {
                 $log: this.verbose,
-                $stdout: {
-                    parseLines: true,
-                    onData,
-                },
-                $stderr: {
-                    parseLines: true,
-                    onData,
-                },
-                $onExitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
-            });
-            await p1;
-            await (0, process_1.exec)(command, [`--prepare`, `--target-dir=${snapshotPath}`], undefined, {
-                log: this.verbose,
-                stderr: { onData: () => { } },
+                $controller: controller,
+                $exitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
             });
+            await Promise.all([
+                dumpProcess.stdout.parseLines(onData),
+                dumpProcess.stderr.parseLines(onData),
+            ]);
+            const prepareProcess = new async_process_1.AsyncProcess(command, [`--prepare`, `--target-dir=${snapshotPath}`], { $log: this.verbose });
+            await prepareProcess.waitForClose();
         }
         return { snapshotPath };
     }
@@ -230,29 +223,25 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             });
             let currentXbFiles = 0;
             const { parallel } = normalizeConfig({ parallel: this.config.parallel });
-            const p1 = (0, process_1.createProcess)("mbstream", ["-x", "-C", snapshotPath, "-v", "-p", parallel], {
-                $log: this.verbose,
-                $stderr: {
-                    parseLines: true,
-                    onData(line) {
-                        const { text: path } = parseLine(line);
-                        data.onProgress({
-                            absolute,
-                            relative: {
-                                payload: path,
-                                format: "amount",
-                                current: ++currentXbFiles,
-                                total: stats?.xbFiles,
-                                percent: stats?.xbFiles
-                                    ? (0, math_1.progressPercent)(stats.xbFiles, currentXbFiles)
-                                    : undefined,
-                            },
-                        });
-                    },
-                },
-            });
-            xbStream.pipe(p1.stdin, { end: true });
-            await Promise.all([(0, fs_1.waitForClose)(xbStream), p1]);
+            const p1 = new async_process_1.AsyncProcess("mbstream", ["-x", "-C", snapshotPath, "-v", "-p", parallel], { $log: this.verbose });
+            await Promise.all([
+                p1.stdin.pipe(xbStream),
+                p1.stderr.parseLines((line) => {
+                    const { text: path } = parseLine(line);
+                    data.onProgress({
+                        absolute,
+                        relative: {
+                            payload: path,
+                            format: "amount",
+                            current: ++currentXbFiles,
+                            total: stats?.xbFiles,
+                            percent: stats?.xbFiles
+                                ? (0, math_1.progressPercent)(stats.xbFiles, currentXbFiles)
+                                : undefined,
+                        },
+                    });
+                }),
+            ]);
         }
         // Prepare
         absolute.current++;
@@ -262,10 +251,8 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             data.onProgress({
                 absolute,
             });
-            await (0, process_1.exec)(this.command, [`--prepare`, `--target-dir=${snapshotPath}`], undefined, {
-                log: this.verbose,
-                stderr: { onData: () => { } },
-            });
+            const p = new async_process_1.AsyncProcess(this.command, [`--prepare`, `--target-dir=${snapshotPath}`], { $log: this.verbose });
+            await p.waitForClose();
         }
         await reloadFiles();
         removeFiles.push(...files.filter((file) => file.startsWith("ib_logfile")));

package/lib/tasks/MssqlTask.js

@@ -1,10 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MssqlTask = exports.mssqlTaskName = void 0;
+const async_process_1 = require("../utils/async-process");
 const config_1 = require("../utils/datatruck/config");
 const error_1 = require("../utils/datatruck/error");
 const fs_1 = require("../utils/fs");
-const process_1 = require("../utils/process");
 const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
 const promises_1 = require("fs/promises");
@@ -18,7 +18,7 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
         return this.config.command ?? "sqlcmd";
     }
     async exec(query) {
-        const result = await (0, process_1.exec)(this.command, [
+        const stdout = await async_process_1.AsyncProcess.stdout(this.command, [
             ...(this.config.hostname ? ["-S", this.config.hostname] : []),
             ...(this.config.username ? ["-U", this.config.username] : []),
             ...(this.config.passwordFile
@@ -32,16 +32,10 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
             "999",
             "-Q",
             `SET nocount ON; ${query.replace(/[\n\t]/g, " ")}`,
-        ], undefined, {
-            log: this.verbose,
-            stderr: {
-                toExitCode: true,
-            },
-            stdout: {
-                save: true,
-            },
+        ], {
+            $log: this.verbose,
         });
-        return result.stdout
+        return stdout
             .split(/\n/g)
             .map((row) => row.split(","))
             .filter((row) => row.length);

package/lib/tasks/MysqlDumpTask.js

@@ -80,7 +80,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                                 sharedPath: tableSharedPath,
                                 items: [tableName],
                                 database: this.config.database,
-                                onSpawn: (p) => (controller.stop = () => p.kill()),
+                                controller,
                             });
                             const files = await (0, promises_1.readdir)(tableSharedPath);
                             const schemaFile = `${tableName}.sql`;
@@ -106,7 +106,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                             output: outPath,
                             items: [tableName],
                             database: this.config.database,
-                            onSpawn: (p) => (controller.stop = () => p.kill()),
+                            controller,
                             ...(concurrency === 1 && {
                                 onProgress(progress) {
                                     data.onProgress({
@@ -256,7 +256,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                     await sql.importFile({
                         path,
                         database: database.name,
-                        onSpawn: (p) => (controller.stop = () => p.kill()),
+                        controller,
                     });
                 }
                 finally {
@@ -306,7 +306,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                         path: csvFile,
                         database: database.name,
                         table: tableName,
-                        onSpawn: (p) => (controller.stop = () => p.kill()),
+                        controller,
                     });
                 }
                 finally {

package/lib/tasks/PostgresqlDumpTask.d.ts

@@ -5,7 +5,7 @@ export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDu
     buildConnectionArgs(database?: string): Promise<string[]>;
     onDatabaseIsEmpty(name: string): Promise<boolean>;
     onCreateDatabase(database: TargetDatabase): Promise<void>;
-    onExecQuery(query: string): Promise<import("../utils/process").ExecResult>;
+    onExecQuery(query: string): Promise<string>;
     onFetchTableNames(database: string): Promise<string[]>;
     onExportTables(tableNames: string[], output: string, onProgress: (progress: {
         totalBytes: number;

package/lib/tasks/PostgresqlDumpTask.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PostgresqlDumpTask = exports.postgresqlDumpTaskName = void 0;
-const process_1 = require("../utils/process");
+const async_process_1 = require("../utils/async-process");
 const SqlDumpTaskAbstract_1 = require("./SqlDumpTaskAbstract");
-const fs_1 = require("fs");
 const path_1 = require("path");
 exports.postgresqlDumpTaskName = "postgresql-dump";
 class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
@@ -41,20 +40,12 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         await this.onExecQuery(query);
     }
     async onExecQuery(query) {
-        return await (0, process_1.exec)("psql", [
+        return await async_process_1.AsyncProcess.stdout("psql", [
             ...(await this.buildConnectionArgs()),
             "-t",
             "-c",
             query.replace(/\s{1,}/g, " "),
-        ], undefined, {
-            log: this.verbose,
-            stderr: {
-                toExitCode: true,
-            },
-            stdout: {
-                save: true,
-            },
-        });
+        ], { $log: this.verbose });
     }
     async onFetchTableNames(database) {
         return await this.fetchValues(`
@@ -70,31 +61,17 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
 	  `);
     }
     async onExportTables(tableNames, output, onProgress) {
-        const stream = (0, fs_1.createWriteStream)(output);
-        await Promise.all([
-            new Promise((resolve, reject) => {
-                stream.on("close", resolve);
-                stream.on("error", reject);
-            }),
-            (0, process_1.exec)("pg_dump", [
-                ...(await this.buildConnectionArgs(this.config.database)),
-                ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
-            ], null, {
-                pipe: { stream, onWriteProgress: onProgress },
-                stderr: {
-                    toExitCode: true,
-                },
-                log: this.verbose,
-            }),
-        ]);
+        const dumpProcess = new async_process_1.AsyncProcess("pg_dump", [
+            ...(await this.buildConnectionArgs(this.config.database)),
+            ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
+        ], { $log: this.verbose });
+        await dumpProcess.stdout.pipe(output, onProgress);
     }
     async onExportStoredPrograms() {
         throw new Error(`Method not implemented: onExportStoredPrograms`);
     }
     async onImport(path, database) {
-        await (0, process_1.exec)("psql", [...(await this.buildConnectionArgs(database)), "-f", (0, path_1.normalize)(path)], undefined, {
-            log: this.verbose,
-        });
+        await async_process_1.AsyncProcess.exec("psql", [...(await this.buildConnectionArgs(database)), "-f", (0, path_1.normalize)(path)], { $log: this.verbose });
     }
 }
 exports.PostgresqlDumpTask = PostgresqlDumpTask;

package/lib/tasks/SqlDumpTaskAbstract.d.ts

@@ -1,4 +1,3 @@
-import { exec } from "../utils/process";
 import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 export type TargetDatabase = {
     name: string;
@@ -29,7 +28,7 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     abstract onCreateDatabase(database: TargetDatabase): Promise<void>;
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
     abstract onFetchTableNames(database: string): Promise<string[]>;
-    abstract onExecQuery(query: string): ReturnType<typeof exec>;
+    abstract onExecQuery(query: string): Promise<string>;
     abstract onExportTables(tableNames: string[], output: string, onProgress: (data: {
         totalBytes: number;
     }) => void): Promise<void>;

package/lib/tasks/SqlDumpTaskAbstract.js

@@ -56,7 +56,7 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
     }
     async fetchValues(query) {
         const result = await this.onExecQuery(query);
-        return result.stdout.split(/\r?\n/).reduce((result, value) => {
+        return result.split(/\r?\n/).reduce((result, value) => {
             value = value.trim();
             if (value.length)
                 result.push(value);

package/lib/utils/async-process.d.ts

@@ -0,0 +1,66 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { ChildProcess, SpawnOptions } from "child_process";
+import { ReadStream } from "fs";
+import { Readable, Writable } from "stream";
+export type AsyncProcessOptions = SpawnOptions & {
+    $log?: AsyncProcessLog | boolean;
+    $controller?: AbortController;
+    $exitCode?: ExitCode;
+};
+type ExitCode = ExitCodeValue | ((code: number) => ExitCodeValue | void | undefined);
+type ExitCodeValue = Error | string | number | boolean;
+type AsyncProcessArgv = (string | number)[] | undefined;
+declare class StdIn {
+    readonly process: AsyncProcess;
+    readonly writable: Writable;
+    constructor(process: AsyncProcess, writable: Writable);
+    pipe(source: string | ReadStream, onProgress?: (data: {
+        totalBytes: number;
+        currentBytes: number;
+        progress: number;
+    }) => void): Promise<void>;
+}
+declare class Std {
+    protected type: "stdout" | "stderr";
+    readonly process: AsyncProcess;
+    readonly readable: Readable;
+    constructor(type: "stdout" | "stderr", process: AsyncProcess, readable: Readable);
+    onData(cb: (chunk: Buffer) => void): void;
+    fetch(): Promise<string>;
+    parseLines(cb: (line: string, total: number) => void): Promise<number>;
+    pipe(out: string | NodeJS.WritableStream | StdIn, onProgress?: (data: {
+        totalBytes: number;
+    }) => void): Promise<void>;
+}
+export type AsyncProcessLog = {
+    colorize?: boolean;
+    exec?: boolean;
+    stdout?: boolean;
+    stderr?: boolean;
+    allToStderr?: boolean;
+    envNames?: string[];
+};
+export declare class AsyncProcess {
+    protected command: string;
+    protected argv: AsyncProcessArgv;
+    protected options: AsyncProcessOptions;
+    readonly child: ChildProcess;
+    readonly stdout: Std;
+    readonly stderr: Std;
+    readonly stdin: StdIn;
+    protected log: AsyncProcessLog | undefined;
+    protected controller: AbortController;
+    private lastStdError;
+    constructor(command: string, argv: AsyncProcessArgv, options?: AsyncProcessOptions);
+    static exec(command: string, argv: AsyncProcessArgv, options?: AsyncProcessOptions): Promise<number>;
+    static stdout(command: string, argv: AsyncProcessArgv, options?: AsyncProcessOptions): Promise<string>;
+    private installLog;
+    private installAbortController;
+    private resolveExitCode;
+    waitForClose(): Promise<number>;
+}
+export {};

package/lib/utils/async-process.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncProcess = void 0;
+const cli_1 = require("./cli");
+const math_1 = require("./math");
+const process_1 = require("./process");
+const stream_1 = require("./stream");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const promises_1 = require("fs/promises");
+const readline_1 = require("readline");
+function resolveLogOptions(log) {
+    return log === true
+        ? { exec: {}, stdout: {}, stderr: {} }
+        : log || undefined;
+}
+function ensureDir(cwd) {
+    if (typeof cwd === "string") {
+        let isDir = false;
+        try {
+            isDir = (0, fs_1.statSync)(cwd).isDirectory();
+        }
+        catch (error) { }
+        if (!isDir)
+            throw new Error(`Current working directory does not exist: ${cwd}`);
+    }
+}
+class StdIn {
+    process;
+    writable;
+    constructor(process, writable) {
+        this.process = process;
+        this.writable = writable;
+    }
+    async pipe(source, onProgress) {
+        if (this.process["log"]?.exec) {
+            const path = source instanceof fs_1.ReadStream
+                ? "path" in source
+                    ? source.path
+                    : "&readableStream"
+                : source;
+            (0, cli_1.logExec)(`[${this.process.child.pid || 0}] < ${path}`);
+        }
+        const stream = typeof source === "string" ? (0, fs_1.createReadStream)(source) : source;
+        const streamPath = stream.path.toString();
+        if (onProgress) {
+            const fileInfo = await (0, promises_1.stat)(streamPath);
+            const totalBytes = fileInfo.size;
+            let currentBytes = 0;
+            stream.on("data", (data) => {
+                currentBytes += data.length;
+                onProgress?.({
+                    totalBytes: totalBytes,
+                    currentBytes: currentBytes,
+                    progress: (0, math_1.progressPercent)(totalBytes, currentBytes),
+                });
+            });
+        }
+        stream.pipe(this.writable);
+        await Promise.all([
+            this.process.waitForClose(),
+            (0, stream_1.waitForClose)(stream),
+            (0, stream_1.waitForClose)(this.writable),
+        ]);
+    }
+}
+class Std {
+    type;
+    process;
+    readable;
+    constructor(type, process, readable) {
+        this.type = type;
+        this.process = process;
+        this.readable = readable;
+    }
+    onData(cb) {
+        this.readable.on("data", cb);
+    }
+    async fetch() {
+        let data = "";
+        this.onData((chunk) => (data += chunk));
+        await this.process.waitForClose();
+        return data.trim();
+    }
+    async parseLines(cb) {
+        let total = 0;
+        const parser = (0, readline_1.createInterface)({ input: this.readable });
+        parser.on("line", (inLine) => {
+            const line = inLine.toString().trim();
+            if (line.length)
+                cb(line, ++total);
+        });
+        await Promise.all([this.process.waitForClose(), (0, stream_1.waitForClose)(parser)]);
+        return total;
+    }
+    async pipe(out, onProgress) {
+        if (this.process["log"]?.exec) {
+            const path = out instanceof StdIn
+                ? `${[out.process.child.pid || 0]}`
+                : typeof out === "string"
+                    ? out
+                    : "path" in out
+                        ? out.path
+                        : "&writableStream";
+            (0, cli_1.logExec)(`[${this.process.child.pid || 0}] ${this.type === "stderr" ? 2 : ""}> ${path}`);
+        }
+        if (onProgress) {
+            let totalBytes = 0;
+            this.readable.on("data", (chunk) => {
+                totalBytes += chunk.length;
+                onProgress({ totalBytes });
+            });
+        }
+        const stream = out instanceof StdIn
+            ? out.writable
+            : typeof out === "string"
+                ? (0, fs_1.createWriteStream)(out)
+                : out;
+        this.readable.pipe(stream);
+        await Promise.all([
+            this.process.waitForClose().catch((error) => {
+                if ("destroy" in stream)
+                    stream.destroy();
+                return Promise.reject(error);
+            }),
+            (0, stream_1.waitForClose)(stream),
+            (0, stream_1.waitForClose)(this.readable),
+        ]);
+    }
+}
+class AsyncProcess {
+    command;
+    argv;
+    options;
+    child;
+    stdout;
+    stderr;
+    stdin;
+    log;
+    controller;
+    lastStdError;
+    constructor(command, argv, options = {}) {
+        this.command = command;
+        this.argv = argv;
+        this.options = options;
+        const { $log, $controller, ...otherOptions } = options;
+        this.log = resolveLogOptions($log);
+        this.controller = $controller || new AbortController();
+        if (this.log?.exec)
+            (0, process_1.logProcess)(command, argv || [], this.log.exec === true ? {} : this.log.exec);
+        if (typeof options.cwd === "string")
+            ensureDir(options.cwd);
+        this.child = (0, child_process_1.spawn)(command, argv?.map(String) || [], otherOptions ?? {});
+        if (this.log)
+            this.installLog(this.log);
+        this.installAbortController(this.controller);
+        this.stdout = new Std("stdout", this, this.child.stdout);
+        this.stderr = new Std("stderr", this, this.child.stderr);
+        this.stdin = new StdIn(this, this.child.stdin);
+    }
+    static async exec(command, argv, options = {}) {
+        const p = new AsyncProcess(command, argv, options);
+        return await p.waitForClose();
+    }
+    static async stdout(command, argv, options = {}) {
+        const p = new AsyncProcess(command, argv, options);
+        return await p.stdout.fetch();
+    }
+    installLog(log) {
+        if (log.stdout)
+            this.child.stdout?.on("data", (chunk) => (0, process_1.logStdout)({
+                data: chunk.toString(),
+                colorize: log.colorize,
+                stderr: log.allToStderr,
+            }));
+        if (log.stderr)
+            this.child.stderr?.on("data", (chunk) => (0, process_1.logStdout)({
+                data: chunk.toString(),
+                colorize: log.colorize,
+                stderr: log.allToStderr,
+            }));
+    }
+    installAbortController(controller) {
+        if (controller.signal.aborted) {
+            this.child.kill();
+        }
+        else {
+            controller.signal.addEventListener("abort", () => {
+                this.child.kill();
+            });
+        }
+    }
+    resolveExitCode(inExitCode) {
+        let exitCode = inExitCode ?? 32;
+        if (!exitCode)
+            return exitCode;
+        const lastStdError = this.lastStdError?.toString().trim().slice(0, 255);
+        let result = this.options.$exitCode ?? true;
+        let message = (inExitCode === null
+            ? [`Process killed: ${this.command}`, lastStdError]
+            : [`Process exit code: ${exitCode} (${this.command})`, lastStdError])
+            .filter((v) => typeof v === "string" && v.length)
+            .join(" | ");
+        if (typeof result === "function")
+            result = result(exitCode);
+        if (typeof result === "string") {
+            message = result;
+        }
+        else if (typeof result === "number") {
+            exitCode = result;
+        }
+        else if (result instanceof Error) {
+            return result;
+        }
+        else if (result === false) {
+            return exitCode;
+        }
+        return new Error(message, {
+            cause: {
+                command: this.command,
+                argv: this.argv,
+                exitCode,
+                lastStdError,
+            },
+        });
+    }
+    async waitForClose() {
+        if (!this.lastStdError) {
+            this.lastStdError = Buffer.from([]);
+            this.child.stderr?.on("data", (chunk) => {
+                this.lastStdError = chunk;
+            });
+        }
+        return new Promise((resolve, reject) => {
+            this.child.on("error", reject).on("close", (exitCode) => {
+                const result = this.resolveExitCode(exitCode);
+                typeof result === "number" ? resolve(result) : reject(result);
+            });
+        });
+    }
+}
+exports.AsyncProcess = AsyncProcess;

package/lib/utils/async.d.ts

@@ -1,7 +1,5 @@
-type ControllerItem = {
-    stop?: () => void;
-};
-type ItemBuffer<T> = Map<T, ControllerItem>;
+/// <reference types="node" />
+type ItemBuffer<T> = Map<T, AbortController>;
 export declare function runParallel<T>(options: {
     items: T[];
     concurrency: number;
@@ -13,7 +11,7 @@ export declare function runParallel<T>(options: {
     onItem: (data: {
         item: T;
         index: number;
-        controller: ControllerItem;
+        controller: AbortController;
     }) => Promise<void> | void;
     onFinished?: () => Promise<void> | void;
 }): Promise<void>;