@datatruck/cli 0.34.4 → 0.35.0

package/config.schema.json

@@ -399,6 +399,63 @@
                   "name"
                 ]
               },
+              {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "const": "mongo-dump"
+                  },
+                  "config": {
+                    "type": "object",
+                    "properties": {
+                      "command": {
+                        "type": "string"
+                      },
+                      "hostname": {
+                        "type": "string"
+                      },
+                      "port": {
+                        "type": "number"
+                      },
+                      "username": {
+                        "type": "string"
+                      },
+                      "password": {
+                        "anyOf": [
+                          {
+                            "type": "object",
+                            "properties": {
+                              "path": {
+                                "type": "string"
+                              }
+                            },
+                            "additionalProperties": false,
+                            "required": [
+                              "path"
+                            ]
+                          },
+                          {
+                            "type": "string"
+                          }
+                        ]
+                      },
+                      "compress": {
+                        "type": "boolean"
+                      },
+                      "concurrency": {
+                        "type": "number"
+                      }
+                    },
+                    "additionalProperties": false
+                  }
+                },
+                "additionalProperties": false,
+                "required": [
+                  "config",
+                  "name"
+                ]
+              },
               {
                 "type": "object",
                 "properties": {

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 };
 };
@@ -166,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,
@@ -174,6 +220,7 @@ class BackupAction {
         const l = new list_1.Listr3({
             streams: this.options.streams,
             progressManager: pm,
+            gargabeCollector: gc,
         });
         return l
             .add([
@@ -197,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",
@@ -214,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({
@@ -238,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_1.AppError(`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",
@@ -265,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],
@@ -283,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_1.AppError(`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/CopyAction.js

@@ -269,26 +269,48 @@ class CopyAction {
                                             ? sourceRepo.get()
                                             : undefined;
                                     if ($sourceRepo) {
-                                        const copy = await $sourceRepo.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;
+                                        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 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);
+                                        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);
+                                        }
                                     }
                                 },
                             });

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/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;

package/lib/actions/RestoreAction.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 };
 };
