@datatruck/cli 0.37.0 → 0.38.1

package/lib/actions/ExportAction.d.ts

@@ -0,0 +1,94 @@
+import { DataFormat } from "../utils/data-format";
+import type { Config } from "../utils/datatruck/config-type";
+import { Listr3TaskResultEnd } from "../utils/list";
+import { InferOptions } from "../utils/options";
+import { Progress, ProgressMode } from "../utils/progress";
+import { StdStreams } from "../utils/stream";
+import { ExtendedSnapshot } from "./SnapshotsAction";
+export declare const exportActionOptions: {
+    repositoryNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    repositoryTypes: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageTaskNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    tags: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageConfig: {
+        description: string;
+        shortFlag: string;
+    };
+    id: {
+        description: string;
+        shortFlag: string;
+        required: true;
+    };
+    outPath: {
+        description: string;
+        required: true;
+    };
+};
+export type ExportActionOptions = InferOptions<typeof exportActionOptions> & {
+    verbose?: boolean;
+};
+type Context = {
+    snapshots: {
+        id: string;
+        packages: number;
+    };
+    task: {
+        taskName: string;
+        packageName: string;
+    };
+    export: ExtendedSnapshot;
+};
+export declare class ExportAction {
+    readonly config: Config;
+    readonly options: ExportActionOptions;
+    readonly settings: {
+        tty?: "auto" | boolean;
+        progress?: ProgressMode;
+        streams?: StdStreams;
+    };
+    constructor(config: Config, options: ExportActionOptions, settings: {
+        tty?: "auto" | boolean;
+        progress?: ProgressMode;
+        streams?: StdStreams;
+    });
+    protected restore(data: {
+        pkg: {
+            name: string;
+        };
+        snapshotPath: string;
+        snapshot: ExtendedSnapshot;
+        onProgress: (progress: Progress) => void;
+    }): Promise<void>;
+    dataFormat(result: Listr3TaskResultEnd<Context>[], options?: {
+        streams?: StdStreams;
+        verbose?: number;
+        errors?: Error[];
+    }): DataFormat;
+    exec(): Promise<{
+        result: (import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<Context>)[];
+        exitCode: number;
+        errors: Error[];
+    }>;
+}
+export {};

package/lib/actions/ExportAction.js

