@datatruck/cli 0.18.0 → 0.20.0

package/utils/process.js

@@ -188,7 +188,7 @@ async function exec(command, argv = [], options = null, settings = {}) {
                 toStderr: log.allToStderr,
             });
         }
-        if (typeof options?.cwd === "string" && !(await (0, fs_1.checkDir)(options.cwd)))
+        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);
@@ -225,13 +225,13 @@ async function exec(command, argv = [], options = null, settings = {}) {
             if (spawnData.exitCode) {
                 let exitCodeError;
                 if (settings.stderr?.toExitCode) {
-                    exitCodeError = new Error(`Exit code ${spawnData.exitCode}: ${spawnData.stderr
+                    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(" ")})`);
+                    exitCodeError = new Error(`Exit code ${spawnData.exitCode}: ${command} ${argv.join(" ")}`);
                 }
                 const exitCodeErrorResult = settings.onExitCodeError?.(spawnData, exitCodeError);
                 if (exitCodeErrorResult instanceof Error) {
@@ -286,17 +286,24 @@ async function exec(command, argv = [], options = null, settings = {}) {
             if (!p.stdout)
                 throw new Error(`stdout is not defined`);
             const parseLines = settings.stdout?.parseLines;
-            const onData = (data) => {
+            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.stdout)
                     logExecStdout({
-                        data: parseLines ? `${data}\n` : data.toString(),
+                        data,
                         stderr: log.allToStderr,
                         colorize: log.colorize,
                     });
                 if (settings.stdout?.save)
-                    spawnData.stdout += data.toString();
+                    spawnData.stdout += data;
                 if (settings.stdout?.onData)
-                    settings.stdout.onData(data.toString());
+                    settings.stdout.onData(inData.toString());
             };
             if (parseLines) {
                 const rl = (0, readline_1.createInterface)({
@@ -305,7 +312,9 @@ async function exec(command, argv = [], options = null, settings = {}) {
                 rl.on("line", onData);
                 rl.on("close", tryFinish);
             }
-            else {
+            else if (log.stdout ||
+                settings.stdout?.save ||
+                settings.stdout?.onData) {
                 p.stdout.on("data", onData);
             }
         }

package/utils/string.d.ts

@@ -1,6 +1,4 @@
 export declare function serialize(message: string, data?: Object): string;
-export declare function ucfirst(value: string): string;
-export declare function lcfirst(value: string): string;
 export declare function snakeCase(value: string, char?: string): string;
 export declare function render(subject: string, vars: Record<string, string | undefined>): string;
 export declare function parseStringList(value: string, validValues?: string[]): string[];

package/utils/string.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatDateTime = exports.checkMatch = exports.checkPath = exports.makePathPatterns = exports.formatSeconds = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = exports.lcfirst = exports.ucfirst = exports.serialize = void 0;
+exports.formatDateTime = exports.checkMatch = exports.checkPath = exports.makePathPatterns = exports.formatSeconds = exports.formatUri = exports.parseStringList = exports.render = exports.snakeCase = exports.serialize = void 0;
 const AppError_1 = require("../Error/AppError");
 const micromatch_1 = require("micromatch");
 function serialize(message, data) {
@@ -9,14 +9,6 @@ function serialize(message, data) {
     return message;
 }
 exports.serialize = serialize;
-function ucfirst(value) {
-    return value.charAt(0).toUpperCase() + value.slice(1);
-}
-exports.ucfirst = ucfirst;
-function lcfirst(value) {
-    return value.charAt(0).toLowerCase() + value.slice(1);
-}
-exports.lcfirst = lcfirst;
 function snakeCase(value, char = "_") {
     return value.replace(/[A-Z]/g, (letter) => `${char}${letter.toLowerCase()}`);
 }

package/utils/tar.d.ts

@@ -0,0 +1,35 @@
+export type Progress = {
+    percent: number;
+    current: number;
+    total: number;
+};
+export type TarEntry = {
+    path: string;
+    progress: Progress;
+};
+export interface CreateTarOptions {
+    path: string;
+    verbose?: boolean;
+    output: string;
+    includeList: string;
+    compress?: boolean;
+    onEntry?: (entry: TarEntry) => void;
+}
+export interface ExtractOptions {
+    input: string;
+    output: string;
+    verbose?: boolean;
+    uncompress?: boolean;
+    total?: number;
+    onEntry?: (entry: TarEntry) => void;
+}
+export type TarVendor = "busybox" | "bsdtar" | "gnu";
+export declare function getTarVendor(cache?: boolean, log?: boolean): Promise<TarVendor | null>;
+export type ListTarOptions = {
+    input: string;
+    onEntry?: (entry: Pick<TarEntry, "path">) => void;
+    verbose?: boolean;
+};
+export declare function listTar(options: ListTarOptions): Promise<number>;
+export declare function createTar(options: CreateTarOptions): Promise<void>;
+export declare function extractTar(options: ExtractOptions): Promise<void>;

package/utils/tar.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTar = exports.createTar = exports.listTar = exports.getTarVendor = void 0;
+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 find = () => {
+        if (p.stdout.includes("BusyBox")) {
+            return "busybox";
+        }
+        else if (p.stdout.includes("bsdtar")) {
+            return "bsdtar";
+        }
+        else if (p.stdout.includes("GNU")) {
+            return "gnu";
+        }
+        else {
+            return null;
+        }
+    };
+    return (tarVendor = find());
+}
+exports.getTarVendor = getTarVendor;
+async function listTar(options) {
+    let total = 0;
+    await (0, process_1.exec)("tar", ["-tf", toLocalPath(options.input), "--force-local"], {}, {
+        log: options.verbose,
+        stdout: {
+            parseLines: "skip-empty",
+            onData: (path) => {
+                options.onEntry?.({ path });
+                total++;
+            },
+        },
+    });
+    return total;
+}
+exports.listTar = listTar;
+async function createTar(options) {
+    const vendor = await getTarVendor(true, options.verbose);
+    const total = await (0, fs_1.countFileLines)(options.includeList);
+    let current = 0;
+    await (0, process_1.exec)("tar", [
+        "-C",
+        toLocalPath(options.path),
+        options.compress ? "-czvf" : "-cvf",
+        toLocalPath(options.output),
+        "-T",
+        toLocalPath(options.includeList),
+        "--ignore-failed-read",
+        "--force-local",
+    ], {}, {
+        log: options.verbose,
+        stderr: { toExitCode: true },
+        stdout: {
+            parseLines: "skip-empty",
+            onData: (line) => {
+                current++;
+                const path = vendor === "bsdtar" ? line.slice(2) : line;
+                options.onEntry?.({
+                    path,
+                    progress: {
+                        total,
+                        current,
+                        percent: (0, math_1.progressPercent)(total, current),
+                    },
+                });
+            },
+        },
+    });
+}
+exports.createTar = createTar;
+/**
+ * Fix `tar.exe: Option --force-local is not supported`
+ */
+function toLocalPath(path) {
+    return (0, os_1.platform)() === "win32" ? path.replace(/\\/g, "/") : path;
+}
+async function extractTar(options) {
+    let total = options.total ??
+        (await listTar({ input: options.input, verbose: options.verbose }));
+    if (options.verbose)
+        (0, cli_1.logExec)("mkdir", ["-p", options.output]);
+    await (0, promises_1.mkdir)(options.output, { recursive: true });
+    await (0, fs_1.ensureEmptyDir)(options.output);
+    let current = 0;
+    await (0, process_1.exec)("tar", [
+        options.uncompress ? "-xzvpf" : "-xvpf",
+        toLocalPath(options.input),
+        "-C",
+        toLocalPath(options.output),
+        "--force-local",
+    ], {}, {
+        log: options.verbose,
+        stderr: {
+            toExitCode: true,
+        },
+        stdout: {
+            parseLines: "skip-empty",
+            onData: (path) => {
+                current++;
+                options.onEntry?.({
+                    path,
+                    progress: {
+                        total,
+                        current,
+                        percent: (0, math_1.progressPercent)(total, current),
+                    },
+                });
+            },
+        },
+    });
+}
+exports.extractTar = extractTar;

package/utils/zip.d.ts

@@ -1,97 +0,0 @@
-export interface ZipDataFilterType {
-    recursive?: boolean;
-    exclude?: boolean;
-    patterns: string[];
-}
-export interface ZipDataType {
-    command?: string;
-    path: string;
-    filter?: (ZipDataFilterType | string)[];
-    output: string;
-    deleteOnZip?: boolean;
-    includeList?: string;
-    excludeList?: string;
-    verbose?: boolean;
-    onProgress?: (data: {
-        percent: number;
-        total: number;
-        current: number;
-        path?: string;
-        type?: "start" | "end";
-    }) => void | Promise<void>;
-    onStream?: (data: ZipStream) => void | Promise<void>;
-}
-export interface UnzipDataType {
-    command?: string;
-    input: string;
-    files?: (ZipDataFilterType | string)[];
-    output: string;
-    verbose?: boolean;
-    onProgress?: (data: {
-        percent: number;
-        current: number;
-        path?: string;
-        type?: "start" | "end";
-    }) => void | Promise<void>;
-    onStream?: (data: UnzipStream) => void | Promise<void>;
-}
-export declare function buildArguments(filters: (ZipDataFilterType | string)[]): string[];
-export declare function checkSSEOption(command?: string): Promise<boolean>;
-type ListZipStream = {
-    Path?: string;
-    Folder?: string;
-    Size?: string;
-    "Packed Size"?: string;
-    Modified?: string;
-    Created?: string;
-    Accessed?: string;
-    Attributes?: string;
-    Encrypted?: string;
-    Comment?: string;
-    CRC?: string;
-    Method?: string;
-    Characteristics?: string;
-    "Host OS"?: string;
-    Version?: string;
-    Volume?: string;
-    Offset?: string;
-};
-export declare function listZip(data: {
-    command?: string;
-    path: string;
-    onStream: (item: ListZipStream) => Promise<void>;
-    verbose?: boolean;
-}): Promise<void>;
-export type ZipStream = {
-    type: "progress";
-    data: {
-        progress: number;
-        files: number;
-        path: string;
-    };
-} | {
-    type: "summary";
-    data: {
-        folders: number;
-        files: number;
-    };
-};
-export declare function zip(data: ZipDataType): Promise<{
-    folders: number;
-    files: number;
-}>;
-export type UnzipStream = {
-    type: "progress";
-    data: {
-        percent: number;
-        files: number;
-        path: string;
-    };
-};
-export declare function unzip(data: UnzipDataType): Promise<{
-    files: number;
-    stdout: string;
-    stderr: string;
-    exitCode: number;
-}>;
-export {};

package/utils/zip.js

@@ -1,238 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.unzip = exports.zip = exports.listZip = exports.checkSSEOption = exports.buildArguments = void 0;
-const process_1 = require("./process");
-const path_1 = require("path");
-function buildArguments(filters) {
-    const args = [];
-    for (const item of filters) {
-        let filter;
-        if (typeof item === "string") {
-            filter = {
-                recursive: false,
-                exclude: false,
-                patterns: [item],
-            };
-        }
-        else {
-            filter = item;
-        }
-        args.push(...filter.patterns.map((value) => {
-            let option = "-";
-            option += filter.exclude ? "x" : "i";
-            if (filter.recursive)
-                option += "r";
-            option += "!";
-            option += (0, path_1.normalize)(value);
-            return option;
-        }));
-    }
-    return args;
-}
-exports.buildArguments = buildArguments;
-let checkSSEOptionResult;
-async function checkSSEOption(command = "7z") {
-    const result = await (0, process_1.exec)(command, [], {}, {
-        stdout: {
-            save: true,
-        },
-    });
-    if (typeof checkSSEOptionResult === "boolean")
-        return checkSSEOptionResult;
-    return (checkSSEOptionResult = result.stdout.includes(" -sse"));
-}
-exports.checkSSEOption = checkSSEOption;
-const listZipLineEqChar = " = ";
-function parseListZipLine(line, buffer) {
-    if (buffer.started) {
-        if (line === "") {
-            if (buffer.opened) {
-                const { stream } = buffer;
-                buffer.stream = {};
-                buffer.opened = false;
-                return stream;
-            }
-        }
-        else {
-            const separator = line.indexOf(listZipLineEqChar);
-            const key = line.slice(0, separator);
-            const value = line.slice(separator + listZipLineEqChar.length);
-            buffer.opened = true;
-            buffer.stream[key] = value;
-        }
-    }
-    else if (line.startsWith("----------")) {
-        buffer.started = true;
-        buffer.stream = {};
-    }
-}
-async function listZip(data) {
-    const buffer = {};
-    await (0, process_1.exec)(data.command ?? "7z", ["l", data.path, "-slt"], {}, {
-        log: {
-            exec: data.verbose ?? false,
-            stderr: data.verbose ?? false,
-            stdout: false,
-        },
-        onExitCodeError: (data, error) => (data.exitCode > 2 ? error : false),
-        stdout: {
-            parseLines: true,
-            onData: async (line) => {
-                const stream = parseListZipLine(line, buffer);
-                if (stream) {
-                    await data.onStream?.(stream);
-                }
-            },
-        },
-    });
-}
-exports.listZip = listZip;
-function parseZipLine(line) {
-    let matches = null;
-    line = line.trim();
-    if (!line.length)
-        return;
-    if ((matches = /^(\d+)% (\d+ )?\+/.exec(line))) {
-        const path = line.slice(line.indexOf("+") + 1).trim();
-        const progress = Number(matches[1]);
-        const files = matches[2] ? Number(matches[2]) : 1;
-        return {
-            type: "progress",
-            data: { progress, path, files },
-        };
-    }
-    else if (line.startsWith("Add new data to archive:")) {
-        const [, folders] = /(\d+) folders?/i.exec(line) || [, 0];
-        const [, files] = /(\d+) files?/i.exec(line) || [, 0];
-        return {
-            type: "summary",
-            data: {
-                folders: Number(folders),
-                files: Number(files),
-            },
-        };
-    }
-}
-async function zip(data) {
-    let summary = {
-        folders: 0,
-        files: 0,
-    };
-    await data.onProgress?.({
-        current: 0,
-        percent: 0,
-        total: 0,
-        type: "start",
-    });
-    await (0, process_1.exec)(data.command ?? "7z", [
-        "a",
-        // https://sourceforge.net/p/sevenzip/bugs/2099/,
-        // https://github.com/mcmilk/7-Zip/commit/87ba6f01ba3c5b2ce3186bddfe3d7d880639193c#diff-779d6b1bfa6196b288478f78ca96c4d4c6d7ac6cf8be15a28a20dabc9137ca36L515
-        ...((await checkSSEOption(data.command)) ? [] : ["-mmt1"]),
-        "-bsp1",
-        ...(data.deleteOnZip ? ["-sdel"] : []),
-        (0, path_1.normalize)(data.output),
-        ...buildArguments(data.filter ?? []),
-        ...(data.includeList ? [`@${(0, path_1.normalize)(data.includeList)}`] : []),
-        ...(data.excludeList ? [`-x@${(0, path_1.normalize)(data.excludeList)}`] : []),
-    ], {
-        cwd: data.path,
-    }, {
-        log: data.verbose ?? false,
-        onExitCodeError: (data, error) => (data.exitCode > 2 ? error : false),
-        stdout: {
-            onData: async (lines) => {
-                for (const line of lines.replaceAll("\b", "").split(/\r?\n/)) {
-                    const stream = parseZipLine(line);
-                    if (stream) {
-                        if (stream.type === "summary")
-                            summary = stream.data;
-                        if (stream.type === "progress") {
-                            const current = Math.max(0, stream.data.files - 1);
-                            await data.onProgress?.({
-                                total: summary.files,
-                                current,
-                                path: stream.data.path,
-                                percent: stream.data.progress,
-                            });
-                        }
-                        await data.onStream?.(stream);
-                    }
-                }
-            },
-        },
-    });
-    await data.onProgress?.({
-        total: summary.files,
-        current: summary.files,
-        percent: 100,
-        type: "end",
-    });
-    return summary;
-}
-exports.zip = zip;
-function parseUnzipLine(line) {
-    let matches = null;
-    if ((matches = /^\s*(?<percent>\d+)%(?: (?<files>\d+))? \-/.exec(line))) {
-        const progress = Number(matches.groups["percent"]);
-        const files = matches.groups["files"] ? Number(matches[2]) : 1;
-        const path = line.slice(line.indexOf("-") + 1).trim();
-        return {
-            type: "progress",
-            data: { percent: progress, path, files },
-        };
-    }
-}
-async function unzip(data) {
-    let summary = {
-        files: 0,
-    };
-    await data.onProgress?.({
-        current: summary.files,
-        percent: 0,
-        type: "start",
-    });
-    const result = await (0, process_1.exec)(data.command ?? "7z", [
-        "x",
-        "-bsp1",
-        (0, path_1.normalize)(data.input),
-        ...buildArguments(data.files ?? []),
-        `-o${(0, path_1.normalize)(data.output)}`,
-        "-r",
-    ], {}, {
-        log: data.verbose ?? false,
-        stderr: { toExitCode: true },
-        stdout: {
-            ...((data.onStream || data.onProgress) && {
-                onData: async (chunk) => {
-                    const lines = chunk.replaceAll("\b", "").split(/\r?\n/);
-                    for (const line of lines) {
-                        const stream = parseUnzipLine(line);
-                        if (stream) {
-                            if (stream.type === "progress") {
-                                const current = Math.max(0, stream.data.files - 1);
-                                summary.files = stream.data.files;
-                                await data.onProgress?.({
-                                    current,
-                                    percent: stream.data.percent,
-                                    path: stream.data.path,
-                                });
-                            }
-                            await data.onStream?.(stream);
-                        }
-                    }
-                },
-            }),
-        },
-    });
-    await data.onProgress?.({
-        current: summary.files,
-        percent: 100,
-        type: "end",
-    });
-    return {
-        ...result,
-        ...summary,
-    };
-}
-exports.unzip = unzip;