@datatruck/cli 0.36.1 → 0.36.3

package/lib/actions/BackupAction.js

@@ -149,7 +149,8 @@ class BackupAction {
             let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
             return item.key === "backup" && color ? chalk_1.default.cyan(title) : title;
         };
-        const renderData = (item, color, result = []) => {
+        const renderData = (item, result, format) => {
+            const color = format !== "list";
             const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
             return (0, cli_1.renderListTaskItem)(item, color, {
                 snapshot: (data) => data.id,
@@ -176,6 +177,9 @@ class BackupAction {
                             result += item.data.pruned;
                         return result;
                     }, 0),
+                    ...(format === "list" && {
+                        duration: (0, date_1.duration)(item.elapsed),
+                    }),
                 }),
             });
         };
@@ -187,7 +191,7 @@ class BackupAction {
                 .map((item) => {
                 const icon = (0, cli_1.renderResult)(item.error, false);
                 const title = renderTitle(item);
-                const data = renderData(item, false, result);
+                const data = renderData(item, result, "list");
                 return `${icon} ${title}: ${data}`;
             }),
             table: {
@@ -203,7 +207,7 @@ class BackupAction {
                     .map((item) => [
                     (0, cli_1.renderResult)(item.error),
                     renderTitle(item, true),
-                    renderData(item, true, result),
+                    renderData(item, result, "table"),
                     (0, date_1.duration)(item.elapsed),
                     (0, cli_1.renderError)(item.error, options.verbose),
                 ]),

package/lib/actions/CopyAction.js

@@ -76,7 +76,8 @@ class CopyAction {
             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 renderData = (item, items = [], format) => {
+            const color = format !== "list";
             const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
             return (0, cli_1.renderListTaskItem)(item, color, {
                 snapshots: (data) => data.snapshots.length,
@@ -93,6 +94,9 @@ class CopyAction {
                     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,
+                    ...(format === "list" && {
+                        duration: (0, date_1.duration)(item.elapsed),
+                    }),
                 }),
             });
         };
@@ -102,7 +106,7 @@ class CopyAction {
             list: () => result.map((item) => {
                 const icon = (0, cli_1.renderResult)(item.error, false);
                 const title = renderTitle(item);
-                const data = renderData(item, false, result);
+                const data = renderData(item, result, "list");
                 return `${icon} ${title}: ${data}`;
             }),
             table: {
@@ -116,7 +120,7 @@ class CopyAction {
                 rows: () => result.map((item) => [
                     (0, cli_1.renderResult)(item.error),
                     renderTitle(item, true),
-                    renderData(item, true, result),
+                    renderData(item, result, "table"),
                     (0, date_1.duration)(item.elapsed),
                     (0, cli_1.renderError)(item.error, options.verbose),
                 ]),

package/lib/cli.js

@@ -76,7 +76,8 @@ function makeCommandAction(command) {
                 }
             }
         }
-        process.stdout.write("", () => process.exit(exitCode));
+        await (0, cli_1.waitForStdDrain)(5000);
+        process.exit(exitCode);
     };
 }
 const program = new commander_1.Command();

package/lib/commands/StartServerCommand.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartServerCommand = void 0;
 const ConfigAction_1 = require("../actions/ConfigAction");
+const cli_1 = require("../utils/cli");
 const cron_server_1 = require("../utils/datatruck/cron-server");
 const repository_server_1 = require("../utils/datatruck/repository-server");
 const error_1 = require("../utils/error");
@@ -22,7 +23,7 @@ class StartServerCommand extends CommandAbstract_1.CommandAbstract {
             });
             const port = repositoryOptions.listen?.port ?? 8888;
             const address = repositoryOptions.listen?.address ?? "127.0.0.1";
-            console.info(`Listening datatruck repository on http://${address}:${port}`);
+            (0, cli_1.logJson)("datatruck-server", `listening server on http://${address}:${port}`);
             server.on("error", (error) => {
                 console.error(`SERVER ERROR`, error);
                 process.exit(1);
@@ -30,6 +31,7 @@ class StartServerCommand extends CommandAbstract_1.CommandAbstract {
             server.listen(port, address);
         }
         const cronOptions = config.server?.cron || {};
+        const cronJobs = cronOptions.actions || [];
         if (cronOptions.enabled ?? true) {
             if (typeof this.configPath !== "string")
                 throw new error_1.AppError(`Config path is required by cron server`);
@@ -39,7 +41,9 @@ class StartServerCommand extends CommandAbstract_1.CommandAbstract {
                 configPath: this.configPath,
             });
             server.start();
-            console.info(`Cron server started`);
+            (0, cli_1.logJson)("cron-server", `server started`, {
+                jobs: cronJobs.length,
+            });
         }
         process.on("SIGINT", () => process.exit(1));
         process.on("SIGTERM", () => process.exit(1));

package/lib/tasks/MysqlDumpTask.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;
+});
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDumpTask = exports.mysqlDumpTaskName = void 0;
 const async_1 = require("../utils/async");
