@datatruck/cli 0.34.3 → 0.34.5

package/lib/actions/BackupAction.js

@@ -1,4 +1,49 @@
 "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 };
 };
@@ -12,6 +57,7 @@ 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 error_1 = require("../utils/error");
 const fs_1 = require("../utils/fs");
 const list_1 = require("../utils/list");
 const progress_1 = require("../utils/progress");
@@ -32,7 +78,7 @@ class BackupAction {
     prepareSnapshot() {
         const date = this.options.date ?? new Date().toISOString();
         if (!(0, dayjs_1.default)(date, "YYYY-MM-DDTHH:mm:ss.SSS[Z]", true).isValid())
-            throw new Error(`Invalid snapshot date: ${date}`);
+            throw new error_1.AppError(`Invalid snapshot date: ${date}`);
         return {
             id: (0, crypto_1.randomUUID)().replaceAll("-", ""),
             date,
@@ -165,6 +211,7 @@ class BackupAction {
     }
     async exec() {
         const { options } = this;
+        const gc = new temp_1.GargabeCollector();
         const pm = new progress_1.ProgressManager({
             verbose: options.verbose,
             tty: options.tty,
@@ -173,6 +220,7 @@ class BackupAction {
         const l = new list_1.Listr3({
             streams: this.options.streams,
             progressManager: pm,
+            gargabeCollector: gc,
         });
         return l
             .add([
@@ -196,11 +244,11 @@ class BackupAction {
                     return [
                         ...packages.flatMap((pkg) => {
                             let taskResult = {};
-                            const gc = new temp_1.GargabeCollector();
                             const repositories = this.getRepositoryNames(pkg.repositoryNames ?? []);
                             const mirrorRepositories = repositories
                                 .filter((r) => r.mirrors.length)
                                 .flatMap(({ name, mirrors }) => mirrors.map((mirror) => ({ name, mirror })));
+                            const taskGc = gc.create();
                             return l.$tasks(!!pkg.task &&
                                 l.$task({
                                     key: "task",
@@ -213,13 +261,25 @@ class BackupAction {
                                         completed: `Task executed: ${pkg.name} (${pkg.task.name})`,
                                     },
                                     exitOnError: false,
-                                    runWrapper: gc.cleanupIfFail.bind(gc),
                                     run: async (task) => {
-                                        taskResult = await (0, task_1.createTask)(pkg.task).backup({
-                                            options,
-                                            package: pkg,
-                                            snapshot,
-                                            onProgress: (p) => pm.update(p, (t) => (task.output = t)),
+                                        await taskGc.disposeIfFail(async () => {
+                                            const env_1 = { stack: [], error: void 0, hasError: false };
+                                            try {
+                                                const progress = __addDisposableResource(env_1, pm.create(task), false);
+                                                taskResult = await (0, task_1.createTask)(pkg.task).backup({
+                                                    options,
+                                                    package: pkg,
+                                                    snapshot,
+                                                    onProgress: progress.update,
+                                                });
+                                            }
+                                            catch (e_1) {
+                                                env_1.error = e_1;
+                                                env_1.hasError = true;
+                                            }
+                                            finally {
+                                                __disposeResources(env_1);
+                                            }
                                         });
                                     },
                                 }), ...repositories.map(({ name: repositoryName }) => l.$task({
@@ -237,21 +297,34 @@ class BackupAction {
                                     failed: `Backup create failed: ${pkg.name} (${repositoryName})`,
                                 },
                                 exitOnError: false,
-                                runWrapper: gc.cleanupOnFinish.bind(gc),
                                 run: async (task, data) => {
-                                    const taskSummary = pkg.task
-                                        ? l.result("task", pkg.name)
-                                        : undefined;
-                                    if (taskSummary?.error)
-                                        throw new Error(`Task failed`);
-                                    const backup = await this.backup({
-                                        pkg,
-                                        repositoryName,
-                                        snapshot,
-                                        snapshotPath: taskResult?.snapshotPath,
-                                        onProgress: (p) => pm.update(p, (t) => (task.output = t)),
-                                    });
-                                    data.bytes = backup.bytes;
+                                    const env_2 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const _ = __addDisposableResource(env_2, gc.create().disposeOnFinish(), true);
+                                        const taskSummary = pkg.task
+                                            ? l.result("task", pkg.name)
+                                            : undefined;
+                                        if (taskSummary?.error)
+                                            throw new error_1.AppError(`Task failed`);
+                                        const progress = __addDisposableResource(env_2, pm.create(task), false);
+                                        const backup = await this.backup({
+                                            pkg,
+                                            repositoryName,
+                                            snapshot,
+                                            snapshotPath: taskResult?.snapshotPath,
+                                            onProgress: progress.update,
+                                        });
+                                        data.bytes = backup.bytes;
+                                    }
+                                    catch (e_2) {
+                                        env_2.error = e_2;
+                                        env_2.hasError = true;
+                                    }
+                                    finally {
+                                        const result_1 = __disposeResources(env_2);
+                                        if (result_1)
+                                            await result_1;
+                                    }
                                 },
                             })), l.$task({
                                 key: "cleanup",
@@ -264,8 +337,8 @@ class BackupAction {
                                     failed: "Task files clean failed",
                                 },
                                 exitOnError: false,
-                                enabled: gc.pending,
-                                run: () => gc.cleanup(),
+                                enabled: taskGc.pending(),
+                                run: () => taskGc.dispose(),
                             }), ...mirrorRepositories.map(({ name, mirror }) => l.$task({
                                 key: "copy",
                                 keyIndex: [pkg.name, mirror],
@@ -282,22 +355,35 @@ class BackupAction {
                                     failed: `Snapshot copy failed: ${pkg.name} (${mirror})`,
                                 },
                                 exitOnError: false,
-                                runWrapper: gc.cleanup.bind(gc),
                                 run: async (task, data) => {
-                                    const backupSummary = l.result("backup", [
-                                        pkg.name,
-                                        name,
-                                    ]);
-                                    if (backupSummary.error)
-                                        throw new Error(`Backup failed`);
-                                    const copy = await this.copy({
-                                        repositoryName: name,
-                                        mirrorRepositoryName: mirror,
-                                        pkg,
-                                        snapshot,
-                                        onProgress: (p) => pm.update(p, (t) => (task.output = t)),
-                                    });
-                                    data.bytes = copy.bytes;
+                                    const env_3 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const _ = __addDisposableResource(env_3, gc.create().disposeOnFinish(), true);
+                                        const backupSummary = l.result("backup", [
+                                            pkg.name,
+                                            name,
+                                        ]);
+                                        if (backupSummary.error)
+                                            throw new error_1.AppError(`Backup failed`);
+                                        const progress = __addDisposableResource(env_3, pm.create(task), false);
+                                        const copy = await this.copy({
+                                            repositoryName: name,
+                                            mirrorRepositoryName: mirror,
+                                            pkg,
+                                            snapshot,
+                                            onProgress: progress.update,
+                                        });
+                                        data.bytes = copy.bytes;
+                                    }
+                                    catch (e_3) {
+                                        env_3.error = e_3;
+                                        env_3.hasError = true;
+                                    }
+                                    finally {
+                                        const result_2 = __disposeResources(env_3);
+                                        if (result_2)
+                                            await result_2;
+                                    }
                                 },
                             })), !!this.options.prune &&
                                 l.$task({

package/lib/actions/ConfigAction.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConfigAction = void 0;
 const config_schema_1 = require("../config.schema");
 const config_1 = require("../utils/datatruck/config");
-const error_1 = require("../utils/datatruck/error");
+const error_1 = require("../utils/error");
 const fs_1 = require("../utils/fs");
 const ajv_1 = __importDefault(require("ajv"));
 const assert_1 = require("assert");

package/lib/actions/CopyAction.js

@@ -57,6 +57,7 @@ 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 error_1 = require("../utils/error");
 const list_1 = require("../utils/list");
 const object_1 = require("../utils/object");
 const progress_1 = require("../utils/progress");
@@ -98,6 +99,12 @@ class CopyAction {
         return new data_format_1.DataFormat({
             streams: options.streams,
             json: result,
+            list: () => result.map((item) => {
+                const icon = (0, cli_1.renderResult)(item.error, false);
+                const title = renderTitle(item);
+                const data = renderData(item, false, result);
+                return `${icon} ${title}: ${data}`;
+            }),
             table: {
                 headers: [
                     { value: "", width: 3 },
@@ -131,7 +138,7 @@ class CopyAction {
             }).map(({ item }) => item)
             : snapshots;
         if (!result.length)
-            throw new Error("No snapshots found");
+            throw new error_1.AppError("No snapshots found");
         return result;
     }
     createSourceRepoMap() {
@@ -212,83 +219,112 @@ class CopyAction {
                         action: "backup",
                     }), [repoConfig.type]);
                     if (!repositoryNames2.length)
-                        throw new Error("No mirror snapshots found");
+                        throw new error_1.AppError("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)),
+                    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,
+                                        },
                                     });
-                                    data.bytes = copy.bytes;
-                                    sourceRepo.set(mirrorRepo);
-                                }
-                            },
-                        });
-                    }));
+                                    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.withKey([
+                                        { id: snapshot.id, packageName: snapshot.packageName },
+                                        { type: mirrorConfig.type },
+                                    ]);
+                                    const $sourceRepo = repoConfig.type === mirrorConfig.type
+                                        ? repo
+                                        : sourceRepo.has()
+                                            ? sourceRepo.get()
+                                            : undefined;
+                                    if ($sourceRepo) {
+                                        const env_2 = { stack: [], error: void 0, hasError: false };
+                                        try {
+                                            const progress = __addDisposableResource(env_2, pm.create(task), false);
+                                            const copy = await $sourceRepo.copy({
+                                                mirrorRepositoryConfig: mirrorConfig.config,
+                                                options: { verbose: this.options.verbose },
+                                                package: { name: snapshot.packageName },
+                                                snapshot,
+                                                onProgress: progress.update,
+                                            });
+                                            data.bytes = copy.bytes;
+                                        }
+                                        catch (e_2) {
+                                            env_2.error = e_2;
+                                            env_2.hasError = true;
+                                        }
+                                        finally {
+                                            __disposeResources(env_2);
+                                        }
+                                    }
+                                    else {
+                                        const env_3 = { stack: [], error: void 0, hasError: false };
+                                        try {
+                                            const progress = __addDisposableResource(env_3, pm.create(task), false);
+                                            const copy = await this.copyCrossRepository({
+                                                mirrorConfig,
+                                                mirrorRepo,
+                                                repo,
+                                                repoConfig,
+                                                snapshot,
+                                                onProgress: progress.update,
+                                            });
+                                            data.bytes = copy.bytes;
+                                            sourceRepo.set(mirrorRepo);
+                                        }
+                                        catch (e_3) {
+                                            env_3.error = e_3;
+                                            env_3.hasError = true;
+                                        }
+                                        finally {
+                                            __disposeResources(env_3);
+                                        }
+                                    }
+                                },
+                            });
+                        })),
+                        ...(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"),
+                        }),
+                    ];
                 },
             }),
