@datatruck/cli 0.34.0 → 0.34.2

package/lib/utils/{Restic.js → restic.js}

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Restic = void 0;
+const async_process_1 = require("./async-process");
 const fs_1 = require("./fs");
-const process_1 = require("./process");
 const string_1 = require("./string");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
@@ -28,14 +28,11 @@ class Restic {
         }
         return `${input.backend}:${(0, string_1.formatUri)({ ...input, password: input.password }, hidePassword)}`;
     }
-    async exec(args, settings, options) {
-        return await (0, process_1.exec)("restic", args, {
+    createProcess(args, options) {
+        return new async_process_1.AsyncProcess("restic", args, {
             stdio: ["ignore", "pipe", "pipe"],
             env: { ...process.env, ...this.options.env },
-            cwd: options?.cwd,
-        }, {
-            stderr: { toExitCode: true },
-            log: this.options.log
+            $log: this.options.log
                 ? {
                     exec: true,
                     stdout: true,
@@ -49,17 +46,22 @@ class Restic {
                     ],
                 }
                 : {},
-            ...(settings ?? {}),
+            ...(options ?? {}),
         });
     }
+    async exec(args, options) {
+        return await this.createProcess(args, options).waitForClose();
+    }
+    async stdout(args, options) {
+        return await this.createProcess(args, options).stdout.fetch();
+    }
     async checkRepository() {
-        const result = await this.exec(["cat", "config"], {
-            onExitCodeError: () => false,
-        });
-        return result.exitCode === 0;
+        return ((await this.exec(["cat", "config"], {
+            $exitCode: false,
+        })) === 0);
     }
     async forget(options) {
-        const result = await this.exec([
+        await this.exec([
             "forget",
             ...(options.keepLast ? ["--keep-last", options.keepLast.toString()] : []),
             ...(options.keepHourly
@@ -87,58 +89,46 @@ class Restic {
             ...(options.prune ? ["--prune"] : []),
             ...(options.snapshotId ? [options.snapshotId] : []),
         ]);
-        return result.stdout;
     }
     async snapshots(options) {
-        const result = await this.exec([
+        const json = await this.stdout([
             "snapshots",
             ...(options.tags?.flatMap((tag) => [`--tag`, tag]) ?? []),
             ...(options.json ? ["--json"] : []),
             ...(options.paths?.flatMap((path) => ["--path", path]) ?? []),
             ...(options.latest ? ["--latest", options.latest.toString()] : []),
             ...(options.snapshotIds || []),
-        ], {
-            stdout: { save: true },
-        });
-        return JSON.parse(result.stdout);
+        ]);
+        return JSON.parse(json);
     }
     async backup(options) {
-        const exec = async () => await this.exec([
-            "backup",
-            "--json",
-            ...(options.exclude?.flatMap((v) => ["-e", v]) ?? []),
-            ...(options.excludeFile?.flatMap((v) => ["--exclude-file", v]) ?? []),
-            ...(options.tags?.flatMap((v) => ["--tag", v]) ?? []),
-            ...(options.setPaths?.flatMap((v) => ["--set-path", v]) ?? []),
-            ...(options.parent ? ["--parent", options.parent] : []),
-            ...options.paths,
-        ], {
-            stderr: {
-                toExitCode: true,
-            },
-            stdout: {
-                ...(options.onStream && {
-                    onData: (data) => {
-                        for (const rawLine of data.split("\n")) {
-                            const line = rawLine.trim();
-                            if (line.startsWith("{") && line.endsWith("}")) {
-                                let parsedLine;
-                                try {
-                                    parsedLine = JSON.parse(line);
-                                }
-                                catch (error) { }
-                                if (parsedLine)
-                                    options.onStream?.(parsedLine);
-                            }
-                        }
-                    },
-                }),
-            },
-        }, {
-            cwd: options.cwd,
-        });
         try {
-            return await exec();
+            const backup = this.createProcess([
+                "backup",
+                "--json",
+                ...(options.exclude?.flatMap((v) => ["-e", v]) ?? []),
+                ...(options.excludeFile?.flatMap((v) => ["--exclude-file", v]) ?? []),
+                ...(options.tags?.flatMap((v) => ["--tag", v]) ?? []),
+                ...(options.setPaths?.flatMap((v) => ["--set-path", v]) ?? []),
+                ...(options.parent ? ["--parent", options.parent] : []),
+                ...options.paths,
+            ], { cwd: options.cwd });
+            if (options.onStream) {
+                await backup.stdout.parseLines((line) => {
+                    if (line.startsWith("{") && line.endsWith("}")) {
+                        let parsedLine;
+                        try {
+                            parsedLine = JSON.parse(line);
+                        }
+                        catch (error) { }
+                        if (parsedLine)
+                            options.onStream?.(parsedLine);
+                    }
+                });
+            }
+            else {
+                await backup.waitForClose();
+            }
         }
         catch (error) {
             if (options.allowEmptySnapshot &&
@@ -161,20 +151,17 @@ class Restic {
         }
     }
     async copy(options) {
-        return await this.exec(["copy", "--json", options.id], {
-            stderr: {
-                toExitCode: true,
-            },
-            stdout: {
-                ...(options.onStream && {
-                    onData: async (data) => {
-                        if (data.startsWith("{") && data.endsWith("}")) {
-                            await options.onStream?.(JSON.parse(data));
-                        }
-                    },
-                }),
-            },
-        });
+        const copy = this.createProcess(["copy", "--json", options.id]);
+        if (options.onStream) {
+            await copy.stdout.parseLines((line) => {
+                if (line.startsWith("{") && line.endsWith("}")) {
+                    options.onStream?.(JSON.parse(line));
+                }
+            });
+        }
+        else {
+            await copy.waitForClose();
+        }
     }
     async restore(options) {
         let progressTimeout;
@@ -199,20 +186,23 @@ class Restic {
         if (typeof progressInterval === "number")
             progressRutine();
         try {
-            const result = await this.exec(["restore", "--json", options.id, "--target", options.target], {
-                stderr: {
-                    toExitCode: true,
-                },
-                stdout: {
-                    ...(options.onStream && {
-                        onData: async (data) => {
-                            if (data.startsWith("{") && data.endsWith("}")) {
-                                await options.onStream?.(JSON.parse(data));
-                            }
-                        },
-                    }),
-                },
-            });
+            const result = this.createProcess([
+                "restore",
+                "--json",
+                options.id,
+                "--target",
+                options.target,
+            ]);
+            if (options.onStream) {
+                await result.stdout.parseLines((line) => {
+                    if (line.startsWith("{") && line.endsWith("}")) {
+                        options.onStream?.(JSON.parse(line));
+                    }
+                });
+            }
+            else {
+                await result.waitForClose();
+            }
             if (snapshots.at(0)?.tags?.includes(emptySnapshotTag))
                 await (0, promises_1.rm)((0, path_1.join)(options.target, `.${emptySnapshotTag}`));
             return result;

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/stream.d.ts

@@ -1,7 +1,13 @@
 /// <reference types="node" />
 import { Writable } from "stream";
-export type Streams = {
+export type StdStreams = {
     stdout: Writable;
     stderr: Writable;
 };
-export declare function createStreams(options?: Partial<Streams>): Streams;
+export declare function createStdStreams(options?: Partial<StdStreams>): StdStreams;
+export declare function waitForClose(stream: {
+    on(event: "close", cb: (...args: any[]) => any): any;
+} | {
+    on(event: "close", cb: (...args: any[]) => any): any;
+    on(event: "error", cb: (...args: any[]) => any): any;
+}): Promise<void>;

package/lib/utils/stream.js

@@ -1,10 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createStreams = void 0;
-function createStreams(options = {}) {
+exports.waitForClose = exports.createStdStreams = void 0;
+function createStdStreams(options = {}) {
     return {
         stdout: options.stdout ?? process.stdout,
         stderr: options.stderr ?? process.stderr,
     };
 }
-exports.createStreams = createStreams;
+exports.createStdStreams = createStdStreams;
+async function waitForClose(stream) {
+    return new Promise((resolve, reject) => {
+        stream.on("close", resolve);
+        stream.on("error", reject);
+    });
+}
+exports.waitForClose = waitForClose;

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.2",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {
@@ -37,7 +37,7 @@
     "fast-glob": "^3.3.2",
     "listr2": "^8.0.1",
     "micromatch": "^4.0.5",
-    "mysql2": "^3.6.5",
+    "mysql2": "^3.7.0",
     "tty-table": "^4.2.3",
     "yaml": "^2.3.4"
   },