@datatruck/cli 0.37.0 → 0.38.1

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,
@@ -182,15 +160,15 @@ class RestoreAction {
         });
     }
     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",
                             });

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>;

package/lib/cli.js

@@ -1,32 +1,9 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.exec = exports.parseArgs = exports.buildArgs = void 0;
+exports.parseArgs = void 0;
 const ConfigAction_1 = require("./actions/ConfigAction");
 const globalData_1 = __importDefault(require("./globalData"));
 const cli_1 = require("./utils/cli");
@@ -34,9 +11,9 @@ const command_1 = require("./utils/datatruck/command");
 const error_1 = require("./utils/error");
 const exit_1 = require("./utils/exit");
 const fs_1 = require("./utils/fs");
-const string_1 = require("./utils/string");
+const options_1 = require("./utils/options");
 const temp_1 = require("./utils/temp");
-const chalk_1 = __importStar(require("chalk"));
+const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const fs_2 = require("fs");
 const path_1 = require("path");
@@ -49,46 +26,7 @@ function getGlobalOptions() {
         progress: parseBool(result.progress),
     };
 }
-function makeCommand(command) {
-    const instance = (0, command_1.createCommand)(command, getGlobalOptions(), null);
-    const options = instance.optionsConfig();
-    const inlineOptions = [];
-    for (const name in options) {
-        const option = options[name];
-        if (typeof option.option !== "string") {
-            inlineOptions.push({ name, required: option.required });
-        }
-    }
-    const programCommand = program.command([
-        command,
-        ...inlineOptions.map((v) => (v.required ? `<${v.name}>` : `[${v.name}]`)),
-    ].join(" "));
-    for (const key in options) {
-        const option = options[key];
-        if (typeof option.option === "string") {
-            const description = `${option.description}${option.defaults ? ` (defaults: ${option.defaults})` : ""}`;
-            if (option.required) {
-                programCommand.requiredOption(option.option, description);
-            }
-            else {
-                programCommand.option(option.option, description);
-            }
-        }
-    }
-    return programCommand.action(async (...args) => {
-        const inlineValues = args.slice(0, inlineOptions.length);
-        const action = makeCommandAction(command);
-        const inOptions = args[inlineOptions.length] || {};
-        const options = inlineOptions.reduce((result, inlineOption, index) => {
-            const value = inlineValues[index];
-            if (value !== undefined)
-                result[inlineOption.name] = value;
-            return result;
-        }, inOptions);
-        return await action(options);
-    });
-}
-function makeCommandAction(commandName) {
+function createCommandAction(Constructor) {
     return async function (options) {
         let exitCode = 1;
         let error;
@@ -100,7 +38,7 @@ function makeCommandAction(commandName) {
                 globalData_1.default.tempDir = (0, path_1.isAbsolute)(config.data.tempDir)
                     ? config.data.tempDir
                     : (0, path_1.join)((0, path_1.dirname)(config.path), config.data.tempDir);
-            const command = (0, command_1.createCommand)(commandName, { ...globalOptions }, options, {}, globalOptions.config);
+            const command = new Constructor({ ...globalOptions }, options, {}, globalOptions.config);
             const response = await command.exec();
             errors = response.errors;
             exitCode = response.exitCode;
@@ -118,18 +56,18 @@ function makeCommandAction(commandName) {
         }
         if (error) {
             if (globalOptions.verbose) {
-                console.error((0, chalk_1.red)(error.stack));
+                console.error(chalk_1.default.red(error.stack));
             }
             else {
                 if (error instanceof error_1.AppError) {
-                    console.error((0, chalk_1.red)(error.message));
+                    console.error(chalk_1.default.red(error.message));
                 }
                 else {
-                    console.error((0, chalk_1.red)(error.stack));
+                    console.error(chalk_1.default.red(error.stack));
                 }
             }
         }
-        await (0, cli_1.waitForStdDrain)(5000);
+        await (0, cli_1.waitForStdDrain)(5_000);
         process.exit(exitCode);
     };
 }
@@ -145,24 +83,12 @@ program.option("-c,--config <path>", "Config path", process.env["DATATRUCK_CONFI
 program.option("--tty <value>", "TTY mode (auto, true, false)", "auto");
 program.option("--progress <value>", "Progress type (auto, true, false, interval, interval:[ms])", "auto");
 program.option("-o,--output-format <format>", "Output format (json, pjson, yaml, table, custom=$, tpl=name)", "table");
-makeCommand("startServer").alias("start");
-makeCommand("config").alias("c");
-makeCommand("init").alias("i");
-makeCommand("snapshots").alias("s");
-makeCommand("prune").alias("p");
-makeCommand("backup").alias("b");
-makeCommand("restore").alias("r");
-makeCommand("run");
-makeCommand("copy").alias("cp");
-makeCommand("cleanCache").alias("cc");
-function buildArgs(input, options) {
-    const optionsArray = Object.keys(options).flatMap((name) => [
-        `--${(0, string_1.snakeCase)(name, "-")}`,
-        options[name],
-    ]);
-    return [input, ...optionsArray];
+const Commands = Object.values(command_1.datatruckCommands)
+    .map((Command) => ({ Command, config: Command.config() }))
+    .sort((a, b) => a.config.name.localeCompare(b.config.name));
+for (const { Command, config } of Commands) {
+    program.addCommand((0, options_1.createCommand)(config, createCommandAction(Command)));
 }
-exports.buildArgs = buildArgs;
 function parseArgs(args) {
     program.parse(args);
     const verbose = getGlobalOptions().verbose;
@@ -187,8 +113,3 @@ function parseArgs(args) {
     });
 }
 exports.parseArgs = parseArgs;
-async function exec(input, options) {
-    const argv = buildArgs(input, options);
-    return parseArgs(argv);
-}
-exports.exec = exec;

package/lib/commands/BackupCommand.d.ts

@@ -1,18 +1,125 @@
-import type { RepositoryConfig } from "../utils/datatruck/config-type";
-import { If } from "../utils/ts";
+import { InferOptions } from "../utils/options";
 import { CommandAbstract } from "./CommandAbstract";
-export type BackupCommandOptions<TResolved = false> = {
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
-    tag?: If<TResolved, string[]>;
-    dryRun?: boolean;
-    date?: string;
-    prune?: boolean;
+export declare const backupCommandOptions: {
+    dryRun: {
+        description: string;
+        value: "boolean";
+    };
+    date: {
+        description: string;
+    };
+    prune: {
+        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";
+    };
 };
-export declare class BackupCommand extends CommandAbstract<BackupCommandOptions<false>, BackupCommandOptions<true>> {
-    optionsConfig(): import("../utils/cli").OptionsConfig<BackupCommandOptions<false>, BackupCommandOptions<true>>;
+export type BackupCommandOptions = InferOptions<typeof backupCommandOptions>;
+export declare class BackupCommand extends CommandAbstract<typeof backupCommandOptions> {
+    static config(): {
+        name: string;
+        alias: string;
+        options: {
+            dryRun: {
+                description: string;
+                value: "boolean";
+            };
+            date: {
+                description: string;
+            };
+            prune: {
+                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";
+            };
+        };
+    };
+    get optionsConfig(): {
+        dryRun: {
+            description: string;
+            value: "boolean";
+        };
+        date: {
+            description: string;
+        };
+        prune: {
+            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";
+        };
+    };
     exec(): Promise<{
         result: (import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<{
             snapshot: {