@@ -24,149 +69,161 @@ const suffix = {
 };
 class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
     async backup(data) {
-        const compressAndClean = this.config.compress
-            ? async (path) => {
-                await (0, tar_1.createTar)({
-                    include: [(0, path_1.relative)(snapshotPath, path)],
-                    output: `${path}.tar.gz`,
-                    path: (0, path_1.dirname)(path),
-                    compress: this.config.compress,
-                    verbose: data.options.verbose,
-                });
-                await (0, promises_1.rm)(path);
-            }
-            : undefined;
-        const snapshotPath = data.package.path ??
-            (await (0, temp_1.mkTmpDir)(exports.mysqlDumpTaskName, "task", "backup", "snapshot"));
-        await (0, fs_1.mkdirIfNotExists)(snapshotPath);
-        await (0, fs_1.ensureEmptyDir)(snapshotPath);
-        const sql = await (0, mysql_1.createMysqlCli)({
-            ...this.config,
-            database: undefined,
-            verbose: data.options.verbose,
-        });
-        const tableNames = await sql.fetchTableNames(this.config.database, this.config.includeTables, this.config.excludeTables);
-        const concurrency = this.config.concurrency ?? 4;
-        const dataFormat = this.config.dataFormat ?? "sql";
-        const sharedDir = dataFormat === "csv"
-            ? await sql.initSharedDir(this.config.csvSharedPath)
-            : undefined;
-        if (this.config.oneFileByTable || sharedDir) {
-            await (0, async_1.runParallel)({
-                items: tableNames,
-                concurrency,
-                onChange: ({ processed: proccesed, buffer }) => data.onProgress({
-                    relative: {
-                        description: buffer.size > 1 ? `Exporting (${buffer.size})` : "Exporting",
-                        payload: [...buffer.keys()].join(", "),
-                    },
-                    absolute: {
-                        total: tableNames.length,
-                        current: proccesed,
-                        percent: (0, math_1.progressPercent)(tableNames.length, proccesed),
-                    },
-                }),
-                onItem: async ({ item: tableName, index, controller }) => {
-                    if (sharedDir) {
-                        const tableSharedPath = (0, path_1.join)(sharedDir, `tmp-dtt-backup-${data.snapshot.id.slice(0, 8)}-${tableName}`);
-                        if (data.options.verbose) {
-                            (0, cli_1.logExec)("mkdir", ["-p", tableSharedPath]);
-                            (0, cli_1.logExec)("chmod", ["777", tableSharedPath]);
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            const compressAndClean = this.config.compress
+                ? async (path) => {
+                    await (0, tar_1.createTar)({
+                        include: [(0, path_1.relative)(snapshotPath, path)],
+                        output: `${path}.tar.gz`,
+                        path: (0, path_1.dirname)(path),
+                        compress: this.config.compress,
+                        verbose: data.options.verbose,
+                    });
+                    await (0, promises_1.rm)(path);
+                }
+                : undefined;
+            const snapshotPath = data.package.path ??
+                (await (0, temp_1.mkTmpDir)(exports.mysqlDumpTaskName, "task", "backup", "snapshot"));
+            await (0, fs_1.mkdirIfNotExists)(snapshotPath);
+            await (0, fs_1.ensureEmptyDir)(snapshotPath);
+            const sql = __addDisposableResource(env_1, await (0, mysql_1.createMysqlCli)({
+                ...this.config,
+                database: undefined,
+                verbose: data.options.verbose,
+            }), true);
+            const tableNames = await sql.fetchTableNames(this.config.database, this.config.includeTables, this.config.excludeTables);
+            const concurrency = this.config.concurrency ?? 4;
+            const dataFormat = this.config.dataFormat ?? "sql";
+            const sharedDir = dataFormat === "csv"
+                ? await sql.initSharedDir(this.config.csvSharedPath)
+                : undefined;
+            if (this.config.oneFileByTable || sharedDir) {
+                await (0, async_1.runParallel)({
+                    items: tableNames,
+                    concurrency,
+                    onChange: ({ processed: proccesed, buffer }) => data.onProgress({
+                        relative: {
+                            description: buffer.size > 1 ? `Exporting (${buffer.size})` : "Exporting",
+                            payload: [...buffer.keys()].join(", "),
+                        },
+                        absolute: {
+                            total: tableNames.length,
+                            current: proccesed,
+                            percent: (0, math_1.progressPercent)(tableNames.length, proccesed),
+                        },
+                    }),
+                    onItem: async ({ item: tableName, index, controller }) => {
+                        if (sharedDir) {
+                            const tableSharedPath = (0, path_1.join)(sharedDir, `tmp-dtt-backup-${data.snapshot.id.slice(0, 8)}-${tableName}`);
+                            if (data.options.verbose) {
+                                (0, cli_1.logExec)("mkdir", ["-p", tableSharedPath]);
+                                (0, cli_1.logExec)("chmod", ["777", tableSharedPath]);
+                            }
+                            await (0, promises_1.mkdir)(tableSharedPath, { recursive: true });
+                            try {
+                                await (0, promises_1.chmod)(tableSharedPath, 0o777);
+                                await sql.csvDump({
+                                    sharedPath: tableSharedPath,
+                                    items: [tableName],
+                                    database: this.config.database,
+                                    controller,
+                                });
+                                const files = await (0, promises_1.readdir)(tableSharedPath);
+                                const schemaFile = `${tableName}.sql`;
+                                const dataFile = `${tableName}.txt`;
+                                const successCsvDump = files.length === 2 &&
+                                    files.every((file) => file === schemaFile || file === dataFile);
+                                if (!successCsvDump)
+                                    throw new error_1.AppError(`Invalid csv dump files: ${files.join(", ")}`);
+                                const schemaPath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.tableSchema}`);
+                                await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, schemaFile), schemaPath);
+                                await compressAndClean?.(schemaPath);
+                                const tablePath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.tableData}`);
+                                await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, dataFile), tablePath);
+                                await compressAndClean?.(tablePath);
+                            }
+                            finally {
+                                await (0, promises_1.rm)(tableSharedPath, { recursive: true });
+                            }
                         }
-                        await (0, promises_1.mkdir)(tableSharedPath, { recursive: true });
-                        try {
-                            await (0, promises_1.chmod)(tableSharedPath, 0o777);
-                            await sql.csvDump({
-                                sharedPath: tableSharedPath,
+                        else {
+                            const outPath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.table}`);
+                            await sql.dump({
+                                output: outPath,
                                 items: [tableName],
                                 database: this.config.database,
                                 controller,
+                                ...(concurrency === 1 && {
+                                    onProgress(progress) {
+                                        data.onProgress({
+                                            relative: {
+                                                description: "Exporting",
+                                                payload: tableName,
+                                                current: progress.totalBytes,
+                                                format: "size",
+                                            },
+                                            absolute: {
+                                                total: tableNames.length,
+                                                current: index,
+                                                percent: (0, math_1.progressPercent)(tableNames.length, index),
+                                            },
+                                        });
+                                    },
+                                }),
                             });
-                            const files = await (0, promises_1.readdir)(tableSharedPath);
-                            const schemaFile = `${tableName}.sql`;
-                            const dataFile = `${tableName}.txt`;
-                            const successCsvDump = files.length === 2 &&
-                                files.every((file) => file === schemaFile || file === dataFile);
-                            if (!successCsvDump)
-                                throw new error_1.AppError(`Invalid csv dump files: ${files.join(", ")}`);
-                            const schemaPath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.tableSchema}`);
-                            await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, schemaFile), schemaPath);
-                            await compressAndClean?.(schemaPath);
-                            const tablePath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.tableData}`);
-                            await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, dataFile), tablePath);
-                            await compressAndClean?.(tablePath);
+                            await sql.assertDumpFile(outPath);
+                            await compressAndClean?.(outPath);
                         }
-                        finally {
-                            await (0, promises_1.rm)(tableSharedPath, { recursive: true });
-                        }
-                    }
-                    else {
-                        const outPath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.table}`);
-                        await sql.dump({
-                            output: outPath,
-                            items: [tableName],
-                            database: this.config.database,
-                            controller,
-                            ...(concurrency === 1 && {
-                                onProgress(progress) {
-                                    data.onProgress({
-                                        relative: {
-                                            description: "Exporting",
-                                            payload: tableName,
-                                            current: progress.totalBytes,
-                                            format: "size",
-                                        },
-                                        absolute: {
-                                            total: tableNames.length,
-                                            current: index,
-                                            percent: (0, math_1.progressPercent)(tableNames.length, index),
-                                        },
-                                    });
-                                },
-                            }),
-                        });
-                        await sql.assertDumpFile(outPath);
-                        await compressAndClean?.(outPath);
-                    }
-                },
-            });
-        }
-        else {
-            data.onProgress({
-                relative: { description: "Exporting" },
-            });
-            const outPath = (0, path_1.join)(snapshotPath, `${this.config.database}${suffix.database}`);
-            await sql.dump({
-                output: outPath,
-                items: tableNames,
-                database: this.config.database,
-                onProgress: (progress) => data.onProgress({
-                    absolute: {
-                        description: "Exporting in single file",
-                        current: progress.totalBytes,
-                        format: "size",
                     },
-                }),
-            });
-            await sql.assertDumpFile(outPath);
-            await compressAndClean?.(outPath);
+                });
+            }
+            else {
+                data.onProgress({
+                    relative: { description: "Exporting" },
+                });
+                const outPath = (0, path_1.join)(snapshotPath, `${this.config.database}${suffix.database}`);
+                await sql.dump({
+                    output: outPath,
+                    items: tableNames,
+                    database: this.config.database,
+                    onProgress: (progress) => data.onProgress({
+                        absolute: {
+                            description: "Exporting in single file",
+                            current: progress.totalBytes,
+                            format: "size",
+                        },
+                    }),
+                });
+                await sql.assertDumpFile(outPath);
+                await compressAndClean?.(outPath);
+            }
+            if (this.config.storedPrograms ?? true) {
+                data.onProgress({
+                    relative: { description: "Exporting stored programs" },
+                });
+                const outPath = (0, path_1.join)(snapshotPath, `${this.config.database}${suffix.stored}`);
+                await sql.dump({
+                    database: this.config.database,
+                    output: outPath,
+                    onlyStoredPrograms: true,
+                });
+                await sql.assertDumpFile(outPath);
+                await compressAndClean?.(outPath);
+            }
+            return {
+                snapshotPath,
+            };
         }
