@datatruck/cli 0.36.8 → 0.38.0

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,26 +63,36 @@ 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;
         verbose?: number;
+        errors?: Error[];
     }): DataFormat;
-    exec(): Promise<(import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<Context>)[]>;
+    exec(): Promise<{
+        result: (import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<Context>)[];
+        exitCode: number;
+        errors: Error[];
+    }>;
 }
 export {};

package/lib/actions/RestoreAction.js

@@ -48,7 +48,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestoreAction = void 0;
+exports.RestoreAction = exports.restoreActionOptions = void 0;
 const cli_1 = require("../utils/cli");
 const data_format_1 = require("../utils/data-format");
 const config_1 = require("../utils/datatruck/config");
@@ -56,61 +56,40 @@ const repository_1 = require("../utils/datatruck/repository");
 const task_1 = require("../utils/datatruck/task");
 const date_1 = require("../utils/date");
 const error_1 = require("../utils/error");
-const fs_1 = require("../utils/fs");
 const list_1 = require("../utils/list");
+const object_1 = require("../utils/object");
 const progress_1 = require("../utils/progress");
-const string_1 = require("../utils/string");
 const temp_1 = require("../utils/temp");
 const SnapshotsAction_1 = require("./SnapshotsAction");
 const assert_1 = require("assert");
 const chalk_1 = __importDefault(require("chalk"));
+exports.restoreActionOptions = {
+    id: {
+        description: "Filter by snapshot id",
+        shortFlag: "i",
+        required: true,
+    },
+    ...(0, object_1.pickProps)(SnapshotsAction_1.snapshotsActionOptions, {
+        tags: true,
+        packageNames: true,
+        packageTaskNames: true,
+        packageConfig: true,
+        repositoryNames: true,
+        repositoryTypes: true,
+    }),
+    initial: {
+        description: "Initial restoring (disables restore path)",
+        value: "boolean",
+    },
+};
 class RestoreAction {
     config;
     options;
-    taskErrors = {};
-    repoErrors = {};
-    constructor(config, options) {
+    settings;
+    constructor(config, options, settings) {
         this.config = config;
         this.options = options;
-    }
-    async findSnapshots() {
-        const result = [];
-        const filterRepo = (0, string_1.createPatternFilter)(this.options.repositoryNames);
-        const filterRepoType = (0, string_1.createPatternFilter)(this.options.repositoryTypes);
-        for (const repository of this.config.repositories) {
-            if (!filterRepo(repository.name))
-                continue;
-            if (!filterRepoType(repository.type))
-                continue;
-            const snapshotsAction = new SnapshotsAction_1.SnapshotsAction(this.config, {
-                repositoryNames: [repository.name],
-                ids: [this.options.snapshotId],
-                packageNames: this.options.packageNames,
-                packageTaskNames: this.options.packageTaskNames,
-                packageConfig: this.options.packageConfig,
-                tags: this.options.tags,
-            });
-            const snapshots = await snapshotsAction.exec("restore");
-            result.push(...snapshots.map((ss) => ({
-                date: ss.date,
-                id: ss.id,
-                originalId: ss.originalId,
-                packageName: ss.packageName,
-                packageTaskName: ss.packageTaskName,
-                tags: ss.tags,
-                repositoryName: repository.name,
-            })));
-        }
-        return result;
-    }
-    groupSnapshots(snapshots) {
-        const names = [];
-        return snapshots.filter((snapshot) => {
-            if (names.includes(snapshot.packageName))
-                return false;
-            names.push(snapshot.packageName);
-            return true;
-        });
+        this.settings = settings;
     }
     async restore(data) {
         let { snapshot, pkg, task } = data;
@@ -125,9 +104,8 @@ class RestoreAction {
             });
             snapshotPath = taskResult?.snapshotPath;
         }
-        await (0, fs_1.initEmptyDir)(snapshotPath);
-        if (this.config.minFreeDiskSpace)
-            await (0, fs_1.ensureFreeDiskSpace)([snapshotPath], this.config.minFreeDiskSpace);
+        (0, assert_1.ok)(snapshotPath);
+        await (0, repository_1.initSnapshotPath)(snapshotPath, this.config.minFreeDiskSpace);
         await repo.restore({
             options: this.options,
             snapshot: data.snapshot,
@@ -176,21 +154,21 @@ class RestoreAction {
                     renderTitle(item, true),
                     renderData(item, true, result),
                     (0, date_1.duration)(item.elapsed),
-                    (0, cli_1.renderError)(item.error, options.verbose),
+                    (0, cli_1.renderError)(item.error, options.errors?.indexOf(item.error)),
                 ]),
             },
         });
     }
     async exec() {
-        const { options } = this;
+        const { options, settings } = this;
         const gc = new temp_1.GargabeCollector();
         const pm = new progress_1.ProgressManager({
             verbose: options.verbose,
-            tty: options.tty,
-            mode: options.progress,
+            tty: settings.tty,
+            mode: settings.progress,
         });
         const l = new list_1.Listr3({
-            streams: options.streams,
+            streams: settings.streams,
             progressManager: pm,
             gargabeCollector: gc,
         });
@@ -211,12 +189,22 @@ class RestoreAction {
                 const { minFreeDiskSpace } = this.config;
                 if (minFreeDiskSpace)
                     await (0, temp_1.ensureFreeDiskTempSpace)(minFreeDiskSpace);
-                if (!options.snapshotId)
+                if (!options.id)
                     throw new error_1.AppError("Snapshot id is required");
-                const snapshots = this.groupSnapshots(await this.findSnapshots());
+                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"],
+                    last: 1,
+                }).exec("restore");
                 if (!snapshots.length)
                     throw new error_1.AppError("None snapshot found");
