@datatruck/cli 0.32.3 → 0.34.0

package/lib/actions/CopyAction.js

@@ -0,0 +1,296 @@
+"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.CopyAction = void 0;
+const DataFormat_1 = require("../utils/DataFormat");
+const bytes_1 = require("../utils/bytes");
+const cli_1 = require("../utils/cli");
+const config_1 = require("../utils/datatruck/config");
+const report_list_1 = require("../utils/datatruck/report-list");
+const repository_1 = require("../utils/datatruck/repository");
+const snapshot_1 = require("../utils/datatruck/snapshot");
+const date_1 = require("../utils/date");
+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 chalk_1 = __importDefault(require("chalk"));
+const os_1 = require("os");
+class CopyAction {
+    config;
+    options;
+    constructor(config, options) {
+        this.config = config;
+        this.options = options;
+    }
+    dataFormat(result, options = {}) {
+        const renderTitle = (item, color) => {
+            let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
+            return item.key === "copy" && color ? chalk_1.default.cyan(title) : title;
+        };
+        const renderData = (item, color, items = []) => {
+            const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
+            return (0, cli_1.renderListTaskItem)(item, color, {
+                snapshots: (data) => data.snapshots.length,
+                copy: (data) => [
+                    data.packageName,
+                    g([
+                        data.snapshotId.slice(0, 8),
+                        data.mirrorRepositoryName,
+                        (0, bytes_1.formatBytes)(data.bytes),
+                    ].join(" ")),
+                ],
+                report: (data) => data.type,
+                summary: (data) => ({
+                    errors: data.errors,
+                    copied: items.filter((i) => i.key === "copy" && !i.error && !i.data.skipped).length,
+                    skipped: items.filter((i) => i.key === "copy" && !i.error && i.data.skipped).length,
+                }),
+            });
+        };
+        return new DataFormat_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.verbose),
+                ]),
+            },
+        });
+    }
+    async fetchSnapshots(repo) {
+        const snapshots = await repo.fetchSnapshots({
+            options: {
+                ids: this.options.ids,
+                packageNames: this.options.packageNames,
+                packageTaskNames: this.options.packageTaskNames,
+                verbose: this.options.verbose,
+            },
+        });
+        const result = this.options.last
+            ? (0, snapshot_1.groupAndFilter)(snapshots, ["packageName"], {
+                last: this.options.last,
+            }).map(({ item }) => item)
+            : snapshots;
+        if (!result.length)
+            throw new Error("No snapshots found");
+        return result;
+    }
+    createSourceRepoMap() {
+        return new object_1.StrictMap(([snapshot, config]) => [config.type, snapshot.id, snapshot.packageName].join("|"));
+    }
+    async copyCrossRepository(options) {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const { repo, repoConfig, mirrorRepo, mirrorConfig, snapshot } = options;
+            const tmp = __addDisposableResource(env_1, await (0, temp_1.useTempDir)("copy", "restore"), true);
+            const pkg = (0, config_1.findPackageOrFail)(this.config, snapshot.packageName);
+            await repo.restore({
+                options: {
+                    verbose: this.options.verbose,
+                    snapshotId: snapshot.id,
+                },
+                snapshot: { id: snapshot.id, date: snapshot.date },
+                package: { name: snapshot.packageName },
+                packageConfig: (0, config_1.findPackageRepositoryConfig)(pkg, repoConfig),
+                snapshotPath: tmp.path,
+                onProgress: options.onProgress,
+            });
+            if (this.config.minFreeDiskSpace)
+                await mirrorRepo.ensureFreeDiskSpace(mirrorConfig.config, this.config.minFreeDiskSpace);
+            return await mirrorRepo.backup({
+                options: {
+                    verbose: this.options.verbose,
+                    tags: snapshot.tags,
+                },
+                snapshot: { id: snapshot.id, date: snapshot.date },
+                package: {
+                    name: snapshot.packageName,
+                    path: tmp.path,
+                },
+                packageConfig: (0, config_1.findPackageRepositoryConfig)(pkg, mirrorConfig),
+                onProgress: options.onProgress,
+            });
+        }
+        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;
+        }
+    }
+    async exec() {
+        const { options } = this;
+        const pm = new progress_1.ProgressManager({
+            verbose: options.verbose,
+            tty: options.tty,
+            mode: options.progress,
+        });
+        const l = new list_1.Listr3({ progressManager: pm });
+        return l
+            .add([
+            l.$task({
+                key: "snapshots",
+                data: { snapshots: [] },
+                title: {
+                    initial: "Fetch snapshots",
+                    started: "Fetching snapshots",
+                    completed: "Snapshots fetched",
+                    failed: "Snapshot fetch failed",
+                },
+                run: async (task, data) => {
+                    if (this.config.minFreeDiskSpace)
+                        await (0, temp_1.ensureFreeDiskTempSpace)(this.config.minFreeDiskSpace);
+                    const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, this.options.repositoryName);
+                    const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
+                    data.snapshots = await this.fetchSnapshots(repo);
+                    task.title = `Snapshots fetched: ${data.snapshots.length}`;
+                    const repositoryNames2 = (0, config_1.sortReposByType)((0, config_1.filterRepository)(this.config.repositories, {
+                        include: this.options.repositoryNames2,
+                        exclude: [repoConfig.name],
+                        action: "backup",
+                    }), [repoConfig.type]);
+                    if (!repositoryNames2.length)
+                        throw new Error("No mirror snapshots found");
+                    const sourceRepoMap = this.createSourceRepoMap();
+                    return data.snapshots.flatMap((snapshot) => repositoryNames2.map((repo2) => {
+                        const id = snapshot.id.slice(0, 8);
+                        const pkgName = snapshot.packageName;
+                        return l.$task({
+                            key: "copy",
+                            keyIndex: [snapshot.packageName, repo2.name, snapshot.id],
+                            data: {
+                                snapshotId: snapshot.id,
+                                packageName: snapshot.packageName,
+                                repositoryName: repoConfig.name,
+                                mirrorRepositoryName: repo2.name,
+                                bytes: 0,
+                                skipped: false,
+                            },
+                            title: {
+                                initial: `Copy snapshot: ${pkgName} (${id}) » ${repo2.name}`,
+                                started: `Copying snapshot: ${pkgName} (${id}) » ${repo2.name}`,
+                                completed: `Snapshot copied: ${pkgName} (${id}) » ${repo2.name}`,
+                                failed: `Snapshot copy failed: ${pkgName} (${id}) » ${repo2.name}`,
+                            },
+                            exitOnError: false,
+                            run: async (task, data) => {
+                                const mirrorConfig = (0, config_1.findRepositoryOrFail)(this.config, repo2.name);
+                                const mirrorRepo = await (0, repository_1.createAndInitRepo)(mirrorConfig, this.options.verbose);
+                                const currentCopies = await mirrorRepo.fetchSnapshots({
+                                    options: {
+                                        ids: [snapshot.id],
+                                        packageNames: [snapshot.packageName],
+                                        verbose: this.options.verbose,
+                                    },
+                                });
+                                if (currentCopies.length) {
+                                    data.skipped = true;
+                                    return task.skip(`Already exists at ${mirrorConfig.name}: ${pkgName} (${id})`);
+                                }
+                                if (this.config.minFreeDiskSpace)
+                                    await mirrorRepo.ensureFreeDiskSpace(mirrorConfig.config, this.config.minFreeDiskSpace);
+                                const sourceRepo = sourceRepoMap.with([
+                                    snapshot,
+                                    mirrorConfig,
+                                ]);
+                                if (sourceRepo.has()) {
+                                    const copy = await sourceRepo.get().copy({
+                                        mirrorRepositoryConfig: mirrorConfig.config,
+                                        options: { verbose: this.options.verbose },
+                                        package: { name: snapshot.packageName },
+                                        snapshot,
+                                        onProgress: (p) => pm.update(p, (d) => (task.output = d)),
+                                    });
+                                    data.bytes = copy.bytes;
+                                }
+                                else {
+                                    const copy = await this.copyCrossRepository({
+                                        mirrorConfig,
+                                        mirrorRepo,
+                                        repo,
+                                        repoConfig,
+                                        snapshot,
+                                        onProgress: (p) => pm.update(p, (d) => (task.output = d)),
+                                    });
+                                    data.bytes = copy.bytes;
+                                    sourceRepo.set(mirrorRepo);
+                                }
+                            },
+                        });
+                    }));
+                },
+            }),
+            ...(0, report_list_1.createReportListTasks)(l, {
+                hostname: this.config.hostname ?? (0, os_1.hostname)(),
+                action: "copy",
+                reports: this.config.reports || [],
+                verbose: this.options.verbose,
+                onMessage: (result, report) => this.dataFormat(result).format(report.format ?? "list"),
+            }),
+        ])
+            .exec();
+    }
+}
+exports.CopyAction = CopyAction;

