@datatruck/cli 0.32.2 → 0.33.0

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

@@ -4,17 +4,16 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackupAction = 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 report_list_1 = require("../utils/datatruck/report-list");
+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");
 const progress_1 = require("../utils/progress");
-const reportSteps_1 = require("../utils/reportSteps");
-const spawnSteps_1 = require("../utils/spawnSteps");
 const temp_1 = require("../utils/temp");
 const PruneAction_1 = require("./PruneAction");
 const assert_1 = require("assert");
@@ -68,7 +67,7 @@ class BackupAction {
         const pkg = { ...data.pkg, path: data.snapshotPath ?? data.pkg.path };
         (0, assert_1.ok)(pkg.path);
         await (0, fs_1.ensureExistsDir)(pkg.path);
-        const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
+        const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
         if (this.config.minFreeDiskSpace)
             await repo.ensureFreeDiskSpace(repoConfig.config, this.config.minFreeDiskSpace);
         const packageConfig = pkg.repositoryConfigs?.find((config) => config.type === repoConfig.type &&
@@ -84,8 +83,8 @@ class BackupAction {
     async copy(data) {
         const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, data.repositoryName);
         const mirrorRepoConfig = (0, config_1.findRepositoryOrFail)(this.config, data.mirrorRepositoryName);
-        const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
-        const mirrorRepo = (0, RepositoryFactory_1.createRepo)(mirrorRepoConfig);
+        const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
+        const mirrorRepo = await (0, repository_1.createAndInitRepo)(mirrorRepoConfig, this.options.verbose);
         if (this.config.minFreeDiskSpace)
             await mirrorRepo.ensureFreeDiskSpace(mirrorRepoConfig.config, this.config.minFreeDiskSpace);
         await repo.copy({
@@ -103,33 +102,27 @@ class BackupAction {
         };
         const renderData = (item, color, result = []) => {
             const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
-            return item.key === "prune"
-                ? `${item.data.packageName} ${g(`${item.data.pruned}/${item.data.total}`)}`
-                : item.key === "snapshot"
-                    ? item.data.id
-                    : item.key === "task"
-                        ? `${item.data.packageName} ${g(item.data.taskName)}`
-                        : item.key === "backup"
-                            ? `${item.data.packageName} ${g(item.data.repositoryName)}`
-                            : item.key === "copy"
-                                ? `${item.data.packageName} ${g(item.data.mirrorRepositoryName)}`
-                                : item.key === "summary"
-                                    ? (0, cli_1.renderObject)({
-                                        errors: item.data.errors,
-                                        backups: result.filter((r) => !r.error && r.key === "backup")
-                                            .length,
-                                        copies: result.filter((r) => !r.error && r.key === "copy").length,
-                                        prunes: result
-                                            .filter((r) => !r.error && r.key === "prune")
-                                            .reduce((result, item) => {
-                                            if (item.key === "prune")
-                                                result += item.data.pruned;
-                                            return result;
-                                        }, 0),
-                                    }, color)
-                                    : item.key === "report"
-                                        ? item.data.type
-                                        : "";
+            return (0, cli_1.renderListTaskItem)(item, color, {
+                snapshot: (data) => data.id,
+                task: (data) => [data.packageName, data.taskName],
+                backup: (data) => [data.packageName, g(data.repositoryName)],
+                copy: (data) => [data.packageName, g(data.mirrorRepositoryName)],
+                prune: (data) => [data.packageName, g(`${data.pruned}/${data.total}`)],
+                cleanup: () => "",
+                report: (data) => data.type,
+                summary: (data) => ({
+                    errors: data.errors,
+                    backups: result.filter((r) => !r.error && r.key === "backup").length,
+                    copies: result.filter((r) => !r.error && r.key === "copy").length,
+                    prunes: result
+                        .filter((r) => !r.error && r.key === "prune")
+                        .reduce((result, item) => {
+                        if (item.key === "prune")
+                            result += item.data.pruned;
+                        return result;
+                    }, 0),
+                }),
+            });
         };
         return new DataFormat_1.DataFormat({
             streams: options.streams,
@@ -214,7 +207,7 @@ class BackupAction {
                                     exitOnError: false,
                                     runWrapper: gc.cleanupIfFail.bind(gc),
                                     run: async (task) => {
-                                        taskResult = await (0, TaskFactory_1.createTask)(pkg.task).backup({
+                                        taskResult = await (0, task_1.createTask)(pkg.task).backup({
                                             options,
                                             package: pkg,
                                             snapshot,
@@ -323,56 +316,10 @@ class BackupAction {
                                     },
                                 }));
                         }),
-                        ...(this.config.reports || []).map((report, index) => {
-                            const reportIndex = index + 1;
-                            return l.$task({
-                                title: {
-                                    initial: `Send report ${reportIndex}`,
-                                    started: `Sending report ${reportIndex}`,
-                                    completed: `Report sent: ${reportIndex}`,
-                                    failed: `Report send failed: ${reportIndex}`,
-                                },
-                                key: "report",
-                                keyIndex: index,
-                                data: { type: report.run.type },
-                                exitOnError: false,
-                                run: async (task) => {
-                                    const result = l
-                                        .getResult()
-                                        .filter((r) => r.key !== "report");
-                                    const success = result.every((r) => !r.error);
-                                    const enabled = !report.when ||
-                                        (report.when === "success" && success) ||
-                                        (report.when === "error" && !success);
-                                    if (!enabled)
-                                        return task.skip(`Report send skipped: ${reportIndex}`);
-                                    const message = this.dataFormat(result).format(report.format ?? "list");
-                                    if ((0, spawnSteps_1.isSpawnStep)(report.run)) {
-                                        await (0, spawnSteps_1.runSpawnSteps)(report.run, {
-                                            data: {
-                                                dtt: {
-                                                    message,
-                                                    result,
-                                                    success,
-                                                },
-                                            },
-                                            verbose: this.options.verbose,
-                                        });
-                                    }
-                                    else if ((0, reportSteps_1.isReportStep)(report.run)) {
-                                        await (0, reportSteps_1.runReportSteps)(report.run, {
-                                            data: {
-                                                title: "DTT Backup",
-                                                message,
-                                                success,
-                                            },
-                                        });
-                                    }
-                                    else {
-                                        throw new Error(`Invalid step type: ${report.run.type}`);
-                                    }
-                                },
-                            });
+                        ...(0, report_list_1.createReportListTasks)(l, {
+                            reports: this.config.reports || [],
+                            verbose: this.options.verbose,
+                            onMessage: (result, report) => this.dataFormat(result).format(report.format ?? "list"),
                         }),
                     ];
                 },

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

@@ -1,5 +1,5 @@
-import { GlobalOptions } from "../Command/CommandAbstract";
-import type { Config } from "../Config/Config";
+import { GlobalOptions } from "../commands/CommandAbstract";
+import type { Config } from "../utils/datatruck/config-type";
 import { IfRequireKeys } from "../utils/ts";
 export type ConfigActionOptions = {
     path: string;
@@ -11,7 +11,9 @@ export declare class ConfigAction<TRequired extends boolean = true> {
     static validate(config: Config): void;
     static check(config: Config): void;
     static normalize(config: Config): Config;
+    static findFile(path: string): Promise<string>;
     static parseFile(path: string): Promise<Config>;
+    static findAndParseFile(inputPath: string): Promise<Config>;
     static fromGlobalOptionsWithPath(globalOptions: GlobalOptions<true>): Promise<{
         path: string;
         data: Config;

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

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigAction = void 0;
-const AppError_1 = require("../Error/AppError");
 const config_schema_1 = require("../config.schema");
 const config_1 = require("../utils/datatruck/config");
+const error_1 = require("../utils/datatruck/error");
 const fs_1 = require("../utils/fs");
 const ajv_1 = __importDefault(require("ajv"));
 const assert_1 = require("assert");
@@ -20,7 +20,7 @@ class ConfigAction {
             allowUnionTypes: true,
         }).compile(config_schema_1.configSchema);
         if (!validate(config))
-            throw new AppError_1.AppError("Json schema error: " + JSON.stringify(validate.errors, null, 2));
+            throw new error_1.AppError("Json schema error: " + JSON.stringify(validate.errors, null, 2));
     }
     static check(config) {
         const repositoryNames = [];
@@ -29,18 +29,18 @@ class ConfigAction {
         for (const repo of config.repositories) {
             repos[repo.name] = repo;
             if (repositoryNames.includes(repo.name))
-                throw new AppError_1.AppError(`Duplicated repository name: ${repo.name}`);
+                throw new error_1.AppError(`Duplicated repository name: ${repo.name}`);
             repositoryNames.push(repo.name);
         }
         for (const repo of config.repositories) {
             if (repo.mirrorRepoNames) {
                 for (const mirrorRepoName of repo.mirrorRepoNames) {
                     if (!repos[mirrorRepoName])
-                        throw new AppError_1.AppError(`Mirror repository name not found: ${mirrorRepoName}`);
+                        throw new error_1.AppError(`Mirror repository name not found: ${mirrorRepoName}`);
                     if (repos[mirrorRepoName].type !== repo.type)
-                        throw new AppError_1.AppError(`Mirror repository type is incompatible: ${mirrorRepoName}`);
+                        throw new error_1.AppError(`Mirror repository type is incompatible: ${mirrorRepoName}`);
                     if (mirrorRepoNames.includes(mirrorRepoName))
-                        throw new AppError_1.AppError(`Mirror repository is already used`);
+                        throw new error_1.AppError(`Mirror repository is already used`);
                     mirrorRepoNames.push(mirrorRepoName);
                 }
             }
@@ -48,7 +48,7 @@ class ConfigAction {
         const packageNames = [];
         for (const pkg of config.packages) {
             if (packageNames.includes(pkg.name))
-                throw new AppError_1.AppError(`Duplicated package name: ${pkg.name}`);
+                throw new error_1.AppError(`Duplicated package name: ${pkg.name}`);
             repositoryNames.push(pkg.name);
         }
     }
@@ -65,12 +65,20 @@ class ConfigAction {
         });
         return config;
     }
+    static async findFile(path) {
+        return await (0, fs_1.findFile)(path, "datatruck.config", fs_1.parseFileExtensions, "Config path not found");
+    }
     static async parseFile(path) {
         const config = await (0, fs_1.parseFile)(path, "config");
         ConfigAction.validate(config);
         ConfigAction.check(config);
         return ConfigAction.normalize(config);
     }
+    static async findAndParseFile(inputPath) {
+        const path = await ConfigAction.findFile(inputPath);
+        const data = await ConfigAction.parseFile(path);
+        return data;
+    }
     static async fromGlobalOptionsWithPath(globalOptions) {
         if (typeof globalOptions.config !== "string")
             return {
@@ -88,7 +96,7 @@ class ConfigAction {
         return config.data;
     }
     async exec() {
-        const path = await (0, fs_1.findFile)(this.options.path, "datatruck.config", fs_1.parseFileExtensions, "Config path not found");
+        const path = await ConfigAction.findFile(this.options.path);
         const data = await ConfigAction.parseFile(path);
         return { path, data };
     }

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

@@ -1,8 +1,10 @@
-import type { Config } from "../Config/Config";
-import { Snapshot } from "../Repository/RepositoryAbstract";
+import { RepositoryAbstract, Snapshot } from "../repositories/RepositoryAbstract";
 import { DataFormat } from "../utils/DataFormat";
+import type { Config, RepositoryConfig } from "../utils/datatruck/config-type";
+import { ReportListTaskContext } from "../utils/datatruck/report-list";
 import { Listr3TaskResultEnd } from "../utils/list";
-import { ProgressMode } from "../utils/progress";
+import { StrictMap } from "../utils/object";
+import { Progress, ProgressMode } from "../utils/progress";
 import { Streams } from "../utils/stream";
 import { IfRequireKeys } from "../utils/ts";
 export type CopyActionOptions = {
@@ -30,7 +32,7 @@ export type Context = {
         mirrorRepositoryName: string;
         skipped: boolean;
     };
-};
+} & ReportListTaskContext;
 export declare class CopyAction<TRequired extends boolean = true> {
     readonly config: Config;
     readonly options: IfRequireKeys<TRequired, CopyActionOptions>;
@@ -39,13 +41,15 @@ export declare class CopyAction<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>)[]>;
+    protected fetchSnapshots(repo: RepositoryAbstract<any>): Promise<Snapshot[]>;
+    protected createSourceRepoMap(): StrictMap<[Pick<Snapshot, "packageName" | "id">, Pick<RepositoryConfig, "type">], RepositoryAbstract<any>>;
+    protected copyCrossRepository(options: {
+        repo: RepositoryAbstract<any>;
+        repoConfig: RepositoryConfig;
+        mirrorRepo: RepositoryAbstract<any>;
+        mirrorConfig: RepositoryConfig;
+        snapshot: Snapshot;
+        onProgress: (p: Progress) => void;
+    }): Promise<void>;
+    exec(): Promise<(import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<Context>)[]>;
 }

package/lib/actions/CopyAction.js

@@ -0,0 +1,285 @@
+"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 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"));
+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].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);
+            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,
+                                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()) {
+                                    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)),
+                                    });
+                                }
+                                else {
+                                    await this.copyCrossRepository({
+                                        mirrorConfig,
+                                        mirrorRepo,
+                                        repo,
+                                        repoConfig,
+                                        snapshot,
+                                        onProgress: (p) => pm.update(p, (d) => (task.output = d)),
+                                    });
+                                    sourceRepo.set(mirrorRepo);
+                                }
+                            },
+                        });
+                    }));
+                },
+            }),
+            ...(0, report_list_1.createReportListTasks)(l, {
+                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";