-                data.id = options.snapshotId;
+                data.id = options.id;
                 data.packages = snapshots.length;
                 return snapshots.map((snapshot) => l.$task({
                     key: "restore",
@@ -233,7 +221,7 @@ class RestoreAction {
                         const env_1 = { stack: [], error: void 0, hasError: false };
                         try {
                             let pkg = (0, config_1.resolvePackage)((0, config_1.findPackageOrFail)(this.config, snapshot.packageName), {
-                                snapshotId: options.snapshotId,
+                                snapshotId: options.id,
                                 snapshotDate: snapshot.date,
                                 action: "restore",
                             });
@@ -299,7 +287,7 @@ class RestoreAction {
                 }));
             },
         }))
-            .exec();
+            .execAndParse(this.options.verbose);
     }
 }
 exports.RestoreAction = RestoreAction;

package/lib/actions/SnapshotsAction.d.ts

@@ -1,34 +1,93 @@
 import { Snapshot } from "../repositories/RepositoryAbstract";
 import type { Config, RepositoryConfigEnabledAction } from "../utils/datatruck/config-type";
-import { IfRequireKeys } from "../utils/ts";
+import { InferOptions } from "../utils/options";
 export type SnapshotGroupByType = keyof Pick<ExtendedSnapshot, "packageName" | "repositoryName" | "repositoryType">;
-export type SnapshotsActionOptions = {
-    ids?: string[];
-    hostnames?: string[];
-    repositoryNames?: string[];
-    packageNames?: string[];
-    packageTaskNames?: string[];
-    packageConfig?: boolean;
-    repositoryTypes?: string[];
+export declare const snapshotsActionOptions: {
+    ids: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    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;
+    };
+    hostnames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    groupBy: {
+        description: string;
+        shortFlag: string;
+        value: (v: string) => ("packageName" | "repositoryName" | "repositoryType" | "id")[];
+    };
+    last: {
+        description: string;
+        shortFlag: string;
+        value: "number";
+    };
+    lastMinutely: {
+        description: string;
+        value: "number";
+    };
+    lastDaily: {
+        description: string;
+        value: "number";
+    };
+    lastHourly: {
+        description: string;
+        value: "number";
+    };
+    lastMonthly: {
+        description: string;
+        value: "number";
+    };
+    lastWeekly: {
+        description: string;
+        value: "number";
+    };
+    lastYearly: {
+        description: string;
+        value: "number";
+    };
+};
+export type SnapshotsActionOptions = InferOptions<typeof snapshotsActionOptions> & {
     verbose?: boolean;
-    tags?: string[];
-    last?: number;
-    lastMinutely?: number;
-    lastHourly?: number;
-    lastDaily?: number;
-    lastWeekly?: number;
-    lastMonthly?: number;
-    lastYearly?: number;
-    groupBy?: SnapshotGroupByType[];
 };
 export type ExtendedSnapshot = {
     shortId: string;
     repositoryName: string;
     repositoryType: string;
 } & Snapshot;