package/lib/{Action → actions}/InitAction.d.ts

@@ -1,4 +1,4 @@
-import type { Config } from "../Config/Config";
+import type { Config } from "../utils/datatruck/config-type";
 import { IfRequireKeys } from "../utils/ts";
 export type InitActionOptions = {
     repositoryNames?: string[];

package/lib/{Action → actions}/InitAction.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InitAction = void 0;
-const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
 const config_1 = require("../utils/datatruck/config");
+const repository_1 = require("../utils/datatruck/repository");
 class InitAction {
     config;
     options;
@@ -13,7 +13,7 @@ class InitAction {
     async exec() {
         const result = [];
         for (const repoConfig of this.config.repositories) {
-            if (!(0, config_1.filterRepository)(repoConfig, "init"))
+            if (!(0, config_1.filterRepositoryByEnabled)(repoConfig, "init"))
                 continue;
             if (this.options.repositoryNames &&
                 !this.options.repositoryNames.includes(repoConfig.name))
@@ -21,7 +21,7 @@ class InitAction {
             if (this.options.repositoryTypes &&
                 !this.options.repositoryTypes.includes(repoConfig.type))
                 continue;
-            const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
+            const repo = (0, repository_1.createRepo)(repoConfig);
             let initError = null;
             try {
                 await repo.init({

package/lib/{Action → actions}/PruneAction.d.ts

@@ -1,5 +1,4 @@
-import type { Config } from "../Config/Config";
-import { RepositoryConfig } from "../Config/RepositoryConfig";
+import type { Config, RepositoryConfig } from "../utils/datatruck/config-type";
 import { KeepObject } from "../utils/date";
 import { IfRequireKeys } from "../utils/ts";
 import { ExtendedSnapshot, SnapshotsActionOptions } from "./SnapshotsAction";

package/lib/{Action → actions}/PruneAction.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PruneAction = void 0;
-const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
+const repository_1 = require("../utils/datatruck/repository");
 const snapshot_1 = require("../utils/datatruck/snapshot");
 const date_1 = require("../utils/date");
 const object_1 = require("../utils/object");
@@ -17,7 +17,7 @@ class PruneAction {
         const repository = (0, object_1.groupBy)(this.config.repositories, "name", true);
         for (const snapshot of snapshots) {
             if (!snapshot.exclusionReasons?.length) {
-                const repo = (0, RepositoryFactory_1.createRepo)(repository[snapshot.repositoryName]);
+                const repo = await (0, repository_1.createAndInitRepo)(repository[snapshot.repositoryName], this.options.verbose);
                 await repo.prune({
                     snapshot: snapshot,
                     options: { verbose: this.options.verbose },

package/lib/{Action → actions}/RestoreAction.d.ts

@@ -1,8 +1,7 @@
-import type { Config } from "../Config/Config";
-import { PackageConfig } from "../Config/PackageConfig";
-import { Snapshot } from "../Repository/RepositoryAbstract";
-import { TaskAbstract } from "../Task/TaskAbstract";
+import { Snapshot } from "../repositories/RepositoryAbstract";
+import { TaskAbstract } from "../tasks/TaskAbstract";
 import { DataFormat } from "../utils/DataFormat";
+import type { Config, PackageConfig } from "../utils/datatruck/config-type";
 import { Listr3TaskResultEnd } from "../utils/list";
 import { Progress, ProgressMode } from "../utils/progress";
 import { Streams } from "../utils/stream";
@@ -57,14 +56,6 @@ export declare class RestoreAction<TRequired extends boolean = true> {
         streams?: Streams;
         verbose?: number;
     }): DataFormat;
-    exec(): Promise<({
-        key: "summary";
-        keyIndex?: string | undefined;
-        data: {
-            errors: number;
-        };
-        elapsed: number;
-        error?: Error | undefined;
-    } | import("../utils/list").Listr3TaskResult<Context>)[]>;
+    exec(): Promise<(import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<Context>)[]>;
 }
 export {};

package/lib/{Action → actions}/RestoreAction.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestoreAction = void 0;
-const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
-const TaskFactory_1 = require("../Factory/TaskFactory");
 const DataFormat_1 = require("../utils/DataFormat");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
+const repository_1 = require("../utils/datatruck/repository");
+const task_1 = require("../utils/datatruck/task");
 const date_1 = require("../utils/date");
 const fs_1 = require("../utils/fs");
 const list_1 = require("../utils/list");
@@ -68,7 +68,7 @@ class RestoreAction {
     async restore(data) {
         let { snapshot, pkg, task } = data;
         const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
-        const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
+        const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
         if (this.options.initial)
             pkg = { ...pkg, restorePath: pkg.path };
         let snapshotPath = pkg.restorePath ?? pkg.path;
@@ -103,19 +103,19 @@ class RestoreAction {
         };
         const renderData = (item, color, result = []) => {
             const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
-            return item.key === "snapshots"
-                ? `${item.data.id.slice(0, 8)} ${g(`${item.data.packages} packages`)}`
-                : item.key === "task"
-                    ? `${item.data.packageName} ${g(item.data.taskName)}`
-                    : item.key === "restore"
-                        ? `${item.data.packageName} ${g(item.data.repositoryName)}`
-                        : item.key === "summary"
-                            ? (0, cli_1.renderObject)({
-                                errors: item.data.errors,
-                                restores: result.filter((r) => !r.error && r.key === "restore")
-                                    .length,
-                            }, color)
-                            : "";
+            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)],
+                restore: (data) => [data.packageName, g(data.repositoryName)],
+                summary: (data) => ({
+                    errors: data.errors,
+                    restores: result.filter((r) => !r.error && r.key === "restore")
+                        .length,
+                }),
+            });
         };
         return new DataFormat_1.DataFormat({
             streams: options.streams,
@@ -191,7 +191,7 @@ class RestoreAction {
                             action: "restore",
                         });
                         const gc = new temp_1.GargabeCollector();
-                        const task = pkg.task ? (0, TaskFactory_1.createTask)(pkg.task) : undefined;
+                        const task = pkg.task ? (0, task_1.createTask)(pkg.task) : undefined;
                         const restore = await this.restore({
                             gc,
                             pkg,

package/lib/{Action → actions}/SnapshotsAction.d.ts

@@ -1,6 +1,5 @@
-import type { Config } from "../Config/Config";
-import { RepositoryConfigEnabledAction } from "../Config/RepositoryConfig";
-import { Snapshot } from "../Repository/RepositoryAbstract";
+import { Snapshot } from "../repositories/RepositoryAbstract";
+import type { Config, RepositoryConfigEnabledAction } from "../utils/datatruck/config-type";
 import { IfRequireKeys } from "../utils/ts";
 export type SnapshotGroupByType = keyof Pick<ExtendedSnapshot, "packageName" | "repositoryName" | "repositoryType">;
 export type SnapshotsActionOptions = {

package/lib/{Action → actions}/SnapshotsAction.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SnapshotsAction = void 0;
-const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
 const config_1 = require("../utils/datatruck/config");
+const repository_1 = require("../utils/datatruck/repository");
 const snapshot_1 = require("../utils/datatruck/snapshot");
 class SnapshotsAction {
     config;
@@ -16,7 +16,7 @@ class SnapshotsAction {
             sourceAction = "snapshots";
         let result = [];
         for (const repoConfig of this.config.repositories) {
-            if (!(0, config_1.filterRepository)(repoConfig, sourceAction))
+            if (!(0, config_1.filterRepositoryByEnabled)(repoConfig, sourceAction))
                 continue;
             if (this.options.repositoryNames &&
                 !this.options.repositoryNames.includes(repoConfig.name))
@@ -24,7 +24,7 @@ class SnapshotsAction {
             if (this.options.repositoryTypes &&
                 !this.options.repositoryTypes.includes(repoConfig.type))
                 continue;
-            const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
+            const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
             const configPackageNames = this.config.packages.map((pkg) => pkg.name);
             const packageNames = this.options.packageConfig
                 ? this.options.packageNames?.filter((name) => configPackageNames.includes(name)) || configPackageNames

package/lib/cli.d.ts

@@ -1,4 +1,4 @@
-import { OptionsMap } from "./Factory/CommandFactory";
-export declare function buildArgs<TCommand extends keyof OptionsMap>(input: TCommand, options: OptionsMap[TCommand]): any[];
+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<TCommand extends keyof OptionsMap>(input: TCommand, options: OptionsMap[TCommand]): Promise<void>;
+export declare function exec<T extends keyof DatatruckCommandMap>(input: T, options: InferDatatruckCommandOptions<T>): Promise<void>;

package/lib/cli.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.exec = exports.parseArgs = exports.buildArgs = void 0;
-const ConfigAction_1 = require("./Action/ConfigAction");
-const AppError_1 = require("./Error/AppError");
-const CommandFactory_1 = require("./Factory/CommandFactory");
+const ConfigAction_1 = require("./actions/ConfigAction");
 const globalData_1 = __importDefault(require("./globalData"));
 const cli_1 = require("./utils/cli");
+const command_1 = require("./utils/datatruck/command");
+const error_1 = require("./utils/datatruck/error");
 const exit_1 = require("./utils/exit");
 const fs_1 = require("./utils/fs");
 const string_1 = require("./utils/string");
@@ -28,8 +28,8 @@ function getGlobalOptions() {
 }
 function makeCommand(command) {
     const programCommand = program.command(command);
-    const instance = (0, CommandFactory_1.CommandFactory)(command, getGlobalOptions(), null);
-    const options = instance.onOptions();
+    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})` : ""}`;
@@ -56,10 +56,11 @@ function makeCommandAction(command) {
                 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);
-            exitCode = await (0, CommandFactory_1.CommandFactory)(command, {
+            const response = await (0, command_1.createCommand)(command, {
                 ...globalOptions,
                 config: config.data,
-            }, options, {}, globalOptions.config).onExec();
+            }, options, {}, globalOptions.config).exec();
+            exitCode = response.exitCode;
         }
         catch (e) {
             const error = e;
@@ -67,7 +68,7 @@ function makeCommandAction(command) {
                 console.error((0, chalk_1.red)(error.stack));
             }
             else {
-                if (error instanceof AppError_1.AppError) {
+                if (error instanceof error_1.AppError) {
                     console.error((0, chalk_1.red)(error.message));
                 }
                 else {
@@ -90,15 +91,15 @@ 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(CommandFactory_1.CommandEnum.startServer).alias("start");
-makeCommand(CommandFactory_1.CommandEnum.config).alias("c");
-makeCommand(CommandFactory_1.CommandEnum.init).alias("i");
-makeCommand(CommandFactory_1.CommandEnum.snapshots).alias("s");
-makeCommand(CommandFactory_1.CommandEnum.prune).alias("p");
-makeCommand(CommandFactory_1.CommandEnum.backup).alias("b");
-makeCommand(CommandFactory_1.CommandEnum.restore).alias("r");
-makeCommand(CommandFactory_1.CommandEnum.copy).alias("cp");
-makeCommand(CommandFactory_1.CommandEnum.cleanCache).alias("cc");
+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, "-")}`,

package/lib/commands/BackupCommand.d.ts

@@ -0,0 +1,45 @@
+import type { RepositoryConfig } from "../utils/datatruck/config-type";
+import { If } from "../utils/ts";
+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 class BackupCommand extends CommandAbstract<BackupCommandOptions<false>, BackupCommandOptions<true>> {
+    optionsConfig(): import("../utils/cli").OptionsConfig<BackupCommandOptions<false>, BackupCommandOptions<true>>;
+    exec(): Promise<{
+        result: (import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<{
+            snapshot: {
+                id: string;
+            };
+            task: {
+                taskName: string;
+                packageName: string;
+            };
+            backup: {
+                packageName: string;
+                repositoryName: string;
+                bytes: number;
+            };
+            cleanup: {};
+            copy: {
+                packageName: string;
+                repositoryName: string;
+                mirrorRepositoryName: string;
+                bytes: number;
+            };
+            prune: {
+                packageName: string;
+                total: number;
+                pruned: number;
+            };
+        } & import("../utils/datatruck/report-list").ReportListTaskContext>)[];
+        exitCode: number;
+    }>;
+}

package/lib/{Command → commands}/BackupCommand.js

@@ -1,13 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackupCommand = void 0;
-const BackupAction_1 = require("../Action/BackupAction");
-const ConfigAction_1 = require("../Action/ConfigAction");
+const BackupAction_1 = require("../actions/BackupAction");
+const ConfigAction_1 = require("../actions/ConfigAction");
 const string_1 = require("../utils/string");
 const CommandAbstract_1 = require("./CommandAbstract");
 class BackupCommand extends CommandAbstract_1.CommandAbstract {
-    onOptions() {
-        return this.returnsOptions({
+    optionsConfig() {
+        return this.castOptionsConfig({
             dryRun: {
                 description: "Skip execution",
                 option: "--dryRun",
@@ -47,7 +47,7 @@ class BackupCommand extends CommandAbstract_1.CommandAbstract {
             },
         });
     }
-    async onExec() {
+    async exec() {
         const verbose = this.globalOptions.verbose ?? 0;
         const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
         const backup = new BackupAction_1.BackupAction(config, {
@@ -69,7 +69,8 @@ class BackupCommand extends CommandAbstract_1.CommandAbstract {
             backup
                 .dataFormat(result, { streams: this.streams, verbose })
                 .log(this.globalOptions.outputFormat);
-        return result.some((item) => item.error) ? 1 : 0;
+        const exitCode = result.some((item) => item.error) ? 1 : 0;
+        return { result, exitCode };
     }
 }
 exports.BackupCommand = BackupCommand;