@datatruck/cli 0.27.0 → 0.29.0

package/Task/MariadbTask.d.ts

@@ -1,4 +1,4 @@
-import { BackupDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
+import { TaskBackupData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 import { JSONSchema7 } from "json-schema";
 export type MariadbTaskConfigType = {
     command?: string;
@@ -28,9 +28,8 @@ export declare const mariadbTaskDefinition: JSONSchema7;
 export declare class MariadbTask extends TaskAbstract<MariadbTaskConfigType> {
     protected verbose?: boolean;
     private get command();
-    onBeforeBackup(): Promise<{
-        targetPath: string;
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
     }>;
-    onBackup(data: BackupDataType): Promise<void>;
-    onRestore(data: RestoreDataType): Promise<void>;
+    restore(data: TaskRestoreData): Promise<void>;
 }

package/Task/MariadbTask.js

@@ -7,6 +7,7 @@ const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
 const process_1 = require("../utils/process");
 const tar_1 = require("../utils/tar");
+const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
 const assert_1 = require("assert");
 const fs_2 = require("fs");
@@ -105,19 +106,13 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
     get command() {
         return this.config.command ?? "mariabackup";
     }
-    async onBeforeBackup() {
-        return {
-            targetPath: await this.mkTmpDir(MariadbTask.name),
-        };
-    }
-    async onBackup(data) {
+    async backup(data) {
         this.verbose = data.options.verbose;
         const config = this.config;
         const command = this.command;
         const sourcePath = data.package.path;
-        const targetPath = data.targetPath;
+        const snapshotPath = await (0, temp_1.mkTmpDir)(exports.mariadbTaskName, "task", "backup", "snapshot");
         (0, assert_1.ok)(typeof sourcePath === "string");
-        (0, assert_1.ok)(typeof targetPath === "string");
         const { parallel, compress } = normalizeConfig(config);
         const args = [
             `--backup`,
@@ -135,7 +130,7 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             args.push(`--stream=xbstream`);
         }
         else {
-            args.push(`--target-dir=${targetPath}`);
+            args.push(`--target-dir=${snapshotPath}`);
         }
         if (config.includeDatabases)
             args.push(`--databases=${config.includeDatabases.join(" ")}`);
@@ -164,7 +159,7 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
                 const matches = pathRegex.exec(text);
                 if (matches)
                     current++;
-                await data.onProgress({
+                data.onProgress({
                     relative: {
                         payload: matches ? matches[1] : text,
                     },
@@ -177,9 +172,9 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             }
         };
         const stats = { xbFiles: total };
-        await (0, promises_1.writeFile)((0, path_1.join)(targetPath, "stats.dtt.json"), JSON.stringify(stats));
+        await (0, promises_1.writeFile)((0, path_1.join)(snapshotPath, "stats.dtt.json"), JSON.stringify(stats));
         if (compress) {
-            const p0 = (0, fs_2.createWriteStream)((0, path_1.join)(targetPath, "db.xb.gz"));
+            const p0 = (0, fs_2.createWriteStream)((0, path_1.join)(snapshotPath, "db.xb.gz"));
             p1 = (0, process_1.createProcess)(command, args, {
                 $log: {
                     exec: this.verbose,
@@ -210,23 +205,22 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
                 $onExitCode: (code) => `Exit code: ${code} - ${lastLineText}`,
             });
             await p1;
-            await (0, process_1.exec)(command, [`--prepare`, `--target-dir=${targetPath}`], undefined, {
+            await (0, process_1.exec)(command, [`--prepare`, `--target-dir=${snapshotPath}`], undefined, {
                 log: this.verbose,
                 stderr: { onData: () => { } },
             });
         }
+        return { snapshotPath };
     }
-    async onRestore(data) {
+    async restore(data) {
         this.verbose = data.options.verbose;
-        const restorePath = data.package.restorePath;
-        (0, assert_1.ok)(typeof restorePath === "string");
-        await (0, fs_1.mkdirIfNotExists)(restorePath);
+        const snapshotPath = data.snapshotPath;
         const removeFiles = [];
         let files = [];
         const reloadFiles = async (data = {}) => {
             if (data.removeFile)
                 removeFiles.push(data.removeFile);
-            return (files = (await (0, fs_1.readDir)(restorePath)).filter((v) => !removeFiles.includes(v)));
+            return (files = (await (0, fs_1.readDir)(snapshotPath)).filter((v) => !removeFiles.includes(v)));
         };
         await reloadFiles();
         const absolute = {
@@ -241,7 +235,7 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         const statsFile = files.find((file) => file === "stats.dtt.json");
         let stats;
         if (statsFile) {
-            const statsFilePath = (0, path_1.join)(restorePath, statsFile);
+            const statsFilePath = (0, path_1.join)(snapshotPath, statsFile);
             const statsBuffer = await (0, promises_1.readFile)(statsFilePath);
             stats = JSON.parse(statsBuffer.toString());
             await reloadFiles({ removeFile: statsFile });
@@ -253,16 +247,16 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         if (files.length === 1 && zipFile) {
             absolute.description = "Extracting";
             absolute.payload = zipFile;
-            await data.onProgress({
+            data.onProgress({
                 absolute,
             });
             await (0, tar_1.extractTar)({
-                input: (0, path_1.join)(restorePath, zipFile),
+                input: (0, path_1.join)(snapshotPath, zipFile),
                 decompress: true,
-                output: restorePath,
+                output: snapshotPath,
                 verbose: this.verbose,
-                async onEntry(item) {
-                    await data.onProgress({
+                onEntry(item) {
+                    data.onProgress({
                         absolute,
                         relative: {
                             payload: item.path,
@@ -279,23 +273,23 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         absolute.current++;
         absolute.percent = (0, math_1.progressPercent)(absolute.total, absolute.current);
         if (files.length === 1 && xbFile) {
-            const xbFilePath = (0, path_1.join)(restorePath, xbFile);
+            const xbFilePath = (0, path_1.join)(snapshotPath, xbFile);
             const xbStream = (0, fs_2.createReadStream)(xbFilePath);
             removeFiles.push(xbFile);
             absolute.description = "Extracting stream";
             absolute.payload = xbFile;
-            await data.onProgress({
+            data.onProgress({
                 absolute,
             });
             let currentXbFiles = 0;
             const { parallel } = normalizeConfig({ parallel: this.config.parallel });
-            const p1 = (0, process_1.createProcess)("mbstream", ["-x", "-C", restorePath, "-v", "-p", parallel], {
+            const p1 = (0, process_1.createProcess)("mbstream", ["-x", "-C", snapshotPath, "-v", "-p", parallel], {
                 $log: this.verbose,
                 $stderr: {
                     parseLines: true,
-                    async onData(line) {
+                    onData(line) {
                         const { text: path } = parseLine(line);
-                        await data.onProgress({
+                        data.onProgress({
                             absolute,
                             relative: {
                                 payload: path,
@@ -318,10 +312,10 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         absolute.percent = (0, math_1.progressPercent)(absolute.total, absolute.current);
         if (files.length === 1 && xbFile) {
             absolute.description = "Preparing";
-            await data.onProgress({
+            data.onProgress({
                 absolute,
             });
-            await (0, process_1.exec)(this.command, [`--prepare`, `--target-dir=${restorePath}`], undefined, {
+            await (0, process_1.exec)(this.command, [`--prepare`, `--target-dir=${snapshotPath}`], undefined, {
                 log: this.verbose,
                 stderr: { onData: () => { } },
             });
@@ -330,7 +324,7 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         removeFiles.push(...files.filter((file) => file.startsWith("ib_logfile")));
         // Remove files
         for (const file of removeFiles) {
-            const filePath = (0, path_1.join)(restorePath, file);
+            const filePath = (0, path_1.join)(snapshotPath, file);
             if (this.verbose)
                 (0, cli_1.logExec)("rm", [filePath]);
             await (0, promises_1.rm)(filePath);

package/Task/MssqlTask.d.ts

@@ -1,4 +1,4 @@
-import { BackupDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
+import { TaskBackupData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 import { JSONSchema7 } from "json-schema";
 export type MssqlTaskConfigType = {
     command?: string;
@@ -17,6 +17,8 @@ export declare class MssqlTask extends TaskAbstract<MssqlTaskConfigType> {
     private get command();
     exec(query: string): Promise<string[][]>;
     fetchDatabaseNames(name?: string): Promise<string[]>;
-    onBackup(data: BackupDataType): Promise<void>;
-    onRestore(data: RestoreDataType): Promise<void>;
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
+    }>;
+    restore(data: TaskRestoreData): Promise<void>;
 }

package/Task/MssqlTask.js

@@ -6,8 +6,8 @@ const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const config_1 = require("../utils/datatruck/config");
 const fs_1 = require("../utils/fs");
 const process_1 = require("../utils/process");
+const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
-const assert_1 = require("assert");
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
@@ -67,26 +67,25 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
             .map(([database]) => database)
             .filter((database) => !privateDatabases.includes(database));
     }
-    async onBackup(data) {
+    async backup(data) {
         this.verbose = data.options.verbose;
-        const targetPath = data.package.path;
-        (0, assert_1.ok)(typeof targetPath === "string");
+        if (data.package.path)
+            throw new Error(`Path is not required: ${data.package.path}`);
+        const snapshotPath = await (0, temp_1.mkTmpDir)(exports.mssqlTaskName, "task", "backup", "snapshot");
         const databaseNames = (await this.fetchDatabaseNames()).filter((databaseName) => (!this.config.includeDatabases ||
             (0, micromatch_1.isMatch)(databaseName, this.config.includeDatabases)) &&
             (!this.config.excludeDatabases ||
                 !(0, micromatch_1.isMatch)(databaseName, this.config.excludeDatabases)));
-        await (0, fs_1.mkdirIfNotExists)(targetPath);
         for (const databaseName of databaseNames) {
-            const databasePath = (0, path_1.join)(targetPath, `${databaseName}${MssqlTask.SUFFIX}`);
+            const databasePath = (0, path_1.join)(snapshotPath, `${databaseName}${MssqlTask.SUFFIX}`);
             await this.exec(`BACKUP DATABASE [${databaseName}] TO DISK='${databasePath}' WITH FORMAT`);
         }
+        return { snapshotPath };
     }
-    async onRestore(data) {
+    async restore(data) {
         this.verbose = data.options.verbose;
-        const restorePath = data.package.restorePath;
-        (0, assert_1.ok)(typeof restorePath === "string");
-        await (0, fs_1.mkdirIfNotExists)(restorePath);
-        const files = await (0, fs_1.readDir)(restorePath);
+        const snapshotPath = data.snapshotPath;
+        const files = await (0, fs_1.readDir)(snapshotPath);
         for (const file of files) {
             if (!file.endsWith(MssqlTask.SUFFIX))
                 continue;
@@ -99,7 +98,7 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
                     snapshotId: data.options.snapshotId,
                     snapshotDate: data.snapshot.date,
                 });
-            const databasePath = (0, path_1.join)(restorePath, file);
+            const databasePath = (0, path_1.join)(snapshotPath, file);
             const exists = await this.fetchDatabaseNames(databaseName);
             if (exists.length)
                 throw new AppError_1.AppError(`Target database already exists: ${databaseName}`);

package/Task/MysqlDumpTask.d.ts

@@ -1,5 +1,6 @@
+import { CompressOptions } from "../utils/tar";
 import { SqlDumpTaskConfigType } from "./SqlDumpTaskAbstract";
-import { BackupDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
+import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 export declare const mysqlDumpTaskName = "mysql-dump";
 export type MysqlDumpTaskConfigType = {
     /**
@@ -11,9 +12,15 @@ export type MysqlDumpTaskConfigType = {
      * @default 1
      */
     concurrency?: number;
+    compress?: boolean | CompressOptions;
 } & SqlDumpTaskConfigType;
 export declare const mysqlDumpTaskDefinition: import("json-schema").JSONSchema7;
 export declare class MysqlDumpTask extends TaskAbstract<MysqlDumpTaskConfigType> {
-    onBackup(data: BackupDataType): Promise<void>;
-    onRestore(data: RestoreDataType): Promise<void>;
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
+    }>;
+    prepareRestore(data: TaskPrepareRestoreData): Promise<{
+        snapshotPath: string;
+    }>;
+    restore(data: TaskRestoreData): Promise<void>;
 }

package/Task/MysqlDumpTask.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MysqlDumpTask = exports.mysqlDumpTaskDefinition = exports.mysqlDumpTaskName = void 0;
 const AppError_1 = require("../Error/AppError");
+const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const async_1 = require("../utils/async");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
@@ -9,9 +10,10 @@ const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
 const mysql_1 = require("../utils/mysql");
 const string_1 = require("../utils/string");
+const tar_1 = require("../utils/tar");
+const temp_1 = require("../utils/temp");
 const SqlDumpTaskAbstract_1 = require("./SqlDumpTaskAbstract");
 const TaskAbstract_1 = require("./TaskAbstract");
-const assert_1 = require("assert");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 exports.mysqlDumpTaskName = "mysql-dump";
@@ -19,6 +21,9 @@ exports.mysqlDumpTaskDefinition = (0, SqlDumpTaskAbstract_1.sqlDumpTaskDefinitio
     dataFormat: { enum: ["csv", "sql"] },
     concurrency: { type: "integer", minimum: 1 },
     csvSharedPath: { type: "string" },
+    compress: {
+        anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
+    },
 });
 const suffix = {
     database: ".database.sql",
@@ -28,18 +33,31 @@ const suffix = {
     tableSchema: ".table-schema.sql",
 };
 class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
-    async onBackup(data) {
+    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 outputPath = data.package.path;
-        (0, assert_1.ok)(typeof outputPath === "string");
         const concurrency = this.config.concurrency ?? 4;
         const dataFormat = this.config.dataFormat ?? "sql";
-        await (0, promises_1.mkdir)(outputPath, { recursive: true });
         const sharedDir = dataFormat === "csv"
             ? await sql.initSharedDir(this.config.csvSharedPath)
             : undefined;
@@ -47,7 +65,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
             await (0, async_1.runParallel)({
                 items: tableNames,
                 concurrency,
-                onChange: async ({ processed: proccesed, buffer }) => await data.onProgress({
+                onChange: ({ processed: proccesed, buffer }) => data.onProgress({
                     relative: {
                         description: buffer.size > 1 ? `Exporting (${buffer.size})` : "Exporting",
                         payload: [...buffer.keys()].join(", "),
@@ -81,15 +99,19 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                                 files.every((file) => file === schemaFile || file === dataFile);
                             if (!successCsvDump)
                                 throw new AppError_1.AppError(`Invalid csv dump files: ${files.join(", ")}`);
-                            await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, schemaFile), (0, path_1.join)(outputPath, `${tableName}${suffix.tableSchema}`));
-                            await (0, fs_1.safeRename)((0, path_1.join)(tableSharedPath, dataFile), (0, path_1.join)(outputPath, `${tableName}${suffix.tableData}`));
+                            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 });
                         }
                     }
                     else {
-                        const outPath = (0, path_1.join)(outputPath, `${tableName}${suffix.table}`);
+                        const outPath = (0, path_1.join)(snapshotPath, `${tableName}${suffix.table}`);
                         await sql.dump({
                             output: outPath,
                             items: [tableName],
@@ -113,16 +135,19 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                                 },
                             }),
                         });
+                        await sql.assertDumpFile(outPath);
+                        await compressAndClean?.(outPath);
                     }
                 },
             });
         }
         else {
-            await data.onProgress({
+            data.onProgress({
                 relative: { description: "Exporting" },
             });
+            const outPath = (0, path_1.join)(snapshotPath, `${this.config.database}${suffix.database}`);
             await sql.dump({
-                output: (0, path_1.join)(outputPath, `${this.config.database}${suffix.database}`),
+                output: outPath,
                 items: tableNames,
                 database: this.config.database,
                 onProgress: (progress) => data.onProgress({
@@ -133,26 +158,39 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                     },
                 }),
             });
+            await sql.assertDumpFile(outPath);
+            await compressAndClean?.(outPath);
         }
         if (this.config.storedPrograms ?? true) {
-            await data.onProgress({
+            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: (0, path_1.join)(outputPath, `${this.config.database}${suffix.stored}`),
+                output: outPath,
                 onlyStoredPrograms: true,
             });
+            await sql.assertDumpFile(outPath);
+            await compressAndClean?.(outPath);
         }
+        return {
+            snapshotPath,
+        };
+    }
+    async prepareRestore(data) {
+        return {
+            snapshotPath: data.package.restorePath ??
+                (await (0, temp_1.mkTmpDir)(exports.mysqlDumpTaskName, "task", "restore", "snapshot")),
+        };
     }
-    async onRestore(data) {
+    async restore(data) {
         const sql = await (0, mysql_1.createMysqlCli)({
             ...this.config,
             database: undefined,
             verbose: data.options.verbose,
         });
-        const restorePath = data.package.restorePath;
-        (0, assert_1.ok)(typeof restorePath === "string");
+        const snapshotPath = data.snapshotPath;
         const params = {
             packageName: data.package.name,
             snapshotId: data.options.snapshotId,
@@ -163,13 +201,12 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
         const database = {
             name: (0, config_1.resolveDatabaseName)(this.config.database, params),
         };
-        if (this.config.targetDatabase && data.options.restorePath)
+        if (this.config.targetDatabase && !data.options.initial)
             database.name = (0, config_1.resolveDatabaseName)(this.config.targetDatabase.name, {
                 ...params,
                 database: database.name,
             });
-        const suffixes = Object.values(suffix);
-        const files = (await (0, fs_1.readDir)(restorePath)).filter((f) => (0, string_1.endsWith)(f, suffixes));
+        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)))
@@ -191,7 +228,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
             : undefined;
         await sql.createDatabase(database);
         if (data.options.verbose)
-            (0, cli_1.logExec)("readdir", [restorePath]);
+            (0, cli_1.logExec)("readdir", [snapshotPath]);
         const concurrency = this.config.concurrency ?? 1;
         let processed = 0;
         await (0, async_1.runParallel)({
@@ -200,7 +237,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
             onFinished: () => {
                 processed++;
             },
-            onChange: async ({ buffer }) => await data.onProgress({
+            onChange: ({ buffer }) => data.onProgress({
                 relative: {
                     description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
                     payload: [...buffer.keys()].join(", "),
@@ -212,11 +249,29 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                 },
             }),
             onItem: async ({ item: file, controller }) => {
-                await sql.importFile({
-                    path: (0, path_1.join)(restorePath, file),
-                    database: database.name,
-                    onSpawn: (p) => (controller.stop = () => p.kill()),
-                });
+                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,
+                        onSpawn: (p) => (controller.stop = () => p.kill()),
+                    });
+                }
+                finally {
+                    await tempDir?.[Symbol.asyncDispose]();
+                }
             },
         });
         await (0, async_1.runParallel)({
@@ -225,7 +280,7 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
             onFinished: () => {
                 processed++;
             },
-            onChange: async ({ buffer }) => await data.onProgress({
+            onChange: ({ buffer }) => data.onProgress({
                 relative: {
                     description: buffer.size > 1 ? `Importing (${buffer.size})` : "Importing",
                     payload: [...buffer.keys()].join(", "),
@@ -237,20 +292,35 @@ class MysqlDumpTask extends TaskAbstract_1.TaskAbstract {
                 },
             }),
             onItem: async ({ item: file, controller }) => {
-                const filePath = (0, path_1.join)(restorePath, file);
+                const id = data.snapshot.id.slice(0, 8);
                 const tableName = file.slice(0, suffix.tableData.length * -1);
-                const sharedFilePath = (0, path_1.join)(sharedDir, `tmp-dtt-restore-${data.snapshot.id.slice(0, 8)}-${tableName}.data.csv`);
+                const sharedName = `tmp-dtt-restore-${id}-${tableName}.data.csv`;
+                const temp = (0, temp_1.useTempFile)((0, path_1.join)(sharedDir, sharedName));
                 try {
-                    await (0, fs_1.safeRename)(filePath, sharedFilePath);
+                    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: sharedFilePath,
+                        path: csvFile,
                         database: database.name,
                         table: tableName,
                         onSpawn: (p) => (controller.stop = () => p.kill()),
                     });
                 }
                 finally {
-                    await (0, promises_1.rm)(sharedFilePath);
+                    await temp[Symbol.asyncDispose]();
                 }
             },
         });

package/Task/ScriptTask.d.ts

@@ -1,42 +1,47 @@
+import { PackageConfigType } from "../Config/PackageConfig";
+import { PreSnapshot } from "../Repository/RepositoryAbstract";
 import { Step } from "../utils/steps";
-import { BackupDataType, BeforeBackupDataType, BeforeRestoreDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
+import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 import { JSONSchema7 } from "json-schema";
+type NodeVars = {
+    dtt: {
+        snapshot: PreSnapshot;
+        package: PackageConfigType;
+        snapshotPath: string;
+    };
+};
 export type ScriptTaskConfigType = {
     env?: Record<string, string | undefined>;
     backupSteps: Step[];
     restoreSteps: Step[];
 };
+export declare function scriptTaskCode<V extends Record<string, any>>(cb: (vars: NodeVars & V) => void): string;
 export declare enum ScriptTaskDefinitionEnum {
     step = "step",
     processStepConfig = "processStepConfig",
-    nodeStepConfig = "nodeStepConfig"
+    nodeStepConfig = "nodeStepConfig",
+    telegramMessageStepConfig = "telegramMessageStepConfig"
 }
 export declare const scriptTaskName = "script";
 export declare const scriptTaskDefinition: JSONSchema7;
 export declare class ScriptTask extends TaskAbstract<ScriptTaskConfigType> {
     protected verbose?: boolean;
-    onBeforeBackup(data: BeforeBackupDataType): Promise<{
-        targetPath: string;
-    }>;
-    protected getVars(data: BackupDataType | RestoreDataType): {
+    protected getVars(data: TaskBackupData | TaskRestoreData): {
         process: {
             DTT_SNAPSHOT_ID: string;
             DTT_SNAPSHOT_DATE: string;
             DTT_PACKAGE_NAME: string;
             DTT_PACKAGE_PATH: string | undefined;
-            DTT_TARGET_PATH: string | undefined;
-        };
-        node: {
-            dtt: {
-                snapshot: import("../Repository/RepositoryAbstract").SnapshotType;
-                package: import("../Config/PackageConfig").PackageConfigType;
-                targetPath: string | undefined;
-            };
+            DTT_SNAPSHOT_PATH: string | undefined;
         };
+        node: NodeVars;
     };
-    onBackup(data: BackupDataType): Promise<void>;
-    onBeforeRestore(data: BeforeRestoreDataType): Promise<{
-        targetPath: string;
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
+    }>;
+    prepareRestore(data: TaskPrepareRestoreData): Promise<{
+        snapshotPath: string;
     }>;
-    onRestore(data: RestoreDataType): Promise<void>;
+    restore(data: TaskRestoreData): Promise<void>;
 }
+export {};