-export declare class SnapshotsAction<TRequired extends boolean = true> {
+export declare class SnapshotsAction {
     readonly config: Config;
-    readonly options: IfRequireKeys<TRequired, SnapshotsActionOptions>;
-    constructor(config: Config, options: IfRequireKeys<TRequired, SnapshotsActionOptions>);
+    readonly options: SnapshotsActionOptions;
+    constructor(config: Config, options: SnapshotsActionOptions);
     exec(sourceAction?: RepositoryConfigEnabledAction): Promise<ExtendedSnapshot[]>;
 }

package/lib/actions/SnapshotsAction.js

@@ -1,10 +1,91 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnapshotsAction = void 0;
+exports.SnapshotsAction = exports.snapshotsActionOptions = void 0;
 const config_1 = require("../utils/datatruck/config");
 const repository_1 = require("../utils/datatruck/repository");
 const snapshot_1 = require("../utils/datatruck/snapshot");
 const string_1 = require("../utils/string");
+const groupByValues = [
+    "id",
+    "packageName",
+    "repositoryName",
+    "repositoryType",
+];
+exports.snapshotsActionOptions = {
+    ids: {
+        description: "Filter by identifiers",
+        shortFlag: "i",
+        value: "array",
+    },
+    repositoryNames: {
+        description: "Filter by repository names",
+        shortFlag: "r",
+        value: "array",
+    },
+    repositoryTypes: {
+        description: "Filter by repository types",
+        shortFlag: "rt",
+        value: "array",
+    },
+    packageNames: {
+        description: "Filter by package names",
+        shortFlag: "p",
+        value: "array",
+    },
+    packageTaskNames: {
+        description: "Filter by task names",
+        shortFlag: "pt",
+        value: "array",
+    },
+    tags: {
+        description: "Filter by tags",
+        shortFlag: "t",
+        value: "array",
+    },
+    packageConfig: {
+        description: "Filter by package config",
+        shortFlag: "pc",
+    },
+    hostnames: {
+        description: "Filter by hostnames",
+        shortFlag: "h",
+        value: "array",
+    },
+    groupBy: {
+        description: `Group by values (${groupByValues.join(", ")})`,
+        shortFlag: "g",
+        value: (v) => (0, string_1.parseStringList)(v, groupByValues),
+    },
+    last: {
+        description: "Filter by last snapshots",
+        shortFlag: "l",
+        value: "number",
+    },
+    lastMinutely: {
+        description: "Filter by last minutely",
+        value: "number",
+    },
+    lastDaily: {
+        description: "Filter by last daily",
+        value: "number",
+    },
+    lastHourly: {
+        description: "Filter by last hourly",
+        value: "number",
+    },
+    lastMonthly: {
+        description: "Filter by last monthly",
+        value: "number",
+    },
+    lastWeekly: {
+        description: "Filter by last weekly",
+        value: "number",
+    },
+    lastYearly: {
+        description: "Filter by last yearly",
+        value: "number",
+    },
+};
 class SnapshotsAction {
     config;
     options;

package/lib/cli.d.ts

@@ -1,4 +1 @@
-import { DatatruckCommandMap, InferDatatruckCommandOptions } from "./utils/datatruck/command";
-export declare function buildArgs<T extends keyof DatatruckCommandMap>(input: T, options: InferDatatruckCommandOptions<T>): any[];
 export declare function parseArgs(args: string[]): void;
-export declare function exec<T extends keyof DatatruckCommandMap>(input: T, options: InferDatatruckCommandOptions<T>): Promise<void>;