@datatruck/cli 0.36.8 → 0.38.0

package/lib/cli.js

@@ -3,7 +3,7 @@ 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");
@@ -11,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 = require("chalk");
+const chalk_1 = __importDefault(require("chalk"));
 const commander_1 = require("commander");
 const fs_2 = require("fs");
 const path_1 = require("path");
@@ -26,57 +26,48 @@ function getGlobalOptions() {
         progress: parseBool(result.progress),
     };
 }
-function makeCommand(command) {
-    const programCommand = program.command(command);
-    const instance = (0, command_1.createCommand)(command, getGlobalOptions(), null);
-    const options = instance.optionsConfig();
-    for (const key in options) {
-        const option = options[key];
-        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(makeCommandAction(command));
-}
-function makeCommandAction(command) {
+function createCommandAction(Constructor) {
     return async function (options) {
         let exitCode = 1;
+        let error;
+        let errors;
         const globalOptions = getGlobalOptions();
         try {
-            const configAction = new ConfigAction_1.ConfigAction({
-                path: globalOptions.config,
-                verbose: !!globalOptions.verbose,
-            });
-            const config = await configAction.exec();
+            const config = await ConfigAction_1.ConfigAction.fromGlobalOptionsWithPath(globalOptions);
             if (config.data.tempDir)
                 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 response = await (0, command_1.createCommand)(command, {
-                ...globalOptions,
-                config: config.data,
-            }, options, {}, globalOptions.config).exec();
+            const command = new Constructor({ ...globalOptions }, options, {}, globalOptions.config);
+            const response = await command.exec();
+            errors = response.errors;
             exitCode = response.exitCode;
         }
         catch (e) {
-            const error = e;
+            error = e;
+        }
+        if (errors?.length) {
+            console.error();
+            errors.forEach((error, index) => {
+                console.error(chalk_1.default.red(`${index + 1}. ` + error.stack ?? error.message));
+                if (errors[index + 1])
+                    console.error();
+            });
+        }
+        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);
     };
 }
@@ -92,23 +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("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;
@@ -117,7 +97,7 @@ function parseArgs(args) {
             process.stdout.write(cli_1.showCursorCommand);
             console.info(`\nClosing... (reason: ${eventName})`);
             if (error instanceof Error)
-                console.error((0, chalk_1.red)(error.stack));
+                console.error(error.stack);
         }
         if (!verbose)
             try {
@@ -133,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: {
@@ -41,5 +148,6 @@ export declare class BackupCommand extends CommandAbstract<BackupCommandOptions<
             };
         } & import("../utils/datatruck/report-list").ReportListTaskContext>)[];
         exitCode: number;
+        errors: Error[];
     }>;
 }

package/lib/commands/BackupCommand.js

@@ -1,76 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BackupCommand = void 0;
+exports.BackupCommand = exports.backupCommandOptions = void 0;
 const BackupAction_1 = require("../actions/BackupAction");
 const ConfigAction_1 = require("../actions/ConfigAction");
-const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
+exports.backupCommandOptions = {
+    ...BackupAction_1.backupActionOptions,
+};
 class BackupCommand extends CommandAbstract_1.CommandAbstract {
-    optionsConfig() {
-        return this.castOptionsConfig({
-            dryRun: {
-                description: "Skip execution",
-                option: "--dryRun",
-            },
-            package: {
-                description: "Filter by package names",
-                option: "-p,--package <values>",
-                parser: string_1.parseStringList,
-            },
-            packageTask: {
-                description: "Filter by package task names",
-                option: "-pt,--package-task <values>",
-                parser: string_1.parseStringList,
-            },
-            repository: {
-                description: "Filter by repository names",
-                option: "-r,--repository <values>",
-                parser: string_1.parseStringList,
-            },
-            repositoryType: {
-                description: "Filter by repository types",
-                option: "-rt,--repository-type <values>",
-                parser: (v) => (0, string_1.parseStringList)(v),
-            },
-            tag: {
-                description: "Filter by tags",
-                option: "-t,--tag <values>",
-                parser: string_1.parseStringList,
-            },
-            date: {
-                description: "Date time (ISO)",
-                option: "--date <value>",
-            },
-            prune: {
-                description: "Prune backups",
-                option: "--prune",
-            },
-        });
+    static config() {
+        return {
+            name: "backup",
+            alias: "b",
+            options: exports.backupCommandOptions,
+        };
+    }
+    get optionsConfig() {
+        return exports.backupCommandOptions;
     }
     async exec() {
         const verbose = this.globalOptions.verbose ?? 0;
         const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
         const backup = new BackupAction_1.BackupAction(config, {
-            packageNames: this.options.package,
-            packageTaskNames: this.options.packageTask,
-            repositoryNames: this.options.repository,
-            repositoryTypes: this.options.repositoryType,
-            tags: this.options.tag,
+            packageNames: this.options.packageNames,
+            packageTaskNames: this.options.packageTaskNames,
+            repositoryNames: this.options.repositoryNames,
+            repositoryTypes: this.options.repositoryTypes,
+            tags: this.options.tags,
             dryRun: this.options.dryRun,
-            verbose: verbose > 0,
             date: this.options.date,
-            tty: this.globalOptions.tty,
+            prune: this.options.prune,
+            verbose: verbose > 0,
+        }, {
             progress: this.globalOptions.progress,
             streams: this.streams,
-            prune: this.options.prune,
+            tty: this.globalOptions.tty,
         });
-        const result = await backup.exec();
+        const data = await backup.exec();
         if (this.globalOptions.outputFormat)
             backup
-                .dataFormat(result, { streams: this.streams, verbose })
+                .dataFormat(data.result, {
+                verbose,
+                streams: this.streams,
+                errors: data.errors,
+            })
                 .log(this.globalOptions.outputFormat);
-        const exitCode = result.some((item) => item.error) ? 1 : 0;
-        return { result, exitCode };
+        return data;
     }
 }
 exports.BackupCommand = BackupCommand;

package/lib/commands/CleanCacheCommand.d.ts

@@ -1,7 +1,14 @@
+import { InferOptions } from "../utils/options";
 import { CommandAbstract } from "./CommandAbstract";
-export type CleanCacheCommandOptions<TResolved = false> = {};
-export declare class CleanCacheCommand extends CommandAbstract<CleanCacheCommandOptions<false>, CleanCacheCommandOptions<true>> {
-    optionsConfig(): import("../utils/cli").OptionsConfig<CleanCacheCommandOptions<false>, CleanCacheCommandOptions<true>>;
+export declare const cleanCacheCommandOptions: {};
+export type CleanCacheCommandOptions = InferOptions<typeof cleanCacheCommandOptions>;
+export declare class CleanCacheCommand extends CommandAbstract<typeof cleanCacheCommandOptions> {
+    static config(): {
+        name: string;
+        alias: string;
+        options: {};
+    };
+    get optionsConfig(): {};
     exec(): Promise<{
         exitCode: number;
     }>;

package/lib/commands/CleanCacheCommand.js

@@ -1,18 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CleanCacheCommand = void 0;
+exports.CleanCacheCommand = exports.cleanCacheCommandOptions = void 0;
 const CleanCacheAction_1 = require("../actions/CleanCacheAction");
 const bytes_1 = require("../utils/bytes");
 const data_format_1 = require("../utils/data-format");
 const CommandAbstract_1 = require("./CommandAbstract");
+exports.cleanCacheCommandOptions = {
+    ...CleanCacheAction_1.cleanCacheActionOptions,
+};
 class CleanCacheCommand extends CommandAbstract_1.CommandAbstract {
-    optionsConfig() {
-        return this.castOptionsConfig({});
+    static config() {
+        return {
+            name: "cleanCache",
+            alias: "cc",
+            options: exports.cleanCacheCommandOptions,
+        };
+    }
+    get optionsConfig() {
+        return exports.cleanCacheCommandOptions;
     }
     async exec() {
-        const cleanCache = new CleanCacheAction_1.CleanCacheAction({
-            verbose: !!this.globalOptions.verbose,
-        });
+        const cleanCache = new CleanCacheAction_1.CleanCacheAction({});
         const result = await cleanCache.exec();
         const dataFormat = new data_format_1.DataFormat({
             streams: this.streams,

package/lib/commands/CommandAbstract.d.ts

@@ -1,9 +1,9 @@
-import { OptionsConfig } from "../utils/cli";
 import { DataFormatType } from "../utils/data-format";
 import type { Config } from "../utils/datatruck/config-type";
+import { CommandConfig, InferOptions, OptionsConfig } from "../utils/options";
 import { ProgressMode } from "../utils/progress";
 import { StdStreams } from "../utils/stream";
-import { If, SimilarObject } from "../utils/ts";
+import { If } from "../utils/ts";
 export type GlobalOptions<TResolved = false> = {
     config: string | Config;
     outputFormat?: DataFormatType;
@@ -11,20 +11,21 @@ export type GlobalOptions<TResolved = false> = {
     tty?: If<TResolved, "auto" | boolean, "auto" | "true" | "false">;
     progress?: If<TResolved, ProgressMode, Exclude<ProgressMode, boolean> | "true" | "false">;
 };
-export type CommandConstructor<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> = {
-    new (globalOptions: GlobalOptions<true>, options: TOptions): CommandAbstract<TUnresolvedOptions, TOptions>;
+export type CommandConstructor<T extends OptionsConfig = OptionsConfig> = {
+    new (globalOptions: GlobalOptions<true>, options: InferOptions<T>, streams?: Partial<StdStreams>, configPath?: string): CommandAbstract<T>;
+    config(): CommandConfig;
 };
-export declare abstract class CommandAbstract<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> {
+export declare abstract class CommandAbstract<T extends OptionsConfig = OptionsConfig> {
     readonly globalOptions: GlobalOptions<true>;
-    readonly inputOptions: TUnresolvedOptions;
+    readonly options: InferOptions<T>;
     readonly configPath?: string | undefined;
-    readonly options: TOptions;
     readonly streams: StdStreams;
-    constructor(globalOptions: GlobalOptions<true>, inputOptions: TUnresolvedOptions, streams?: Partial<StdStreams>, configPath?: string | undefined);
-    abstract optionsConfig(): OptionsConfig<TUnresolvedOptions, TOptions>;
-    protected castOptionsConfig(options: OptionsConfig<TUnresolvedOptions, TOptions>): OptionsConfig<TUnresolvedOptions, TOptions>;
+    abstract optionsConfig: T;
+    static config(): CommandConfig;
+    constructor(globalOptions: GlobalOptions<true>, options: InferOptions<T>, streams?: Partial<StdStreams>, configPath?: string | undefined);
     abstract exec(): Promise<{
         exitCode: number;
         result?: any;
+        errors?: Error[];
     }>;
 }

package/lib/commands/CommandAbstract.js

@@ -1,23 +1,20 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommandAbstract = void 0;
-const cli_1 = require("../utils/cli");
 const stream_1 = require("../utils/stream");
 class CommandAbstract {
     globalOptions;
-    inputOptions;
-    configPath;
     options;
+    configPath;
     streams;
-    constructor(globalOptions, inputOptions, streams = {}, configPath) {
+    static config() {
+        throw new Error("Not implemented");
+    }
+    constructor(globalOptions, options, streams = {}, configPath) {
         this.globalOptions = globalOptions;
-        this.inputOptions = inputOptions;
+        this.options = options;
         this.configPath = configPath;
-        this.options = (0, cli_1.parseOptions)(inputOptions, this.optionsConfig());
         this.streams = (0, stream_1.createStdStreams)(streams);
     }
-    castOptionsConfig(options) {
-        return options;
-    }
 }
 exports.CommandAbstract = CommandAbstract;

package/lib/commands/ConfigCommand.d.ts

@@ -1,14 +1,77 @@
-import type { RepositoryConfig } from "../utils/datatruck/config-type";
-import { If } from "../utils/ts";
+import { InferOptions } from "../utils/options";
 import { CommandAbstract } from "./CommandAbstract";
-export type ConfigCommandOptions<TResolved = false> = {
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
+export declare const configCommandOptions: {
+    packageNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageTaskNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    repositoryNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    repositoryTypes: {
+        description: string;
+        shortFlag: string;
+        value: (value: string | undefined, validValues?: ("git" | "restic" | "datatruck")[] | undefined, defaultsValues?: true | ("git" | "restic" | "datatruck")[] | undefined) => ("git" | "restic" | "datatruck")[];
+    };
 };
-export declare class ConfigCommand extends CommandAbstract<ConfigCommandOptions<false>, ConfigCommandOptions<true>> {
-    optionsConfig(): import("../utils/cli").OptionsConfig<ConfigCommandOptions<false>, ConfigCommandOptions<true>>;
+export type ConfigCommandOptions = InferOptions<typeof configCommandOptions>;
+export declare class ConfigCommand extends CommandAbstract<typeof configCommandOptions> {
+    static config(): {
+        name: string;
+        alias: string;
+        options: {
+            packageNames: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            packageTaskNames: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            repositoryNames: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            repositoryTypes: {
+                description: string;
+                shortFlag: string;
+                value: (value: string | undefined, validValues?: ("git" | "restic" | "datatruck")[] | undefined, defaultsValues?: true | ("git" | "restic" | "datatruck")[] | undefined) => ("git" | "restic" | "datatruck")[];
+            };
+        };
+    };
+    get optionsConfig(): {
+        packageNames: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        packageTaskNames: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        repositoryNames: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        repositoryTypes: {
+            description: string;
+            shortFlag: string;
+            value: (value: string | undefined, validValues?: ("git" | "restic" | "datatruck")[] | undefined, defaultsValues?: true | ("git" | "restic" | "datatruck")[] | undefined) => ("git" | "restic" | "datatruck")[];
+        };
+    };
     exec(): Promise<{
         result: {
             path: string;