-        if (this.config.storedPrograms ?? true) {
-            data.onProgress({
-                relative: { description: "Exporting stored programs" },
-            });
-            const outPath = (0, path_1.join)(snapshotPath, `${this.config.database}${suffix.stored}`);
-            await sql.dump({
-                database: this.config.database,
-                output: outPath,
-                onlyStoredPrograms: true,
-            });
-            await sql.assertDumpFile(outPath);
-            await compressAndClean?.(outPath);
+        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;
         }
-        return {
-            snapshotPath,
-        };
     }
     async prepareRestore(data) {
         return {
@@ -175,145 +232,157 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
         };
     }
     async restore(data) {
-        const sql = await (0, mysql_1.createMysqlCli)({
-            ...this.config,
-            database: undefined,
-            verbose: data.options.verbose,
-        });
-        const snapshotPath = data.snapshotPath;
-        const params = {
-            packageName: data.package.name,
-            snapshotId: data.options.snapshotId,
-            snapshotDate: data.snapshot.date,
-            action: "restore",
-            database: undefined,
-        };
-        const database = {
-            name: (0, config_1.resolveDatabaseName)(this.config.database, params),
-        };
-        if (this.config.targetDatabase && !data.options.initial)
-            database.name = (0, config_1.resolveDatabaseName)(this.config.targetDatabase.name, {
-                ...params,
-                database: database.name,
-            });
-        const [files, compressed] = (0, fs_1.groupFiles)(await (0, fs_1.readDir)(snapshotPath), Object.values(suffix));
-        // Database check
-        if (files.some((f) => f.endsWith(suffix.database)) &&
-            !(await sql.isDatabaseEmpty(database.name)))
-            throw new error_1.AppError(`Target database is not empty: ${database.name}`);
-        // Table check
-        const restoreTables = [
-            ...new Set(...files
-                .filter((f) => (0, string_1.endsWith)(f, [suffix.table, suffix.tableSchema, suffix.tableData]))
-                .map((f) => f.split(".")[0])),
-        ];
-        const serverTables = await sql.fetchTableNames(database.name);
-        const errorTables = restoreTables.filter((v) => serverTables.includes(v));
-        if (errorTables.length)
-            throw new error_1.AppError(`Target table already exists: ${errorTables.join(", ")}`);
-        // Data check
-        const dataFiles = files.filter((f) => f.endsWith(suffix.tableData));
-        const sharedDir = dataFiles.length
-            ? await sql.initSharedDir(this.config.csvSharedPath)
-            : undefined;
-        await sql.createDatabase(database);
-        if (data.options.verbose)
-            (0, cli_1.logExec)("readdir", [snapshotPath]);
-        const concurrency = this.config.concurrency ?? 1;
-        let processed = 0;
-        await (0, async_1.runParallel)({
-            items: files.filter((f) => !f.endsWith(suffix.tableData)),
-            concurrency,
-            onFinished: () => {
-                processed++;
-            },
-            onChange: ({ buffer }) => data.onProgress({
-                relative: {
-                    description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
-                    payload: [...buffer.keys()].join(", "),
-                },
-                absolute: {
-                    total: files.length,
-                    current: processed,
-                    percent: (0, math_1.progressPercent)(files.length, processed),
+        const env_2 = { stack: [], error: void 0, hasError: false };
+        try {
+            const sql = __addDisposableResource(env_2, await (0, mysql_1.createMysqlCli)({
+                ...this.config,
+                database: undefined,
+                verbose: data.options.verbose,
+            }), true);
+            const snapshotPath = data.snapshotPath;
+            const params = {
+                packageName: data.package.name,
+                snapshotId: data.options.snapshotId,
+                snapshotDate: data.snapshot.date,
+                action: "restore",
+                database: undefined,
+            };
+            const database = {
+                name: (0, config_1.resolveDatabaseName)(this.config.database, params),
+            };
+            if (this.config.targetDatabase && !data.options.initial)
+                database.name = (0, config_1.resolveDatabaseName)(this.config.targetDatabase.name, {
+                    ...params,
+                    database: database.name,
+                });
+            const [files, compressed] = (0, fs_1.groupFiles)(await (0, fs_1.readDir)(snapshotPath), Object.values(suffix));
+            // Database check
+            if (files.some((f) => f.endsWith(suffix.database)) &&
+                !(await sql.isDatabaseEmpty(database.name)))
+                throw new error_1.AppError(`Target database is not empty: ${database.name}`);
+            // Table check
+            const restoreTables = [
+                ...new Set(...files
+                    .filter((f) => (0, string_1.endsWith)(f, [suffix.table, suffix.tableSchema, suffix.tableData]))
+                    .map((f) => f.split(".")[0])),
+            ];
+            const serverTables = await sql.fetchTableNames(database.name);
+            const errorTables = restoreTables.filter((v) => serverTables.includes(v));
+            if (errorTables.length)
+                throw new error_1.AppError(`Target table already exists: ${errorTables.join(", ")}`);
+            // Data check
+            const dataFiles = files.filter((f) => f.endsWith(suffix.tableData));
+            const sharedDir = dataFiles.length
+                ? await sql.initSharedDir(this.config.csvSharedPath)
+                : undefined;
+            await sql.createDatabase(database);
+            if (data.options.verbose)
+                (0, cli_1.logExec)("readdir", [snapshotPath]);
+            const concurrency = this.config.concurrency ?? 1;
+            let processed = 0;
+            await (0, async_1.runParallel)({
+                items: files.filter((f) => !f.endsWith(suffix.tableData)),
+                concurrency,
+                onFinished: () => {
+                    processed++;
                 },
-            }),
-            onItem: async ({ item: file, controller }) => {
-                let path = (0, path_1.join)(snapshotPath, file);
-                const tempDir = compressed[file]
-                    ? await (0, temp_1.useTempDir)(exports.mysqlDumpTaskName, "task", "restore", "decompress")
-                    : undefined;
-                try {
-                    if (tempDir) {
-                        await (0, tar_1.extractTar)({
-                            input: (0, path_1.join)(snapshotPath, compressed[file]),
-                            output: tempDir.path,
-                            decompress: true,
-                            verbose: data.options.verbose,
+                onChange: ({ buffer }) => data.onProgress({
+                    relative: {
+                        description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
+                        payload: [...buffer.keys()].join(", "),
+                    },
+                    absolute: {
+                        total: files.length,
+                        current: processed,
+                        percent: (0, math_1.progressPercent)(files.length, processed),
+                    },
+                }),
+                onItem: async ({ item: file, controller }) => {
+                    let path = (0, path_1.join)(snapshotPath, file);
+                    const tempDir = compressed[file]
+                        ? await (0, temp_1.useTempDir)(exports.mysqlDumpTaskName, "task", "restore", "decompress")
+                        : undefined;
+                    try {
+                        if (tempDir) {
+                            await (0, tar_1.extractTar)({
+                                input: (0, path_1.join)(snapshotPath, compressed[file]),
+                                output: tempDir.path,
+                                decompress: true,
+                                verbose: data.options.verbose,
+                            });
+                            path = await (0, fs_1.ensureSingleFile)(tempDir.path);
+                        }
+                        await sql.importFile({
+                            path,
+                            database: database.name,
+                            controller,
                         });
-                        path = await (0, fs_1.ensureSingleFile)(tempDir.path);
                     }
-                    await sql.importFile({
-                        path,
-                        database: database.name,
-                        controller,
-                    });
-                }
-                finally {
-                    await tempDir?.[Symbol.asyncDispose]();
-                }
-            },
-        });
-        await (0, async_1.runParallel)({
-            items: dataFiles,
-            concurrency,
-            onFinished: () => {
-                processed++;
-            },
-            onChange: ({ buffer }) => data.onProgress({
-                relative: {
-                    description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
-                    payload: [...buffer.keys()].join(", "),
+                    finally {
+                        await tempDir?.[Symbol.asyncDispose]();
+                    }
                 },
-                absolute: {
-                    total: files.length,
-                    current: processed,
-                    percent: (0, math_1.progressPercent)(files.length, processed),
+            });
+            await (0, async_1.runParallel)({
+                items: dataFiles,
+                concurrency,
+                onFinished: () => {
+                    processed++;
                 },
-            }),
-            onItem: async ({ item: file, controller }) => {
-                const id = data.snapshot.id.slice(0, 8);
-                const tableName = file.slice(0, suffix.tableData.length * -1);
-                const sharedName = `tmp-dtt-restore-${id}-${tableName}.data.csv`;
-                const temp = (0, temp_1.useTempFile)((0, path_1.join)(sharedDir, sharedName));
-                try {
-                    let csvFile = temp.path;
-                    if (compressed[file]) {
-                        await (0, fs_1.mkdirIfNotExists)(temp.path);
-                        await (0, tar_1.extractTar)({
-                            input: (0, path_1.join)(snapshotPath, compressed[file]),
-                            output: temp.path,
-                            decompress: true,
-                            verbose: data.options.verbose,
+                onChange: ({ buffer }) => data.onProgress({
+                    relative: {
+                        description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
+                        payload: [...buffer.keys()].join(", "),
+                    },
+                    absolute: {
+                        total: files.length,
+                        current: processed,
+                        percent: (0, math_1.progressPercent)(files.length, processed),
+                    },
+                }),
+                onItem: async ({ item: file, controller }) => {
+                    const id = data.snapshot.id.slice(0, 8);
+                    const tableName = file.slice(0, suffix.tableData.length * -1);
+                    const sharedName = `tmp-dtt-restore-${id}-${tableName}.data.csv`;
+                    const temp = (0, temp_1.useTempFile)((0, path_1.join)(sharedDir, sharedName));
+                    try {
+                        let csvFile = temp.path;
+                        if (compressed[file]) {
+                            await (0, fs_1.mkdirIfNotExists)(temp.path);
+                            await (0, tar_1.extractTar)({
+                                input: (0, path_1.join)(snapshotPath, compressed[file]),
+                                output: temp.path,
+                                decompress: true,
+                                verbose: data.options.verbose,
+                            });
+                            csvFile = await (0, fs_1.ensureSingleFile)(temp.path);
+                        }
+                        else {
+                            const sourceFile = (0, path_1.join)(snapshotPath, file);
+                            await (0, fs_1.safeRename)(sourceFile, temp.path);
+                        }
+                        await sql.importCsvFile({
+                            path: csvFile,
+                            database: database.name,
+                            table: tableName,
+                            controller,
                         });
-                        csvFile = await (0, fs_1.ensureSingleFile)(temp.path);
                     }
-                    else {
-                        const sourceFile = (0, path_1.join)(snapshotPath, file);
-                        await (0, fs_1.safeRename)(sourceFile, temp.path);
+                    finally {
+                        await temp[Symbol.asyncDispose]();
                     }
-                    await sql.importCsvFile({
-                        path: csvFile,
-                        database: database.name,
-                        table: tableName,
-                        controller,
-                    });
-                }
-                finally {
-                    await temp[Symbol.asyncDispose]();
-                }
-            },
-        });
+                },
+            });
+        }
+        catch (e_2) {
+            env_2.error = e_2;
+            env_2.hasError = true;
+        }
+        finally {
+            const result_2 = __disposeResources(env_2);
+            if (result_2)
+                await result_2;
+        }
     }
 }
 exports.MysqlDumpTask = MysqlDumpTask;

package/lib/utils/cli.d.ts

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 import { Listr3TaskResultEnd } from "./list";
+import chalk from "chalk";
 export declare const showCursorCommand = "\u001B[?25h";
 export declare function renderProgressBar(progress: number, size?: number, subprogress?: number): string;
 export declare function logExec(command: string, argv?: string[], env?: NodeJS.ProcessEnv, logToStderr?: boolean): void;
@@ -29,3 +30,7 @@ export declare function stringifyOptions<T1, T2 extends {
     [K in keyof T1]: unknown;
 }>(options: OptionsConfig<T1, T2>, object: any): string[];
 export declare function confirm(message: string): Promise<unknown>;
+export declare function waitForStdDrain(ms?: number): Promise<void>;
+export declare function colorizeValue(value: unknown, color?: typeof chalk.ForegroundColor): string;
+export declare function colorizeObject(input: Record<string, any>): string;
+export declare function logJson(ctx: string, msg: string, data?: any): void;

package/lib/utils/cli.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.confirm = exports.stringifyOptions = exports.parseOptions = exports.renderObject = exports.renderListTaskItem = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
+exports.logJson = exports.colorizeObject = exports.colorizeValue = exports.waitForStdDrain = exports.confirm = exports.stringifyOptions = exports.parseOptions = exports.renderObject = exports.renderListTaskItem = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
 const error_1 = require("./error");
 const chalk_1 = __importDefault(require("chalk"));
 const chalk_2 = require("chalk");
@@ -149,3 +149,47 @@ function confirm(message) {
     });
 }
 exports.confirm = confirm;
+async function waitForStdDrain(ms) {
+    await Promise.all([process.stdout, process.stderr].map((stream) => new Promise((resolve) => {
+        {
+            const finish = () => {
+                clearTimeout(timeout);
+                resolve();
+            };
+            const timeout = ms ? setTimeout(finish, ms) : undefined;
+            const drained = stream.write("", finish);
+            if (drained)
+                finish();
+        }
+    })));
+}
+exports.waitForStdDrain = waitForStdDrain;
+function colorizeValue(value, color) {
+    const json = JSON.stringify(value);
+    return color ? chalk_1.default[color](json) : json;
+}
+exports.colorizeValue = colorizeValue;
+function colorizeObject(input) {
+    const object = {};
+    for (const key in input) {
+        const value = input[key];
+        object[colorizeValue(key)] =
+            typeof value === "object" && !!value && !Array.isArray(value)
+                ? colorizeObject(value)
+                : colorizeValue(value, "green");
+    }
+    const values = Object.entries(object)
+        .map(([key, value]) => `${key}: ${value}`)
+        .join(", ");
+    return `{ ${values} }`;
+}
+exports.colorizeObject = colorizeObject;
+function logJson(ctx, msg, data) {
+    const json = colorizeObject({
+        ctx,
+        msg,
+        data,
+    });
+    console.log(json);
+}
+exports.logJson = logJson;

package/lib/utils/datatruck/cron-server.js

@@ -26,8 +26,7 @@ function createJobs(actions, worker) {
 }
 function createCronServer(options, config) {
     const worker = async (action, index) => {
-        if (config.log)
-            console.info(`> [job] ${index} - ${action.name}`);
+        let pid = 0;
         try {
             const Command = command_1.datatruckCommandMap[action.name];
             const command = new Command({ config: { packages: [], repositories: [] } }, {});
@@ -35,19 +34,24 @@ function createCronServer(options, config) {
                 ? ({ ...action.options, confirm: true })
                 : action.options);
             const [node, bin] = process.argv;
-            await async_process_1.AsyncProcess.exec(node, [
+            const p = new async_process_1.AsyncProcess(node, [
                 process.env.pm_exec_path ?? bin,
                 "-c",
                 config.configPath,
                 action.name,
                 ...cliOptions,
-            ], { $log: config.verbose });
+            ], { $log: config.verbose, $exitCode: false });
+            pid = p.child.pid || 0;
             if (config.log)
-                console.info(`< [job] ${index} - ${action.name}`);
+                (0, cli_1.logJson)("cron-server", `${action.name} started`, { pid });
+            const exitCode = await p.waitForClose();
+            if (config.log)
+                (0, cli_1.logJson)("cron-server", `${action.name} finished`, { pid, exitCode });
         }
         catch (error) {
             if (config.log)
-                console.error(`< [job] ${index} - ${action.name}`, error);
+                (0, cli_1.logJson)("cron-server", `${action.name} failed`, { pid });
+            console.error(error);
         }
     };
     let jobs = createJobs(options.actions || [], worker);
@@ -55,12 +59,14 @@ function createCronServer(options, config) {
         onRead: () => ConfigAction_1.ConfigAction.findAndParseFile(config.configPath),
         onCheck: (prev, current) => (0, string_1.compareJsons)(prev, current),
         onError: (error) => {
-            if (config.log)
-                console.error(`< [jobs] update error`, error);
+            if (config.log) {
+                (0, cli_1.logJson)("cron-server", "job update error");
+                console.error(error);
+            }
         },
         onChange: (data) => {
             if (config.log)
-                console.info(`[jobs] updated`);
+                (0, cli_1.logJson)("cron-server", "jobs updated");
             handler.stop();
             const cron = data?.server?.cron;
             const enabled = cron?.enabled ?? true;

package/lib/utils/datatruck/repository-server.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDatatruckRepositoryServer = exports.headerKey = void 0;
 const ConfigAction_1 = require("../../actions/ConfigAction");
+const cli_1 = require("../cli");
 const http_1 = require("../http");
 const virtual_fs_1 = require("../virtual-fs");
 const fs_1 = require("fs");
@@ -77,7 +78,10 @@ function createDatatruckRepositoryServer(inOptions, config = {}) {
                 return res.end();
             }
             if (config.log)
-                console.info(`> [repository] ${repository} - ${req.url}`);
+                (0, cli_1.logJson)("repository-server", "request", {
+                    repository,
+                    url: req.url,
+                });
             const fs = new virtual_fs_1.LocalFs({
                 backend: backend.path,
             });
@@ -123,12 +127,18 @@ function createDatatruckRepositoryServer(inOptions, config = {}) {
                     res.write(JSON.stringify(json));
             }
             if (config.log)
-                console.info(`< [repository] ${repository} - ${action}`);
+                (0, cli_1.logJson)("repository-server", "request finished", {
+                    url: req.url,
+                });
             res.end();
         }
         catch (error) {
-            if (config.log)
-                console.error(`< [repository] ${req.url}`, error);
+            if (config.log) {
+                (0, cli_1.logJson)("repository-server", "request failed", {
+                    url: req.url,
+                });
+                console.error(error);
+            }
             res.statusCode = 500;
             res.statusMessage = error.message;
             res.end();

package/lib/utils/mysql.d.ts

@@ -11,6 +11,7 @@ export type MysqlCliOptions = {
 };
 export declare function assertDumpFile(path: string): Promise<void>;
 export declare function createMysqlCli(options: MysqlCliOptions): Promise<{
+    [Symbol.asyncDispose](): Promise<void>;
     options: MysqlCliOptions;
     initSharedDir: (sharedDir?: string) => Promise<string>;
     args: () => Promise<string[]>;

package/lib/utils/mysql.js

@@ -258,6 +258,9 @@ async function createMysqlCli(options) {
         await sql.changeUser({ database: name });
     }
     return {
+        async [Symbol.asyncDispose]() {
+            await sql.end();
+        },
         options,
         initSharedDir,
         args,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.36.1",
+  "version": "0.36.3",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {
@@ -26,18 +26,18 @@
     "config.schema.json"
   ],
   "dependencies": {
-    "@supercharge/promise-pool": "^3.1.0",
+    "@supercharge/promise-pool": "^3.1.1",
     "ajv": "^8.12.0",
     "async": "^3.2.5",
     "chalk": "^4.1.2",
-    "commander": "^11.1.0",
-    "croner": "^8.0.0",
+    "commander": "^12.0.0",
+    "croner": "^8.0.1",
     "dayjs": "^1.11.10",
     "fast-folder-size": "^2.2.0",
     "fast-glob": "^3.3.2",
-    "listr2": "^8.0.1",
+    "listr2": "^8.0.2",
     "micromatch": "^4.0.5",
-    "mysql2": "^3.7.0",
+    "mysql2": "^3.9.1",
     "tty-table": "^4.2.3",
     "yaml": "^2.3.4"
   },