@datatruck/cli 0.34.0 → 0.34.1

package/lib/utils/process.js

@@ -3,100 +3,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exec = exports.createProcess = exports.logProcessExec = exports.waitForClose = exports.parseStreamData = exports.logExecStderr = exports.logExecStdout = void 0;
+exports.logProcess = exports.logStderr = exports.logStdout = void 0;
 const cli_1 = require("./cli");
-const fs_1 = require("./fs");
-const math_1 = require("./math");
 const chalk_1 = __importDefault(require("chalk"));
-const child_process_1 = require("child_process");
-const fs_2 = require("fs");
-const promises_1 = require("fs/promises");
-const readline_1 = require("readline");
 const stream_1 = require("stream");
-function logExecStdout(input) {
+function logStdout(input) {
     let text = input.colorize ? chalk_1.default.grey(input.data) : input.data;
     if (input.lineSalt)
         text += "\n";
     input.stderr ? process.stderr.write(text) : process.stdout.write(text);
 }
-exports.logExecStdout = logExecStdout;
-function logExecStderr(data, colorize) {
+exports.logStdout = logStdout;
+function logStderr(data, colorize) {
     process.stdout.write(colorize ? chalk_1.default.red(data) : data);
 }
-exports.logExecStderr = logExecStderr;
-function parseStreamData(stream, options = {}) {
-    const log = options.log === true ? {} : options.log;
-    let result;
-    if (options.save)
-        result = "";
-    return new Promise((resolve, reject) => {
-        const lines = options.parseLines;
-        const onData = (data) => {
-            if (options.onData)
-                options.onData(data.toString());
-            if (log)
-                logExecStdout({
-                    data: lines ? `${data}\n` : data.toString(),
-                    stderr: log.toStderr,
-                    colorize: log.colorize,
-                });
-            if (options?.save)
-                result += data.toString();
-        };
-        if (lines) {
-            const rl = (0, readline_1.createInterface)({
-                input: stream,
-            });
-            rl.on("line", onData).on("close", () => resolve(result));
-        }
-        else {
-            stream
-                .on("data", onData)
-                .on("error", reject)
-                .once("close", () => resolve(result));
-        }
-    });
-}
-exports.parseStreamData = parseStreamData;
-function waitForClose(p, options = {}) {
-    return new Promise((resolve, reject) => {
-        let result = {
-            exitCode: 1,
-        };
-        if (options.stdout) {
-            result.stdout = "";
-            p.stdout.on("data", (data) => (result.stdout += data.toString()));
-        }
-        p.once("error", reject).once("close", (exitCode) => {
-            if (exitCode) {
-                let onExitCode = options.onExitCode ?? true;
-                if (typeof onExitCode === "function") {
-                    onExitCode = onExitCode(exitCode);
-                }
-                if (typeof onExitCode === "string") {
-                    reject(new Error(onExitCode));
-                }
-                else if (typeof onExitCode === "number") {
-                    reject(new Error(`Exit code: ${onExitCode}`));
-                }
-                else if (onExitCode instanceof Error) {
-                    reject(onExitCode);
-                }
-                else if (onExitCode === false) {
-                    resolve({ ...result, exitCode: exitCode });
-                }
-                else {
-                    reject(new Error(`Exit code: ${exitCode}`));
-                }
-            }
-            else {
-                resolve({ ...result, exitCode: exitCode });
-            }
-        });
-    });
-}
-exports.waitForClose = waitForClose;
-async function logProcessExec(command, argv, options) {
+exports.logStderr = logStderr;
+async function logProcess(command, argv, options) {
     const logEnv = options.envNames?.reduce((env, key) => {
         const value = options?.env?.[key];
         if (typeof value !== "undefined")
@@ -111,230 +33,4 @@ async function logProcessExec(command, argv, options) {
         ]
         : argv, logEnv, options.toStderr);
 }
-exports.logProcessExec = logProcessExec;
-function createProcess(command, argv = [], options = {}) {
-    const $log = options.$log === true
-        ? { exec: {}, stdout: {}, stderr: {} }
-        : options.$log || {};
-    if ($log.exec)
-        logProcessExec(command, argv, $log.exec === true ? {} : $log.exec);
-    if (typeof options.cwd === "string") {
-        let isDir = false;
-        try {
-            isDir = (0, fs_2.statSync)(options.cwd).isDirectory();
-        }
-        catch (error) { }
-        if (!isDir)
-            throw new Error(`Current working directory does not exist: ${options.cwd}`);
-    }
-    const handler = (0, child_process_1.spawn)(command, argv.map((v) => (typeof v === "number" ? v.toString() : v)), options ?? {});
-    const { $stdout, $stderr, $onExitCode } = options;
-    async function exec() {
-        const [stdout, stderr, result] = await Promise.all([
-            (!!$log.stdout || !!$stdout) &&
-                parseStreamData(handler.stdout, {
-                    log: $log.stdout,
-                    ...$stdout,
-                }),
-            (!!$log.stderr || !!$stderr) &&
-                parseStreamData(handler.stderr, {
-                    log: $log.stderr,
-                    ...$stderr,
-                }),
-            waitForClose(handler, {
-                onExitCode: $onExitCode,
-            }),
-        ]);
-        const endResult = {
-            exitCode: result.exitCode,
-        };
-        if (typeof stdout === "string")
-            endResult.stdout = stdout;
-        if (typeof stderr === "string")
-            endResult.stderr = stderr;
-        return endResult;
-    }
-    const promise = {
-        [Symbol.toStringTag]: "process",
-        then: function (onfulfilled, onrejected) {
-            return exec().then(onfulfilled, onrejected);
-        },
-        catch: function (onrejected) {
-            return exec().catch(onrejected);
-        },
-        finally: function (onfinally) {
-            return exec().finally(onfinally);
-        },
-    };
-    Object.assign(handler, promise);
-    return handler;
-}
-exports.createProcess = createProcess;
-async function exec(command, argv = [], options = null, settings = {}) {
-    const pipe = settings.pipe;
-    let log = {};
-    if (settings.log === true) {
-        log.exec = log.stdout = log.stderr = log.allToStderr = log.colorize = true;
-    }
-    else if (settings.log) {
-        log = settings.log;
-    }
-    if (log.exec)
-        logProcessExec(command, argv, {
-            env: options?.env,
-            envNames: log.envNames,
-            pipe: pipe?.stream,
-            toStderr: log.allToStderr,
-        });
-    if (typeof options?.cwd === "string" && !(await (0, fs_1.existsDir)(options.cwd)))
-        throw new Error(`Current working directory does not exist: ${options.cwd}`);
-    if (pipe?.stream instanceof fs_2.ReadStream && "onReadProgress" in pipe) {
-        const fileInfo = await (0, promises_1.stat)(pipe.stream.path);
-        const totalBytes = fileInfo.size;
-        let currentBytes = 0;
-        pipe.stream.on("data", (data) => {
-            currentBytes += data.length;
-            pipe.onReadProgress?.({
-                totalBytes: totalBytes,
-                currentBytes: currentBytes,
-                progress: (0, math_1.progressPercent)(totalBytes, currentBytes),
-            });
-        });
-    }
-    const p = (0, child_process_1.spawn)(command, argv, options ?? {});
-    settings.onSpawn?.(p);
-    let spawnError;
-    const spawnData = {
-        stdout: "",
-        stderr: "",
-        exitCode: 0,
-    };
-    let finishListeners = 1;
-    if (pipe?.stream instanceof fs_2.WriteStream)
-        finishListeners++;
-    if (settings.stdout?.parseLines)
-        finishListeners++;
-    if (settings.stderr?.parseLines)
-        finishListeners++;
-    let streamError;
-    return new Promise((resolve, reject) => {
-        const tryFinish = () => {
-            if (!--finishListeners)
-                finish();
-        };
-        const finish = () => {
-            if (spawnData.exitCode) {
-                let exitCodeError;
-                if (settings.stderr?.toExitCode) {
-                    exitCodeError = new Error(`Exit code ${spawnData.exitCode}: ${command} ${argv.join(" ")} | ${spawnData.stderr
-                        .split(/\r?\n/g)
-                        .filter((v) => !!v.length)
-                        .join(" | ")}`);
-                }
-                else {
-                    exitCodeError = new Error(`Exit code ${spawnData.exitCode}: ${command} ${argv.join(" ")}`);
-                }
-                const exitCodeErrorResult = settings.onExitCodeError?.(spawnData, exitCodeError);
-                if (exitCodeErrorResult instanceof Error) {
-                    return reject(exitCodeErrorResult);
-                }
-                else if (exitCodeErrorResult !== false) {
-                    return reject(exitCodeError);
-                }
-            }
-            if (streamError) {
-                reject(streamError);
-            }
-            else if (spawnError) {
-                reject(spawnError);
-            }
-            else {
-                resolve(spawnData);
-            }
-        };
-        if (pipe) {
-            pipe.stream.on("error", (error) => {
-                streamError = error;
-                tryFinish();
-            });
-            if (pipe.stream instanceof fs_2.WriteStream) {
-                if (!p.stdout)
-                    throw new Error(`stdout is not defined`);
-                if (!p.stderr)
-                    throw new Error(`stderr is not defined`);
-                if ("onWriteProgress" in pipe && pipe.onWriteProgress) {
-                    let totalBytes = 0;
-                    p.stdout.on("data", (chunk) => {
-                        totalBytes += chunk.length;
-                        pipe.onWriteProgress({ totalBytes });
-                    });
-                    p.stderr.on("data", (chunk) => {
-                        totalBytes += chunk.length;
-                        pipe.onWriteProgress({ totalBytes });
-                    });
-                }
-                p.stdout.pipe(pipe.stream, { end: false });
-                p.stderr.pipe(pipe.stream, { end: false });
-                p.on("close", tryFinish);
-            }
-            else if (pipe.stream instanceof stream_1.Readable) {
-                if (!p.stdin)
-                    throw new Error(`stdin is not defined`);
-                pipe.stream.pipe(p.stdin);
-            }
-        }
-        const stdConfig = {
-            stdout: { log: log.stdout, settings: settings.stdout },
-            stderr: { log: log.stderr, settings: settings.stderr },
-        };
-        for (const inType in stdConfig) {
-            const type = inType;
-            const enabled = log[type] || settings[type];
-            if (!enabled)
-                continue;
-            if (!p[type])
-                throw new Error(`${type} is not defined`);
-            const parseLines = settings[type]?.parseLines;
-            const skipEmptyLines = parseLines === "skip-empty";
-            const onData = (inData) => {
-                let data = inData.toString();
-                if (parseLines) {
-                    if (skipEmptyLines && !data.trim().length)
-                        return;
-                    data = `${inData}\n`;
-                }
-                if (log[type])
-                    logExecStdout({
-                        data,
-                        stderr: log.allToStderr,
-                        colorize: log.colorize,
-                    });
-                if (settings[type]?.save ||
-                    (type === "stderr" && settings[type]?.toExitCode))
-                    spawnData[type] += data;
-                if (settings[type]?.onData)
-                    settings[type].onData(inData.toString());
-            };
-            if (parseLines) {
-                const rl = (0, readline_1.createInterface)({
-                    input: p[type],
-                });
-                rl.on("line", onData);
-                rl.on("close", tryFinish);
-            }
-            else if (log[type] ||
-                settings[type]?.save ||
-                settings[type]?.onData ||
-                (type === "stderr" && settings[type]?.toExitCode)) {
-                p[type].on("data", onData);
-            }
-        }
-        p.on("error", (error) => (spawnError = error)).on("close", (exitCode) => {
-            spawnData.exitCode = exitCode ?? 0;
-            if (pipe?.stream instanceof fs_2.WriteStream)
-                pipe.stream.end();
-            tryFinish();
-        });
-    });
-}
-exports.exec = exec;
+exports.logProcess = logProcess;

package/lib/utils/spawnSteps.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runSpawnSteps = exports.isSpawnStep = void 0;
-const process_1 = require("./process");
+const async_process_1 = require("./async-process");
 const string_1 = require("./string");
 const temp_1 = require("./temp");
 const promises_1 = require("fs/promises");
@@ -49,22 +49,21 @@ async function runSpawnSteps(input, options) {
                     : []),
                 ...(step.config.args || []).map((arg) => (0, string_1.render)(arg.toString(), data)),
             ];
-            await (0, process_1.exec)(command, args, {
+            const p = new async_process_1.AsyncProcess(command, args, {
                 cwd: options.cwd,
                 env: {
                     ...process.env,
                     ...options.env,
                     ...step.config.env,
                 },
-            }, {
-                log: options.verbose,
-                ...(options.onLine && {
-                    stdout: {
-                        parseLines: "skip-empty",
-                        onData: (line) => options.onLine(line),
-                    },
-                }),
+                $log: options.verbose,
             });
+            if (options.onLine) {
+                await p.stdout.parseLines(options.onLine);
+            }
+            else {
+                await p.waitForClose();
+            }
         }
         else {
             throw new Error(`Invalid step type: ${step.type}`);

package/lib/utils/tar.js

@@ -1,30 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.extractTar = exports.normalizeTarPath = exports.createTar = exports.checkPigzLib = exports.listTar = exports.getTarVendor = void 0;
+const async_process_1 = require("./async-process");
 const cli_1 = require("./cli");
 const fs_1 = require("./fs");
 const math_1 = require("./math");
-const process_1 = require("./process");
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
 let tarVendor;
 async function getTarVendor(cache = true, log = false) {
     if (cache && typeof tarVendor !== "undefined")
         return tarVendor;
-    const p = await (0, process_1.exec)("tar", ["--help"], {}, {
-        log,
-        stdout: {
-            save: true,
-        },
-    });
+    const stdout = await async_process_1.AsyncProcess.stdout("tar", ["--help"], { $log: log });
     const find = () => {
-        if (p.stdout.includes("BusyBox")) {
+        if (stdout.includes("BusyBox")) {
             return "busybox";
         }
-        else if (p.stdout.includes("bsdtar")) {
+        else if (stdout.includes("bsdtar")) {
             return "bsdtar";
         }
-        else if (p.stdout.includes("GNU")) {
+        else if (stdout.includes("GNU")) {
             return "gnu";
         }
         else {
@@ -36,22 +31,14 @@ async function getTarVendor(cache = true, log = false) {
 exports.getTarVendor = getTarVendor;
 async function listTar(options) {
     const vendor = await getTarVendor(true, options.verbose);
-    let total = 0;
-    await (0, process_1.exec)("tar", [
+    const p = new async_process_1.AsyncProcess("tar", [
         "-tf",
         toLocalPath(options.input),
         ...(vendor === "bsdtar" ? [] : ["--force-local"]),
-    ], {}, {
-        log: options.verbose,
-        stdout: {
-            parseLines: "skip-empty",
-            onData: (path) => {
-                options.onEntry?.({ path: normalizeTarPath(path) });
-                total++;
-            },
-        },
+    ], { $log: options.verbose });
+    return await p.stdout.parseLines((path) => {
+        options.onEntry?.({ path: normalizeTarPath(path) });
     });
-    return total;
 }
 exports.listTar = listTar;
 let pigzLib;
@@ -59,7 +46,10 @@ async function checkPigzLib(cache = true) {
     if (cache && pigzLib !== undefined)
         return pigzLib;
     try {
-        return !(await (0, process_1.exec)("pigz", ["-V"])).exitCode;
+        const exitCode = await async_process_1.AsyncProcess.exec("pigz", ["-V"], {
+            $exitCode: false,
+        });
+        return !exitCode;
     }
     catch {
         return false;
@@ -105,7 +95,7 @@ async function createTar(options) {
             },
         });
     };
-    await (0, process_1.exec)("tar", [
+    const p = new async_process_1.AsyncProcess("tar", [
         "--no-recursion",
         "-C",
         toLocalPath(options.path),
@@ -139,21 +129,16 @@ async function createTar(options) {
             ...process.env,
             ...env,
         },
-    }, {
-        log: options.verbose
+        $log: options.verbose
             ? { envNames: Object.keys(env), exec: true, stderr: true, stdout: true }
             : false,
-        ...(vendor === "bsdtar"
-            ? {
-                stderr: options.onEntry
-                    ? { toExitCode: true, parseLines: "skip-empty", onData }
-                    : { toExitCode: true },
-            }
-            : {
-                stderr: { toExitCode: true },
-                stdout: { parseLines: "skip-empty", onData },
-            }),
     });
+    if (options.onEntry) {
+        await p[vendor === "bsdtar" ? "stderr" : "stdout"].parseLines(onData);
+    }
+    else {
+        await p.waitForClose();
+    }
 }
 exports.createTar = createTar;
 /**
@@ -197,7 +182,7 @@ async function extractTar(options) {
             },
         });
     };
-    await (0, process_1.exec)("tar", [
+    const p = new async_process_1.AsyncProcess("tar", [
         decompress?.cores === 1 ? "-xzvpf" : "-xvpf",
         toLocalPath(options.input),
         "-C",
@@ -211,18 +196,13 @@ async function extractTar(options) {
             decompress.cores > 1 && {
             shell: true,
         }),
-    }, {
-        log: options.verbose,
-        ...(vendor === "bsdtar"
-            ? {
-                stderr: options.onEntry
-                    ? { toExitCode: true, parseLines: "skip-empty", onData }
-                    : { toExitCode: true },
-            }
-            : {
-                stderr: { toExitCode: true },
-                stdout: { parseLines: "skip-empty", onData },
-            }),
+        $log: options.verbose,
     });
+    if (options.onEntry) {
+        await p[vendor === "bsdtar" ? "stderr" : "stdout"].parseLines(onData);
+    }
+    else {
+        await p.waitForClose();
+    }
 }
 exports.extractTar = extractTar;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.34.0",
+  "version": "0.34.1",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {