@datatruck/cli 0.37.0 → 0.38.1

package/lib/commands/BackupCommand.js

@@ -1,68 +1,40 @@
 "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 data = await backup.exec();
         if (this.globalOptions.outputFormat)

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,18 +11,18 @@ 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;

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;

package/lib/commands/ConfigCommand.js

@@ -1,43 +1,51 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ConfigCommand = void 0;
+exports.ConfigCommand = exports.configCommandOptions = void 0;
 const ConfigAction_1 = require("../actions/ConfigAction");
 const data_format_1 = require("../utils/data-format");
 const config_1 = require("../utils/datatruck/config");
 const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
+exports.configCommandOptions = {
+    packageNames: {
+        description: "Filter by package names",
+        shortFlag: "p",
+        value: "array",
+    },
+    packageTaskNames: {
+        description: "Filter by package task names",
+        shortFlag: "pt",
+        value: "array",
+    },
+    repositoryNames: {
+        description: "Filter by repository names",
+        shortFlag: "r",
+        value: "array",
+    },
+    repositoryTypes: {
+        description: "Filter by repository types",
+        shortFlag: "rt",
+        value: (string_1.parseStringList),
+    },
+};
 class ConfigCommand extends CommandAbstract_1.CommandAbstract {
-    optionsConfig() {
-        return this.castOptionsConfig({
-            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),
-            },
-        });
+    static config() {
+        return {
+            name: "config",
+            alias: "c",
+            options: exports.configCommandOptions,
+        };
+    }
+    get optionsConfig() {
+        return exports.configCommandOptions;
     }
     async exec() {
         const result = await ConfigAction_1.ConfigAction.fromGlobalOptionsWithPath(this.globalOptions);
         const packages = (0, config_1.filterPackages)(result.data, {
-            packageNames: this.options.package,
-            packageTaskNames: this.options.packageTask,
-            repositoryNames: this.options.repository,
-            repositoryTypes: this.options.repositoryType,
+            packageNames: this.options.packageNames,
+            packageTaskNames: this.options.packageTaskNames,
+            repositoryNames: this.options.repositoryNames,
+            repositoryTypes: this.options.repositoryTypes,
         });
         const summaryConfig = packages.flatMap((pkg) => ({
             packageName: pkg.name,

package/lib/commands/CopyCommand.d.ts

@@ -1,15 +1,107 @@
-import { If } from "../utils/ts";
+import { InferOptions } from "../utils/options";
 import { CommandAbstract } from "./CommandAbstract";
-export type CopyCommandOptions<TResolved = false> = {
-    id?: If<TResolved, string[]>;
-    last?: number;
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    repository: string;
-    repository2?: If<TResolved, string[]>;
+export declare const copyCommandOptions: {
+    repositoryNames2: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    packageTaskNames: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    ids: {
+        description: string;
+        shortFlag: string;
+        value: "array";
+    };
+    last: {
+        description: string;
+        shortFlag: string;
+        value: "number";
+    };
+    repositoryName: {
+        description: string;
+        shortFlag: string;
+        required: true;
+    };
 };
-export declare class CopyCommand extends CommandAbstract<CopyCommandOptions<false>, CopyCommandOptions<true>> {
-    optionsConfig(): import("../utils/cli").OptionsConfig<CopyCommandOptions<false>, CopyCommandOptions<true>>;
+export type CopyCommandOptions = InferOptions<typeof copyCommandOptions>;
+export declare class CopyCommand extends CommandAbstract<typeof copyCommandOptions> {
+    static config(): {
+        name: string;
+        alias: string;
+        options: {
+            repositoryNames2: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            packageNames: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            packageTaskNames: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            ids: {
+                description: string;
+                shortFlag: string;
+                value: "array";
+            };
+            last: {
+                description: string;
+                shortFlag: string;
+                value: "number";
+            };
+            repositoryName: {
+                description: string;
+                shortFlag: string;
+                required: true;
+            };
+        };
+    };
+    get optionsConfig(): {
+        repositoryNames2: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        packageNames: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        packageTaskNames: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        ids: {
+            description: string;
+            shortFlag: string;
+            value: "array";
+        };
+        last: {
+            description: string;
+            shortFlag: string;
+            value: "number";
+        };
+        repositoryName: {
+            description: string;
+            shortFlag: string;
+            required: true;
+        };
+    };
     exec(): Promise<{
         result: (import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<import("../actions/CopyAction").Context>)[];
         exitCode: number;

package/lib/commands/CopyCommand.js

@@ -1,55 +1,33 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopyCommand = void 0;
+exports.CopyCommand = exports.copyCommandOptions = void 0;
 const ConfigAction_1 = require("../actions/ConfigAction");
 const CopyAction_1 = require("../actions/CopyAction");
-const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
+exports.copyCommandOptions = {
+    ...CopyAction_1.copyActionOptions,
+};
 class CopyCommand extends CommandAbstract_1.CommandAbstract {
-    optionsConfig() {
-        return this.castOptionsConfig({
-            id: {
-                option: "-i,--id <ids>",
-                description: "Filter by identifiers",
-                parser: string_1.parseStringList,
-            },
-            last: {
-                option: "-l,--last <amount>",
-                description: "Last snapshots",
-                parser: Number,
-            },
-            package: {
-                option: "-p,--package <names>",
-                description: "Filter by package names",
-                parser: string_1.parseStringList,
-            },
-            packageTask: {
-                option: "-pt,--package-task <values>",
-                description: "Filter by task names",
-                parser: string_1.parseStringList,
-            },
-            repository: {
-                option: "-r,--repository <name>",
-                description: "Filter by repository name",
-                required: true,
-            },
-            repository2: {
-                option: "-r2,--repository2 <names>",
-                description: "Filter by repository names",
-                parser: string_1.parseStringList,
-            },
-        });
+    static config() {
+        return {
+            name: "copy",
+            alias: "cp",
+            options: exports.copyCommandOptions,
+        };
+    }
+    get optionsConfig() {
+        return exports.copyCommandOptions;
     }
     async exec() {
         const verbose = this.globalOptions.verbose ?? 0;
         const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
         const copy = new CopyAction_1.CopyAction(config, {
-            ids: this.options.id,
+            ids: this.options.ids,
             last: this.options.last,
-            packageNames: this.options.package,
-            packageTaskNames: this.options.packageTask,
-            repositoryName: this.options.repository,
-            repositoryNames2: this.options.repository2,
+            packageNames: this.options.packageNames,
+            packageTaskNames: this.options.packageTaskNames,
+            repositoryName: this.options.repositoryName,
+            repositoryNames2: this.options.repositoryNames2,
             verbose: verbose > 0,
             tty: this.globalOptions.tty,
             progress: this.globalOptions.progress,