@datatruck/cli 0.32.3 → 0.34.0

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

@@ -4,23 +4,24 @@ 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 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 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");
 const chalk_1 = __importDefault(require("chalk"));
 const crypto_1 = require("crypto");
 const dayjs_1 = __importDefault(require("dayjs"));
+const os_1 = require("os");
 class BackupAction {
     config;
     options;
@@ -68,12 +69,12 @@ 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 &&
             (!config.names || config.names.includes(repoConfig.name)))?.config;
-        await repo.backup({
+        return await repo.backup({
             options: this.options,
             snapshot: data.snapshot,
             package: pkg,
@@ -84,11 +85,11 @@ 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({
+        return await repo.copy({
             options: this.options,
             package: data.pkg,
             snapshot: data.snapshot,
@@ -103,33 +104,33 @@ 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, (0, bytes_1.formatBytes)(data.bytes)].join(" ")),
+                ],
+                copy: (data) => [
+                    data.packageName,
+                    g([data.mirrorRepositoryName, (0, bytes_1.formatBytes)(data.bytes)].join(" ")),
+                ],
+                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 +215,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,
@@ -227,6 +228,7 @@ class BackupAction {
                                 data: {
                                     packageName: pkg.name,
                                     repositoryName: repositoryName,
+                                    bytes: 0,
                                 },
                                 title: {
                                     initial: `Create backup: ${pkg.name} (${repositoryName})`,
@@ -236,19 +238,20 @@ class BackupAction {
                                 },
                                 exitOnError: false,
                                 runWrapper: gc.cleanupOnFinish.bind(gc),
-                                run: async (task) => {
+                                run: async (task, data) => {
                                     const taskSummary = pkg.task
                                         ? l.result("task", pkg.name)
                                         : undefined;
                                     if (taskSummary?.error)
                                         throw new Error(`Task failed`);
-                                    await this.backup({
+                                    const backup = await this.backup({
                                         pkg,
                                         repositoryName,
                                         snapshot,
                                         snapshotPath: taskResult?.snapshotPath,
                                         onProgress: (p) => pm.update(p, (t) => (task.output = t)),
                                     });
+                                    data.bytes = backup.bytes;
                                 },
                             })), l.$task({
                                 key: "cleanup",
@@ -270,6 +273,7 @@ class BackupAction {
                                     packageName: pkg.name,
                                     repositoryName: name,
                                     mirrorRepositoryName: mirror,
+                                    bytes: 0,
                                 },
                                 title: {
                                     initial: `Copy snapshot: ${pkg.name} (${mirror})`,
@@ -279,20 +283,21 @@ class BackupAction {
                                 },
                                 exitOnError: false,
                                 runWrapper: gc.cleanup.bind(gc),
-                                run: async (task) => {
+                                run: async (task, data) => {
                                     const backupSummary = l.result("backup", [
                                         pkg.name,
                                         name,
                                     ]);
                                     if (backupSummary.error)
                                         throw new Error(`Backup failed`);
-                                    await this.copy({
+                                    const copy = await this.copy({
                                         repositoryName: name,
                                         mirrorRepositoryName: mirror,
                                         pkg,
                                         snapshot,
                                         onProgress: (p) => pm.update(p, (t) => (task.output = t)),
                                     });
+                                    data.bytes = copy.bytes;
                                 },
                             })), !!this.options.prune &&
                                 l.$task({
@@ -323,56 +328,12 @@ 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, {
+                            hostname: this.config.hostname ?? (0, os_1.hostname)(),
+                            action: "backup",
+                            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 = {
@@ -29,8 +31,9 @@ export type Context = {
         repositoryName: string;
         mirrorRepositoryName: string;
         skipped: boolean;
+        bytes: number;
     };
-};
+} & ReportListTaskContext;
 export declare class CopyAction<TRequired extends boolean = true> {
     readonly config: Config;
     readonly options: IfRequireKeys<TRequired, CopyActionOptions>;
@@ -39,13 +42,17 @@ 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<{
+        bytes: number;
+    }>;
+    exec(): Promise<(import("../utils/list").List3SummaryResult | import("../utils/list").Listr3TaskResult<Context>)[]>;
 }