-            ...(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();
     }

package/lib/actions/InitAction.js

@@ -21,7 +21,7 @@ class InitAction {
             if (this.options.repositoryTypes &&
                 !this.options.repositoryTypes.includes(repoConfig.type))
                 continue;
-            const repo = (0, repository_1.createRepo)(repoConfig);
+            const repo = (0, repository_1.createRepo)(repoConfig, this.options.verbose);
             let initError = null;
             try {
                 await repo.init({

package/lib/actions/PruneAction.js

@@ -4,6 +4,7 @@ exports.PruneAction = void 0;
 const repository_1 = require("../utils/datatruck/repository");
 const snapshot_1 = require("../utils/datatruck/snapshot");
 const date_1 = require("../utils/date");
+const error_1 = require("../utils/error");
 const object_1 = require("../utils/object");
 const SnapshotsAction_1 = require("./SnapshotsAction");
 class PruneAction {
@@ -41,10 +42,10 @@ class PruneAction {
         const keepFilter = (0, date_1.createFilterByLastOptions)(this.options);
         const hasKeepFilter = Object.values(keepFilter).some((v) => typeof v === "number");
         if (hasIdFilter && hasKeepFilter)
-            throw new Error(`Snapshot id filter can not be used with 'keep' filters`);
+            throw new error_1.AppError(`Snapshot id filter can not be used with 'keep' filters`);
         const prunePolicy = !hasIdFilter && !hasKeepFilter;
         if (prunePolicy && !this.options.groupBy?.includes("packageName"))
-            throw new Error(`Policy config requires groupBy packageName`);
+            throw new error_1.AppError(`Policy config requires groupBy packageName`);
         const keepSnapshots = hasKeepFilter
             ? (0, snapshot_1.groupAndFilter)(snapshots, this.options.groupBy, keepFilter)
             : prunePolicy

package/lib/actions/RestoreAction.d.ts

@@ -5,7 +5,6 @@ import type { Config, PackageConfig } from "../utils/datatruck/config-type";
 import { Listr3TaskResultEnd } from "../utils/list";
 import { Progress, ProgressMode } from "../utils/progress";
 import { StdStreams } from "../utils/stream";
-import { GargabeCollector } from "../utils/temp";
 import { IfRequireKeys } from "../utils/ts";
 export type RestoreActionOptions = {
     snapshotId: string;
@@ -47,7 +46,6 @@ export declare class RestoreAction<TRequired extends boolean = true> {
         pkg: PackageConfig;
         task: TaskAbstract | undefined;
         snapshot: RestoreSnapshot;
-        gc: GargabeCollector;
         onProgress: (progress: Progress) => void;
     }): Promise<{
         snapshotPath: string | undefined;