@@ -71,27 +116,25 @@ class RestoreAction {
         const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
         const repo = await (0, repository_1.createAndInitRepo)(repoConfig, this.options.verbose);
         let snapshotPath = pkg.restorePath ?? pkg.path;
-        await data.gc.cleanupIfFail(async () => {
-            if (task) {
-                const taskResult = await task.prepareRestore({
-                    options: this.options,
-                    package: pkg,
-                    snapshot,
-                });
-                snapshotPath = taskResult?.snapshotPath;
-            }
-            await (0, fs_1.initEmptyDir)(snapshotPath);
-            if (this.config.minFreeDiskSpace)
-                await (0, fs_1.ensureFreeDiskSpace)([snapshotPath], this.config.minFreeDiskSpace);
-            await repo.restore({
+        if (task) {
+            const taskResult = await task.prepareRestore({
                 options: this.options,
-                snapshot: data.snapshot,
                 package: pkg,
-                snapshotPath: snapshotPath,
-                packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repoConfig.type &&
-                    (!config.names || config.names.includes(repoConfig.name)))?.config,
-                onProgress: data.onProgress,
+                snapshot,
             });
+            snapshotPath = taskResult?.snapshotPath;
+        }
+        await (0, fs_1.initEmptyDir)(snapshotPath);
+        if (this.config.minFreeDiskSpace)
+            await (0, fs_1.ensureFreeDiskSpace)([snapshotPath], this.config.minFreeDiskSpace);
+        await repo.restore({
+            options: this.options,
+            snapshot: data.snapshot,
+            package: pkg,
+            snapshotPath: snapshotPath,
+            packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repoConfig.type &&
+                (!config.names || config.names.includes(repoConfig.name)))?.config,
+            onProgress: data.onProgress,
         });
         return { snapshotPath };
     }
@@ -139,6 +182,7 @@ class RestoreAction {
     }
     async exec() {
         const { options } = this;
+        const gc = new temp_1.GargabeCollector();
         const pm = new progress_1.ProgressManager({
             verbose: options.verbose,
             tty: options.tty,
@@ -147,6 +191,7 @@ class RestoreAction {
         const l = new list_1.Listr3({
             streams: options.streams,
             progressManager: pm,
+            gargabeCollector: gc,
         });
         return l
             .add(l.$task({
@@ -184,48 +229,71 @@ class RestoreAction {
                     },
                     exitOnError: false,
                     run: async (listTask) => {
-                        let pkg = (0, config_1.resolvePackage)((0, config_1.findPackageOrFail)(this.config, snapshot.packageName), {
-                            snapshotId: options.snapshotId,
-                            snapshotDate: snapshot.date,
-                            action: "restore",
-                        });
-                        if (this.options.initial)
-                            pkg = { ...pkg, restorePath: pkg.path };
-                        const gc = new temp_1.GargabeCollector();
-                        const task = pkg.task ? (0, task_1.createTask)(pkg.task) : undefined;
-                        const restore = await this.restore({
-                            gc,
-                            pkg,
-                            task,
-                            snapshot: snapshot,
-                            onProgress: (p) => pm.update(p, (t) => (listTask.output = t)),
-                        });
-                        if (!task)
-                            return await gc.cleanup();
-                        return l.$tasks({
-                            key: "task",
-                            keyIndex: pkg.name,
-                            data: { taskName: pkg.task.name, packageName: pkg.name },
-                            title: {
-                                initial: `Execute task: ${pkg.name} (${pkg.task.name})`,
-                                started: `Executing task: ${pkg.name} (${pkg.task.name})`,
-                                completed: `Task executed: ${pkg.name} (${pkg.task.name})`,
-                                failed: `Task execute failed: ${pkg.name} (${pkg.task.name})`,
-                            },
-                            exitOnError: false,
-                            runWrapper: gc.cleanup.bind(gc),
-                            run: async (listTask) => {
-                                const { snapshotPath } = restore;
-                                (0, assert_1.ok)(snapshotPath);
-                                await task.restore({
-                                    package: pkg,
-                                    options,
-                                    snapshot,
-                                    snapshotPath,
-                                    onProgress: (p) => pm.update(p, (t) => (listTask.output = t)),
-                                });
-                            },
-                        });
+                        const env_1 = { stack: [], error: void 0, hasError: false };
+                        try {
+                            let pkg = (0, config_1.resolvePackage)((0, config_1.findPackageOrFail)(this.config, snapshot.packageName), {
+                                snapshotId: options.snapshotId,
+                                snapshotDate: snapshot.date,
+                                action: "restore",
+                            });
+                            if (this.options.initial)
+                                pkg = { ...pkg, restorePath: pkg.path };
+                            const task = pkg.task ? (0, task_1.createTask)(pkg.task) : undefined;
+                            const progress = __addDisposableResource(env_1, pm.create(listTask), false);
+                            const restoreGc = gc.create();
+                            const restore = await restoreGc.disposeIfFail(() => this.restore({
+                                pkg,
+                                task,
+                                snapshot: snapshot,
+                                onProgress: progress.update,
+                            }));
+                            if (!task)
+                                return await restoreGc.dispose();
+                            return l.$tasks({
+                                key: "task",
+                                keyIndex: pkg.name,
+                                data: { taskName: pkg.task.name, packageName: pkg.name },
+                                title: {
+                                    initial: `Execute task: ${pkg.name} (${pkg.task.name})`,
+                                    started: `Executing task: ${pkg.name} (${pkg.task.name})`,
+                                    completed: `Task executed: ${pkg.name} (${pkg.task.name})`,
+                                    failed: `Task execute failed: ${pkg.name} (${pkg.task.name})`,
+                                },
+                                exitOnError: false,
+                                run: async (listTask) => {
+                                    const env_2 = { stack: [], error: void 0, hasError: false };
+                                    try {
+                                        const _ = __addDisposableResource(env_2, restoreGc.disposeOnFinish(), true);
+                                        const { snapshotPath } = restore;
+                                        (0, assert_1.ok)(snapshotPath);
+                                        const progress = __addDisposableResource(env_2, pm.create(listTask), false);
+                                        await task.restore({
+                                            package: pkg,
+                                            options,
+                                            snapshot,
+                                            snapshotPath,
+                                            onProgress: progress.update,
+                                        });
+                                    }
+                                    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;
+                                    }
+                                },
+                            });
+                        }
+                        catch (e_1) {
+                            env_1.error = e_1;
+                            env_1.hasError = true;
+                        }
+                        finally {
+                            __disposeResources(env_1);
+                        }
                     },
                 }));
             },

package/lib/repositories/DatatruckRepository.d.ts

@@ -12,7 +12,7 @@ export type MetaData = {
         files: number;
         size: number;
         checksum: string;
-    }>;
+    } | undefined>;
 };
 export type DatatruckRepositoryConfig = {
     backend: string;