@@ -0,0 +1,236 @@
+"use strict";
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        function next() {
+            while (env.stack.length) {
+                var rec = env.stack.pop();
+                try {
+                    var result = rec.dispose && rec.dispose.call(rec.value);
+                    if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExportAction = exports.exportActionOptions = void 0;
+const DatatruckRepository_1 = require("../repositories/DatatruckRepository");
+const cli_1 = require("../utils/cli");
+const data_format_1 = require("../utils/data-format");
+const config_1 = require("../utils/datatruck/config");
+const repository_1 = require("../utils/datatruck/repository");
+const date_1 = require("../utils/date");
+const error_1 = require("../utils/error");
+const list_1 = require("../utils/list");
+const object_1 = require("../utils/object");
+const progress_1 = require("../utils/progress");
+const temp_1 = require("../utils/temp");
+const SnapshotsAction_1 = require("./SnapshotsAction");
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = require("path");
+exports.exportActionOptions = {
+    id: {
+        description: "Filter by snapshot id",
+        shortFlag: "i",
+        required: true,
+    },
+    outPath: {
+        description: "Out path",
+        required: true,
+    },
+    ...(0, object_1.pickProps)(SnapshotsAction_1.snapshotsActionOptions, {
+        tags: true,
+        packageNames: true,
+        packageTaskNames: true,
+        packageConfig: true,
+        repositoryNames: true,
+        repositoryTypes: true,
+    }),
+};
+class ExportAction {
+    config;
+    options;
+    settings;
+    constructor(config, options, settings) {
+        this.config = config;
+        this.options = options;
+        this.settings = settings;
+    }
+    async restore(data) {
+        let { snapshot, snapshotPath, pkg } = data;
+        await (0, repository_1.initSnapshotPath)(snapshotPath, this.config.minFreeDiskSpace);
+        const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
+        const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
+        await repo.restore({
+            options: this.options,
+            snapshot: data.snapshot,
+            package: pkg,
+            snapshotPath: snapshotPath,
+            packageConfig: undefined,
+            onProgress: data.onProgress,
+        });
+    }
+    dataFormat(result, options = {}) {
+        const renderTitle = (item, color) => {
+            let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
+            return item.key === "export" && color ? chalk_1.default.cyan(title) : title;
+        };
+        const renderData = (item, color, result = []) => {
+            const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
+            return (0, cli_1.renderListTaskItem)(item, color, {
+                snapshots: (data) => [
+                    data.id.slice(0, 8),
+                    g(`${data.packages} packages`),
+                ],
+                task: (data) => [data.packageName, g(data.taskName)],
+                export: (data) => [data.packageName, g(data.repositoryName)],
+                summary: (data) => ({
+                    errors: data.errors,
+                    exports: result.filter((r) => !r.error && r.key === "export").length,
+                }),
+            });
+        };
+        return new data_format_1.DataFormat({
+            streams: options.streams,
+            json: result,
+            table: {
+                headers: [
+                    { value: "", width: 3 },
+                    { value: "Title", width: 15 },
+                    { value: "Data" },
+                    { value: "Duration", width: 10 },
+                    { value: "Error", width: 50 },
+                ],
+                rows: () => result.map((item) => [
+                    (0, cli_1.renderResult)(item.error),
+                    renderTitle(item, true),
+                    renderData(item, true, result),
+                    (0, date_1.duration)(item.elapsed),
+                    (0, cli_1.renderError)(item.error, options.errors?.indexOf(item.error)),
+                ]),
+            },
+        });
+    }
+    async exec() {
+        const { options, settings } = this;
+        const gc = new temp_1.GargabeCollector();
+        const pm = new progress_1.ProgressManager({
+            verbose: options.verbose,
+            tty: settings.tty,
+            mode: settings.progress,
+        });
+        const l = new list_1.Listr3({
+            streams: settings.streams,
+            progressManager: pm,
+            gargabeCollector: gc,
+        });
+        return l
+            .add(l.$task({
+            key: "snapshots",
+            data: {
+                id: "",
+                packages: 0,
+            },
+            title: {
+                initial: "Fetch snapshots",
+                started: "Fetching snapshots",
+                completed: "Snapshots fetched",
+                failed: "Snapshot fetch failed",
+            },
+            run: async (_, data) => {
+                const { minFreeDiskSpace } = this.config;
+                if (minFreeDiskSpace)
+                    await (0, temp_1.ensureFreeDiskTempSpace)(minFreeDiskSpace);
+                if (!options.id)
+                    throw new error_1.AppError("Snapshot id is required");
+                const snapshots = await new SnapshotsAction_1.SnapshotsAction(this.config, {
+                    ids: [this.options.id],
+                    repositoryNames: this.options.repositoryNames,
+                    repositoryTypes: this.options.repositoryTypes,
+                    packageNames: this.options.packageNames,
+                    packageTaskNames: this.options.packageTaskNames,
+                    packageConfig: this.options.packageConfig,
+                    tags: this.options.tags,
+                    groupBy: ["packageName"],
+                }).exec("restore");
+                if (!snapshots.length)
+                    throw new error_1.AppError("None snapshot found");
+                data.id = options.id;
+                data.packages = snapshots.length;
+                return snapshots.map((snapshot) => l.$task({
+                    key: "export",
+                    keyIndex: snapshot.packageName,
+                    data: snapshot,
+                    title: {
+                        initial: `Export snapshot: ${snapshot.packageName} (${snapshot.repositoryName})`,
+                        started: `Restoring snapshot: ${snapshot.packageName} (${snapshot.repositoryName})`,
+                        completed: `Snapshot exported: ${snapshot.packageName} (${snapshot.repositoryName})`,
+                        failed: `Snapshot export failed: ${snapshot.packageName} (${snapshot.repositoryName})`,
+                    },
+                    exitOnError: false,
+                    run: async (listTask) => {
+                        const env_1 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            const progress = __addDisposableResource(env_1, pm.create(listTask), false);
+                            const _ = __addDisposableResource(env_1, gc.create().disposeOnFinish(), true);
+                            await this.restore({
+                                pkg: { name: snapshot.packageName },
+                                snapshotPath: (0, path_1.join)(this.options.outPath, snapshot.repositoryName, DatatruckRepository_1.DatatruckRepository.createSnapshotName(snapshot, {
+                                    name: snapshot.packageName,
+                                })),
+                                snapshot: snapshot,
+                                onProgress: progress.update,
+                            });
+                        }
+                        catch (e_1) {
+                            env_1.error = e_1;
+                            env_1.hasError = true;
+                        }
+                        finally {
+                            const result_1 = __disposeResources(env_1);
+                            if (result_1)
+                                await result_1;
+                        }
+                    },
+                }));
+            },
+        }))
+            .execAndParse(this.options.verbose);
+    }
+}
+exports.ExportAction = ExportAction;

package/lib/actions/InitAction.d.ts

@@ -1,14 +1,24 @@
 import type { Config } from "../utils/datatruck/config-type";
-import { IfRequireKeys } from "../utils/ts";
-export type InitActionOptions = {
-    repositoryNames?: string[];
-    repositoryTypes?: string[];
+import { InferOptions } from "../utils/options";
+export declare const initActionOptions: {
+    repositoryNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    repositoryTypes: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+};
+export type InitActionOptions = InferOptions<typeof initActionOptions> & {
     verbose?: boolean;
 };
-export declare class InitAction<TRequired extends boolean = true> {
+export declare class InitAction {
     readonly config: Config;
-    readonly options: IfRequireKeys<TRequired, InitActionOptions>;
-    constructor(config: Config, options: IfRequireKeys<TRequired, InitActionOptions>);
+    readonly options: InitActionOptions;
+    constructor(config: Config, options: InitActionOptions);
     exec(): Promise<{
         repositoryName: string;
         repositoryType: string;

package/lib/actions/InitAction.js

@@ -1,9 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.InitAction = void 0;
+exports.InitAction = exports.initActionOptions = void 0;
 const config_1 = require("../utils/datatruck/config");
 const repository_1 = require("../utils/datatruck/repository");
+const object_1 = require("../utils/object");
 const string_1 = require("../utils/string");
+const SnapshotsAction_1 = require("./SnapshotsAction");
+exports.initActionOptions = {
+    ...(0, object_1.pickProps)(SnapshotsAction_1.snapshotsActionOptions, {
+        repositoryNames: true,
+        repositoryTypes: true,
+    }),
+};
 class InitAction {
     config;
     options;

package/lib/actions/PruneAction.d.ts

@@ -1,18 +1,77 @@
-import type { Config, RepositoryConfig } from "../utils/datatruck/config-type";
-import { KeepObject } from "../utils/date";
-import { IfRequireKeys } from "../utils/ts";
-import { ExtendedSnapshot, SnapshotsActionOptions } from "./SnapshotsAction";
-export type PruneActionsOptions = KeepObject & {
-    ids?: string[];
-    packageNames?: string[];
-    repositoryNames?: string[];
-    repositoryTypes?: RepositoryConfig["type"][];
-    tags?: string[];
+import type { Config } from "../utils/datatruck/config-type";
+import { InferOptions } from "../utils/options";
+import { ExtendedSnapshot } from "./SnapshotsAction";
+export declare const pruneActionOptions: {
+    groupBy: {
+        description: string;
+        shortFlag: string;
+        defaults: string;
+        value: (v: string) => ("packageName" | "repositoryName" | "repositoryType")[];
+    };
+    dryRun: {
+        description: string;
+        value: "boolean";
+    };
+    showAll: {
+        description: string;
+        shortFlag: string;
+    };
+    keepMinutely: {
+        description: string;
+        value: "number";
+    };
+    keepDaily: {
+        description: string;
+        value: "number";
+    };
+    keepHourly: {
+        description: string;
+        value: "number";
+    };
+    keepLast: {
+        description: string;
+        value: "number";
+    };
+    keepMonthly: {
+        description: string;
+        value: "number";
+    };
+    keepWeekly: {
+        description: string;
+        value: "number";
+    };
+    keepYearly: {
+        description: string;
+        value: "number";
+    };
+    repositoryNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    repositoryTypes: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    tags: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    ids: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+};
+export type PruneActionsOptions = InferOptions<typeof pruneActionOptions> & {
     verbose?: boolean;
-    groupBy?: SnapshotsActionOptions["groupBy"];
-    dryRun?: boolean;
-    longId?: boolean;
-    returnsAll?: boolean;
 };
 export type PruneResult = {
     total: number;
@@ -21,10 +80,10 @@ export type PruneResult = {
         exclusionReasons: string[];
     })[];
 };
-export declare class PruneAction<TRequired extends boolean = true> {
+export declare class PruneAction {
     readonly config: Config;
-    readonly options: IfRequireKeys<TRequired, PruneActionsOptions>;
-    constructor(config: Config, options: IfRequireKeys<TRequired, PruneActionsOptions>);
+    readonly options: PruneActionsOptions;
+    constructor(config: Config, options: PruneActionsOptions);
     confirm(snapshots: PruneResult["snapshots"]): Promise<void>;
     exec(): Promise<PruneResult>;
 }

package/lib/actions/PruneAction.js

@@ -1,12 +1,72 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PruneAction = void 0;
+exports.PruneAction = exports.pruneActionOptions = void 0;
 const repository_1 = require("../utils/datatruck/repository");
 const snapshot_1 = require("../utils/datatruck/snapshot");
 const date_1 = require("../utils/date");
 const error_1 = require("../utils/error");
 const object_1 = require("../utils/object");
+const string_1 = require("../utils/string");
 const SnapshotsAction_1 = require("./SnapshotsAction");
+exports.pruneActionOptions = {
+    ids: {
+        description: "Filter by snapshot id",
+        shortFlag: "i",
+        value: "array",
+    },
+    ...(0, object_1.pickProps)(SnapshotsAction_1.snapshotsActionOptions, {
+        packageNames: true,
+        repositoryNames: true,
+        repositoryTypes: true,
+        tags: true,
+    }),
+    groupBy: {
+        description: "Group by values (packageName, repositoryName, repositoryType)",
+        shortFlag: "g",
+        defaults: "packageName,repositoryName",
+        value: (v) => (0, string_1.parseStringList)(v, [
+            "packageName",
+            "repositoryName",
+            "repositoryType",
+        ]),
+    },
+    dryRun: {
+        description: "",
+        value: "boolean",
+    },
+    showAll: {
+        description: "Show all",
+        shortFlag: "a",
+    },
+    keepMinutely: {
+        description: "Keep last N minutely snapshots",
+        value: "number",
+    },
+    keepDaily: {
+        description: "Keep last N daily snapshots",
+        value: "number",
+    },
+    keepHourly: {
+        description: "Keep last N hourly snapshots",
+        value: "number",
+    },
+    keepLast: {
+        description: "Keep last N snapshots",
+        value: "number",
+    },
+    keepMonthly: {
+        description: "Keep last N monthly snapshots",
+        value: "number",
+    },
+    keepWeekly: {
+        description: "Keep last N weekly snapshots",
+        value: "number",
+    },
+    keepYearly: {
+        description: "Keep last N yearly snapshots",
+        value: "number",
+    },
+};
 class PruneAction {
     config;
     options;
@@ -71,7 +131,7 @@ class PruneAction {
             const prune = !keepSnapshot;
             if (prune)
                 result.prune++;
-            if (prune || this.options.returnsAll)
+            if (prune || this.options.showAll)
                 snapshotsDeleted.push({
                     ...snapshot,
                     exclusionReasons: keepSnapshot?.reasons || [],

package/lib/actions/RestoreAction.d.ts

@@ -3,22 +3,51 @@ import { TaskAbstract } from "../tasks/TaskAbstract";
 import { DataFormat } from "../utils/data-format";
 import type { Config, PackageConfig } from "../utils/datatruck/config-type";
 import { Listr3TaskResultEnd } from "../utils/list";
+import { InferOptions } from "../utils/options";
 import { Progress, ProgressMode } from "../utils/progress";
 import { StdStreams } from "../utils/stream";
-import { IfRequireKeys } from "../utils/ts";
-export type RestoreActionOptions = {
-    snapshotId: string;
-    tags?: string[];
-    packageNames?: string[];
-    packageTaskNames?: string[];
-    packageConfig?: boolean;
-    repositoryNames?: string[];
-    repositoryTypes?: string[];
+export declare const restoreActionOptions: {
+    initial: {
+        description: string;
+        value: "boolean";
+    };
+    repositoryNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    repositoryTypes: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageTaskNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    tags: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageConfig: {
+        description: string;
+        shortFlag: string;
+    };
+    id: {
+        description: string;
+        shortFlag: string;
+        required: true;
+    };
+};
+export type RestoreActionOptions = InferOptions<typeof restoreActionOptions> & {
     verbose?: boolean;
-    initial?: boolean;
-    tty?: "auto" | boolean;
-    progress?: ProgressMode;
-    streams?: StdStreams;
 };
 type RestoreSnapshot = Snapshot & {
     repositoryName: string;
@@ -34,21 +63,26 @@ type Context = {
     };
     restore: RestoreSnapshot;
 };
-export declare class RestoreAction<TRequired extends boolean = true> {
+export declare class RestoreAction {
     readonly config: Config;
-    readonly options: IfRequireKeys<TRequired, RestoreActionOptions>;
-    protected taskErrors: Record<string, Error[]>;
-    protected repoErrors: Record<string, Error[]>;
-    constructor(config: Config, options: IfRequireKeys<TRequired, RestoreActionOptions>);
-    protected findSnapshots(): Promise<RestoreSnapshot[]>;
-    protected groupSnapshots(snapshots: RestoreSnapshot[]): RestoreSnapshot[];
+    readonly options: RestoreActionOptions;
+    readonly settings: {
+        tty?: "auto" | boolean;
+        progress?: ProgressMode;
+        streams?: StdStreams;
+    };
+    constructor(config: Config, options: RestoreActionOptions, settings: {
+        tty?: "auto" | boolean;
+        progress?: ProgressMode;
+        streams?: StdStreams;
+    });
     protected restore(data: {
         pkg: PackageConfig;
         task: TaskAbstract | undefined;
         snapshot: RestoreSnapshot;
         onProgress: (progress: Progress) => void;
     }): Promise<{
-        snapshotPath: string | undefined;
+        snapshotPath: string;
     }>;
     dataFormat(result: Listr3TaskResultEnd<Context>[], options?: {
         streams?: StdStreams;