@datatruck/cli 0.34.0 → 0.34.2

package/lib/utils/process.d.ts

@@ -1,85 +1,15 @@
 /// <reference types="node" />
-/// <reference types="node" />
-/// <reference types="node" />
-import { SpawnOptions, ChildProcess, ChildProcessByStdio } from "child_process";
-import { ReadStream, WriteStream } from "fs";
 import { Readable, Writable } from "stream";
 export type ProcessEnv = {
     [name: string]: string | undefined;
 };
-export type ExecLogSettings = {
-    colorize?: boolean;
-    exec?: boolean;
-    stdout?: boolean;
-    stderr?: boolean;
-    allToStderr?: boolean;
-    envNames?: string[];
-};
-export interface ExecSettingsInterface {
-    exec?: boolean;
-    pipe?: {
-        stream: WriteStream;
-        onWriteProgress?: (data: {
-            totalBytes: number;
-        }) => void;
-    } | {
-        stream: ReadStream;
-        onReadProgress?: (data: {
-            totalBytes: number;
-            currentBytes: number;
-            progress: number;
-        }) => void;
-    } | {
-        stream: Readable;
-    };
-    log?: ExecLogSettings | boolean;
-    onSpawn?: (p: ChildProcess) => void | undefined;
-    stdout?: {
-        save?: boolean;
-        parseLines?: boolean | "skip-empty";
-        onData?: (data: string) => void;
-    };
-    stderr?: {
-        save?: boolean;
-        parseLines?: boolean | "skip-empty";
-        onData?: (data: string) => void;
-        toExitCode?: boolean;
-    };
-    onExitCodeError?: (data: ExecResult, error: Error) => Error | false;
-}
-export declare function logExecStdout(input: {
+export declare function logStdout(input: {
     data: string;
     colorize?: boolean;
     stderr?: boolean;
     lineSalt?: boolean;
 }): void;
-export declare function logExecStderr(data: string, colorize?: boolean): void;
-export type ExecResult = {
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-};
-export type ParseStreamDataOptions<S extends boolean = boolean> = {
-    save?: S;
-    parseLines?: boolean;
-    log?: LogProcessOptions | boolean;
-    onData?: (data: string) => void;
-};
-export declare function parseStreamData<S extends boolean>(stream: Readable, options?: ParseStreamDataOptions<S>): Promise<S extends true ? string : undefined>;
-type OnExitCode = OnExitCodeValue | ((code: number) => OnExitCodeValue | void | undefined);
-type OnExitCodeValue = Error | string | number | boolean;
-export declare function waitForClose<O extends boolean, E extends boolean>(p: ChildProcess, options?: {
-    strict?: boolean;
-    stdout?: O;
-    stderr?: E;
-    onExitCode?: OnExitCode;
-}): Promise<{
-    exitCode: number;
-} & (O extends true ? {
-    stdout: string;
-} : {}) & (E extends true ? {
-    stderr: string;
-} : {})>;
+export declare function logStderr(data: string, colorize?: boolean): void;
 export type LogProcessOptions = {
     envNames?: string[];
     env?: Record<string, any>;
@@ -87,23 +17,4 @@ export type LogProcessOptions = {
     toStderr?: boolean;
     colorize?: boolean;
 };
-export declare function logProcessExec(command: string, argv: any[], options: LogProcessOptions): Promise<void>;
-export type ProcessOptions<O1 extends boolean, O2 extends boolean> = {
-    $stdout?: Omit<ParseStreamDataOptions<O1>, "log">;
-    $stderr?: Omit<ParseStreamDataOptions<O2>, "log">;
-    $onExitCode?: OnExitCode;
-    $log?: boolean | {
-        exec?: boolean | LogProcessOptions;
-        stdout?: boolean | LogProcessOptions;
-        stderr?: boolean | LogProcessOptions;
-    };
-};
-export declare function createProcess<O1 extends boolean, O2 extends boolean>(command: string, argv?: (string | number)[], options?: SpawnOptions & ProcessOptions<O1, O2>): ChildProcessByStdio<Writable, Readable, Readable> & PromiseLike<{
-    exitCode: number;
-} & (O1 extends true ? {
-    stdout: string;
-} : {}) & (O2 extends true ? {
-    stderr: string;
-} : {})>;
-export declare function exec(command: string, argv?: string[], options?: SpawnOptions | null, settings?: ExecSettingsInterface): Promise<ExecResult>;
-export {};
+export declare function logProcess(command: string, argv: any[], options: LogProcessOptions): Promise<void>;

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/{Restic.d.ts → restic.d.ts}

@@ -1,4 +1,5 @@
-import { ExecResult, ExecSettingsInterface, ProcessEnv } from "./process";
+import { AsyncProcess, AsyncProcessOptions } from "./async-process";
+import { ProcessEnv } from "./process";
 import { Uri } from "./string";
 export type ResticRepositoryUri = {
     name?: string;
@@ -46,9 +47,9 @@ export declare class Restic {
         env: Record<string, string>;
     });
     static formatRepository(input: ResticRepositoryUri, hidePassword?: boolean): Promise<string>;
-    exec(args: string[], settings?: ExecSettingsInterface, options?: {
-        cwd?: string;
-    }): Promise<ExecResult>;
+    private createProcess;
+    exec(args: string[], options?: AsyncProcessOptions): Promise<number>;
+    private stdout;
     checkRepository(): Promise<boolean>;
     forget(options: {
         snapshotId?: string;
@@ -62,7 +63,7 @@ export declare class Restic {
         keepTag?: string[];
         tag?: string[];
         prune?: boolean;
-    }): Promise<string>;
+    }): Promise<void>;
     snapshots(options: {
         tags?: string[];
         paths?: string[];
@@ -91,11 +92,11 @@ export declare class Restic {
         allowEmptySnapshot?: boolean;
         onStream?: (data: ResticBackupStream) => void;
         createEmptyDir?: () => Promise<string>;
-    }): Promise<ExecResult>;
+    }): Promise<void>;
     copy(options: {
         id: string;
         onStream?: (data: ResticBackupStream) => void;
-    }): Promise<ExecResult>;
+    }): Promise<void>;
     restore(options: {
         id: string;
         target: string;
@@ -103,6 +104,6 @@ export declare class Restic {
          * @default 30_000
          */
         progressInterval?: number | false;
-        onStream?: (data: ResticBackupStream) => Promise<void>;
-    }): Promise<ExecResult>;
+        onStream?: (data: ResticBackupStream) => void;
+    }): Promise<AsyncProcess>;
 }