@datatruck/cli 0.18.0 → 0.19.0

package/Task/TaskAbstract.js

@@ -3,9 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskAbstract = void 0;
 const fs_1 = require("../utils/fs");
 class TaskAbstract {
+    config;
+    tmpDirs = [];
     constructor(config) {
         this.config = config;
-        this.tmpDirs = [];
     }
     async mkTmpDir(prefix, id) {
         const dir = await (0, fs_1.mkTmpDir)(prefix, id);

package/config.schema.json

@@ -458,45 +458,31 @@
       "additionalProperties": false,
       "properties": {
         "compress": {
-          "anyOf": [
-            {
-              "type": "boolean"
-            },
-            {
-              "type": "object",
-              "additionalProperties": false,
-              "properties": {
-                "packs": {
-                  "type": "array",
-                  "items": {
-                    "type": "object",
-                    "additionalProperties": false,
-                    "required": [
-                      "include"
-                    ],
-                    "properties": {
-                      "name": {
-                        "type": "string"
-                      },
-                      "include": {
-                        "$ref": "#/definitions/stringlist-util"
-                      },
-                      "exclude": {
-                        "$ref": "#/definitions/stringlist-util"
-                      },
-                      "onePackByResult": {
-                        "type": "boolean"
-                      }
-                    }
-                  }
-                }
+          "type": "boolean"
+        },
+        "packs": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "required": [
+              "include"
+            ],
+            "properties": {
+              "name": {
+                "type": "string"
+              },
+              "include": {
+                "$ref": "#/definitions/stringlist-util"
+              },
+              "exclude": {
+                "$ref": "#/definitions/stringlist-util"
+              },
+              "onePackByResult": {
+                "type": "boolean"
               }
             }
-          ]
-        },
-        "fileCopyConcurrency": {
-          "type": "integer",
-          "minimum": 1
+          }
         }
       }
     },

package/index.d.ts

@@ -0,0 +1 @@
+export {};

package/index.js

@@ -1 +1,2 @@
 "use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -1,23 +1,24 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.18.0",
+  "version": "0.19.0",
   "dependencies": {
     "ajv": "^8.12.0",
     "async": "^3.2.4",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.3",
-    "commander": "^9.4.1",
-    "dayjs": "^1.11.7",
-    "fast-folder-size": "^1.7.1",
-    "fast-glob": "^3.2.12",
+    "commander": "^11.0.0",
+    "dayjs": "^1.11.10",
+    "fast-folder-size": "^2.2.0",
+    "fast-glob": "^3.3.1",
     "micromatch": "^4.0.5",
     "pretty-bytes": "^5.6.0",
-    "sqlite": "^4.1.2",
-    "sqlite3": "^5.1.4"
+    "sqlite": "^5.0.1",
+    "sqlite3": "^5.1.6",
+    "tar": "^6.2.0"
   },
   "optionalDependencies": {
     "ts-node": "^10.9.1",
-    "yaml": "^2.2.1"
+    "yaml": "^2.3.2"
   },
   "engine": {
     "node": ">=16.0.0"

package/utils/DataFormat.js

@@ -10,6 +10,7 @@ const util_1 = require("util");
 const customPrefix = "custom=";
 const tplPrefix = "tpl=";
 class DataFormat {
+    options;
     constructor(options) {
         this.options = options;
     }

package/utils/Git.js

@@ -4,6 +4,7 @@ exports.Git = void 0;
 const fs_1 = require("./fs");
 const process_1 = require("./process");
 class Git {
+    options;
     constructor(options) {
         this.options = options;
     }

package/utils/ObjectVault.js

@@ -2,11 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ObjectVault = void 0;
 class ObjectVault {
-    constructor() {
-        this.counter = 0;
-        this.ids = {};
-        this.objects = {};
-    }
+    counter = 0;
+    ids = {};
+    objects = {};
     static serializeKeys(keys) {
         return JSON.stringify(keys);
     }

package/utils/Restic.js

@@ -7,6 +7,7 @@ const string_1 = require("./string");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 class Restic {
+    options;
     constructor(options) {
         this.options = options;
     }

package/utils/fs.d.ts

@@ -104,18 +104,12 @@ export declare function createFileScanner(options: {
         include: string[];
     };
     onProgress: (data: Progress) => Promise<void>;
-    disableCounting?: boolean;
-    disableEndProgress?: boolean;
 }): Promise<{
+    disposed: boolean;
     total: number;
     current: number;
-    progress: (description: string, data: {
-        path?: string;
-        current: number;
-        type?: "start" | "end";
-        percent?: number;
-    }) => Promise<void>;
-    updateProgress: (end?: boolean) => Promise<void>;
+    progress: (description: string, path?: string) => Promise<void>;
+    end: () => Promise<void>;
     start: (cb?: ((entry: Required<Entry>) => any) | undefined) => Promise<void>;
 }>;
 export {};

package/utils/fs.js

@@ -458,62 +458,54 @@ async function cpy(options) {
 exports.cpy = cpy;
 async function createFileScanner(options) {
     const object = {
+        disposed: false,
         total: 0,
         current: 0,
-        progress: async (description, data) => {
+        progress: async (description, path) => {
+            if (object.disposed)
+                return;
+            if (path)
+                object.current++;
             await options.onProgress({
                 relative: {
                     description,
-                    payload: data.path,
-                    percent: data.percent,
+                    payload: path,
                 },
                 absolute: {
                     total: object.total,
-                    current: object.current + data.current,
-                    percent: (0, math_1.progressPercent)(object.total, object.current + data.current),
+                    current: object.current,
+                    percent: (0, math_1.progressPercent)(object.total, object.current),
                 },
             });
-            if (data.type === "end") {
-                object.current += data.current;
-            }
         },
-        updateProgress: async (end) => {
-            const currentTime = performance.now();
-            const diff = currentTime - lastTime;
-            if (end || diff > 1000) {
-                await options.onProgress({
-                    relative: {
-                        description: end ? "Scanned files" : "Scanning files",
-                        payload: object.total.toString(),
-                    },
-                });
-                lastTime = currentTime;
-            }
+        end: async () => {
+            if (!object.disposed)
+                await object.progress("Finished");
+            object.disposed = true;
         },
         start: async (cb) => {
+            let lastTime = performance.now();
+            await object.progress("Scanning files");
             for await (const entry of pathIterator(stream)) {
-                if (!options.disableCounting)
+                if (cb) {
+                    if (await cb(entry))
+                        object.total++;
+                }
+                else {
                     object.total++;
-                await object.updateProgress();
-                if (cb)
-                    await cb(entry);
+                }
+                if (lastTime - performance.now() > 500)
+                    await object.progress("Scanning files");
             }
-            if (!options.disableEndProgress)
-                await object.updateProgress(true);
+            await object.progress("Scanned files");
         },
     };
-    await options.onProgress({
-        relative: {
-            description: "Scanning files",
-        },
-    });
     const stream = fast_glob_1.default.stream(options.glob.include, {
         dot: true,
         markDirectories: true,
         stats: true,
         ...options.glob,
     });
-    let lastTime = performance.now();
     return object;
 }
 exports.createFileScanner = createFileScanner;

package/utils/tar.d.ts

@@ -0,0 +1,32 @@
+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;
+    include: string[];
+    compress?: boolean;
+    onEntry?: (entry: TarEntry) => void;
+}
+export interface ExtractOptions {
+    input: string;
+    output: string;
+    verbose?: boolean;
+    total?: number;
+    onEntry?: (entry: TarEntry) => void;
+}
+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,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTar = exports.createTar = exports.listTar = void 0;
+const cli_1 = require("./cli");
+const fs_1 = require("./fs");
+const math_1 = require("./math");
+const fs_2 = require("fs");
+const promises_1 = require("fs/promises");
+const tar_1 = __importDefault(require("tar"));
+async function listTar(options) {
+    if (options.verbose)
+        (0, cli_1.logExec)("tar", ["-ztvf", options.input]);
+    let total = 0;
+    await tar_1.default.list({
+        file: options.input,
+        onentry(entry) {
+            options.onEntry?.({ path: entry.path });
+            total++;
+        },
+    });
+    return total;
+}
+exports.listTar = listTar;
+async function createTar(options) {
+    if (options.verbose)
+        (0, cli_1.logExec)("tar", [
+            options.compress ? "-czvf" : "-cvf",
+            options.output,
+            options.path,
+        ]);
+    let total = options.include.length;
+    if (!total)
+        throw new Error("'include' option is empty");
+    let current = 0;
+    let progressPromise;
+    const inStream = tar_1.default.create({
+        gzip: options.compress,
+        cwd: options.path,
+        filter(path) {
+            current++;
+            options.onEntry?.({
+                path: path,
+                progress: {
+                    total,
+                    current,
+                    percent: (0, math_1.progressPercent)(total, current),
+                },
+            });
+            return true;
+        },
+    }, options.include);
+    const outStream = (0, fs_2.createWriteStream)(options.output);
+    await new Promise((resolve, reject) => {
+        inStream.on("error", reject);
+        outStream.on("error", reject);
+        inStream.pipe(outStream);
+        outStream.on("close", resolve);
+    });
+    await progressPromise;
+}
+exports.createTar = createTar;
+async function extractTar(options) {
+    let total = options.total ??
+        (await listTar({ input: options.input, verbose: options.verbose }));
+    if (options.verbose) {
+        (0, cli_1.logExec)("tar", ["-xzvfp", options.input, "-C", options.output]);
+        (0, cli_1.logExec)("mkdir", ["-p", options.output]);
+    }
+    let current = 0;
+    await (0, promises_1.mkdir)(options.output, { recursive: true });
+    await (0, fs_1.ensureEmptyDir)(options.output);
+    await tar_1.default.extract({
+        file: options.input,
+        cwd: options.output,
+        preserveOwner: true,
+        onentry(entry) {
+            current++;
+            options.onEntry?.({
+                path: entry.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 {};