@datatruck/cli 0.5.0 → 0.7.0

package/SessionDriver/ConsoleSessionDriver.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleSessionDriver = void 0;
 const AppError_1 = require("../Error/AppError");
 const cli_util_1 = require("../util/cli-util");
+const date_util_1 = require("../util/date-util");
 const SessionDriverAbstract_1 = require("./SessionDriverAbstract");
 const chalk_1 = require("chalk");
 const sep = (0, chalk_1.grey)(`|`);
@@ -12,42 +13,28 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
     constructor() {
         super(...arguments);
         this.prints = 0;
+        this.chron = (0, date_util_1.createChron)();
     }
     async onInit() {
-        this.startTime = Date.now();
+        this.chron.start();
         this.renderInterval = setInterval(() => {
             if (this.lastMessage)
-                this.printMessage(this.lastMessage);
+                this.printMessage(this.lastMessage, false);
         }, 100);
     }
-    async onEnd() {
+    async onEnd(data) {
         clearInterval(this.renderInterval);
         if (!this.options.verbose)
             process.stdout.write(cli_util_1.showCursorCommand);
-        const ellapsed = (Date.now() - this.startTime) / 1000;
-        let ellapsedUnit;
-        let ellapsedValue;
-        if (ellapsed > 60 * 60) {
-            ellapsedValue = ellapsed / 60 / 60;
-            ellapsedUnit = `hour`;
-        }
-        else if (ellapsed > 60) {
-            ellapsedValue = ellapsed / 60;
-            ellapsedUnit = `minute`;
-        }
-        else {
-            ellapsedValue = ellapsed;
-            ellapsedUnit = `second`;
-        }
-        if (ellapsedValue !== 1)
-            ellapsedUnit += `s`;
-        const message = `Completed in ${ellapsedValue.toFixed(2)} ${ellapsedUnit}`;
-        console.info(`\n${(0, chalk_1.grey)(message)}`);
+        (0, cli_util_1.logVars)({
+            ...data,
+            elapsed: this.chron.elapsed(true),
+        });
     }
     async onRead() {
         throw new AppError_1.AppError("Method not implemented");
     }
-    printMessage(message) {
+    printMessage(message, endMessage) {
         const text = this.renderMessage(message);
         if (this.options.verbose && this.lastMessageText === text) {
             return;
@@ -58,8 +45,10 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         else {
             const columns = process.stdout.columns;
             const line = this.renderSpinner(text);
-            const [truncatedLine, truncted] = (0, cli_util_1.truncate)(line, columns);
-            if (this.lastColumns && columns !== this.lastColumns && truncted)
+            const [truncatedLine, truncated] = endMessage
+                ? [line, false]
+                : (0, cli_util_1.truncate)(line, columns);
+            if (this.lastColumns && columns !== this.lastColumns && truncated)
                 process.stdout.write(`${cli_util_1.clearCommand}\n`);
             process.stdout.write(`${cli_util_1.clearCommand}${truncatedLine}${cli_util_1.hideCursorCommand}`);
             this.lastColumns = columns;
@@ -82,18 +71,19 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         const parts = [
             `${padding}${message.textPrefix} [${(0, chalk_1.grey)(sessionId)}] ${message.text}`,
             badges,
-            ...(haveProgressBar
-                ? [
-                    (0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressPercent ?? 0, 10)),
-                    `${message.progressPercent?.toFixed(2)}%`,
-                    `${message.progressCurrent}/${message.progressTotal}`,
-                    message.progressStep,
-                    `${message.progressStepPercent
-                        ? (0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressStepPercent ?? 0, 10))
-                        : ""}`,
-                ].filter((v) => !!v?.length)
-                : []),
         ];
+        if (typeof message.progressPercent === "number") {
+            parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressPercent ?? 0, 10)), `${message.progressPercent?.toFixed(2)}%`);
+        }
+        if (typeof message.progressCurrent === "number" ||
+            typeof message.progressTotal === "number") {
+            parts.push(`${message.progressCurrent ?? "?"}/${message.progressTotal ?? "?"}`);
+        }
+        if (typeof message.progressStep === "string")
+            parts.push(message.progressStep);
+        if (typeof message.progressStepPercent === "number") {
+            parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressStepPercent ?? 0, 10)));
+        }
         return parts.join(` ${sep} `);
     }
     async onWrite(data) {
@@ -169,10 +159,11 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         if (isHeader && data.action === SessionDriverAbstract_1.ActionEnum.End) {
             return;
         }
-        this.printMessage(message);
-        if (!this.options.verbose)
-            if (!hasProgress || data.action === SessionDriverAbstract_1.ActionEnum.End || isHeader)
-                process.stdout.write("\n");
+        const endMessage = !this.options.verbose &&
+            (!hasProgress || data.action === SessionDriverAbstract_1.ActionEnum.End || isHeader);
+        this.printMessage(message, endMessage);
+        if (endMessage)
+            process.stdout.write("\n");
     }
 }
 exports.ConsoleSessionDriver = ConsoleSessionDriver;

package/SessionDriver/SessionDriverAbstract.d.ts

@@ -73,6 +73,6 @@ export declare abstract class SessionDriverAbstract {
     });
     onInit(): Promise<void>;
     abstract onWrite(data: WriteDataType): Promise<void>;
-    onEnd(): Promise<void>;
+    onEnd(data?: Record<string, any>): Promise<void>;
     abstract onRead(data: ReadDataType, entity: EntityEnum): Promise<ReadResultType[]>;
 }

package/SessionDriver/SessionDriverAbstract.js

@@ -22,6 +22,6 @@ class SessionDriverAbstract {
         this.options = options;
     }
     async onInit() { }
-    async onEnd() { }
+    async onEnd(data) { }
 }
 exports.SessionDriverAbstract = SessionDriverAbstract;

package/SessionManager/BackupSessionManager.d.ts

@@ -27,7 +27,7 @@ export declare class BackupSessionManager {
         repositoryName: string;
     }): number;
     initDrivers(): Promise<void>;
-    endDrivers(): Promise<void>;
+    endDrivers(data?: Record<string, any>): Promise<void>;
     protected alter(data: WriteDataType): Promise<number>;
     readAll(options: BackupSessionsActionOptionsType): Promise<import("../SessionDriver/SessionDriverAbstract").ReadResultType[]>;
     init(input: Pick<BackupSessionEntity, "packageName" | "snapshotId" | "tags">): Promise<number>;

package/SessionManager/BackupSessionManager.js

@@ -27,10 +27,10 @@ class BackupSessionManager {
             await driver.onInit();
         }
     }
-    async endDrivers() {
+    async endDrivers(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
         for (const driver of drivers) {
-            await driver.onEnd();
+            await driver.onEnd(data);
         }
     }
     async alter(data) {

package/Task/GitTask.d.ts

@@ -18,6 +18,10 @@ export declare type GitTaskConfigType = {
      * @default true
      */
     includeConfig?: boolean;
+    /**
+     * @default 1
+     */
+    fileCopyConcurrency?: number;
 };
 export declare const gitTaskName = "git";
 export declare const gitTaskDefinition: JSONSchema7;

package/Task/GitTask.js

@@ -9,7 +9,6 @@ const process_util_1 = require("../util/process-util");
 const TaskAbstract_1 = require("./TaskAbstract");
 const assert_1 = require("assert");
 const fs_1 = require("fs");
-const fs_extra_1 = require("fs-extra");
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
@@ -49,6 +48,10 @@ exports.gitTaskDefinition = {
         includeConfig: {
             type: "boolean",
         },
+        fileCopyConcurrency: {
+            type: "integer",
+            minimum: 1,
+        },
     },
 };
 class GitTask extends TaskAbstract_1.TaskAbstract {
@@ -69,6 +72,9 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         (0, assert_1.ok)(typeof targetPath === "string");
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
+        await data.onProgress({
+            step: "Creating bundle...",
+        });
         await (0, process_util_1.exec)(this.command, ["bundle", "create", bundlePath, "--all"], {
             cwd: path,
         }, {
@@ -152,40 +158,28 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         for (const option of lsFilesConfig) {
             if (!option.include)
                 continue;
-            const createdPaths = [];
             const outPath = (0, path_1.join)(targetPath, `repo.${option.name}`);
             await (0, fs_util_1.mkdirIfNotExists)(outPath);
             if (data.options.verbose)
                 (0, cli_util_1.logExec)(`Copying ${option.name} files to ${outPath}`);
-            const reader = (0, readline_1.createInterface)({
-                input: (0, fs_1.createReadStream)(option.pathsPath),
-            });
-            for await (const entry of reader) {
-                const source = (0, path_1.join)(path, entry);
-                const target = (0, path_1.join)(outPath, entry);
-                if (entry.endsWith("/")) {
-                    await (0, promises_1.mkdir)(target, {
-                        recursive: true,
-                    });
-                }
-                else {
+            await (0, fs_util_1.cpy)({
+                input: {
+                    type: "pathList",
+                    path: option.pathsPath,
+                    basePath: path,
+                },
+                targetPath: outPath,
+                concurrency: this.config.fileCopyConcurrency,
+                onPath: async ({ entryPath }) => {
                     currentFiles++;
                     await data.onProgress({
                         total,
                         current: currentFiles,
                         percent: (0, math_util_1.progressPercent)(total, currentFiles),
-                        step: entry,
+                        step: entryPath,
                     });
-                    const dir = (0, path_1.dirname)(target);
-                    if (!createdPaths.includes(dir)) {
-                        await (0, promises_1.mkdir)(dir, {
-                            recursive: true,
-                        });
-                        createdPaths.push(dir);
-                    }
-                    await (0, promises_1.copyFile)(source, target);
-                }
-            }
+                },
+            });
             await (0, promises_1.rm)(option.pathsPath);
         }
     }
@@ -235,10 +229,15 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
             if (await (0, fs_util_1.checkDir)(sourcePath)) {
                 if (data.options.verbose)
                     (0, cli_util_1.logExec)(`Copying ${name} files to ${restorePath}`);
-                await (0, fs_extra_1.copy)(sourcePath, restorePath, {
-                    filter: async (path) => {
-                        await incrementProgress((0, path_1.relative)(sourcePath, path));
-                        return true;
+                await (0, fs_util_1.cpy)({
+                    input: {
+                        type: "glob",
+                        sourcePath,
+                    },
+                    targetPath: restorePath,
+                    concurrency: this.config.fileCopyConcurrency,
+                    onPath: async ({ entryPath }) => {
+                        await incrementProgress(entryPath);
                     },
                 });
             }

package/Task/MariadbTask.js

@@ -83,21 +83,30 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         await (0, fs_util_1.forEachFile)(sourcePath, () => {
             total++;
         });
-        const onData = async (lines) => {
-            const regex = /\[\d{1,}\] \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} Copying (.+) to/;
-            let path = lines
-                .split(/\r?\n/)
-                .reduce((result, line) => {
-                const matches = regex.exec(line);
-                if (matches) {
-                    current++;
-                    result.push(matches[1]);
+        let childProcess;
+        const onData = async (strLines) => {
+            const paths = [];
+            const pathRegex = /\[\d{1,}\] \d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2} Copying (.+) to/;
+            const lines = strLines.split(/\r?\n/);
+            let fatalError = false;
+            for (const line of lines) {
+                if (line.includes("[ERROR] InnoDB: Unsupported redo log format.") ||
+                    line.includes("Error: cannot read redo log header")) {
+                    fatalError = true;
                 }
-                return result;
-            }, [])
-                .pop();
-            if (path) {
-                path = (0, posix_1.normalize)(path);
+                else {
+                    const matches = pathRegex.exec(line);
+                    if (matches) {
+                        current++;
+                        paths.push(matches[1]);
+                    }
+                }
+            }
+            if (fatalError) {
+                childProcess.kill();
+            }
+            else if (paths.length) {
+                const path = (0, posix_1.normalize)(paths[0]);
                 await data.onProgress({
                     current,
                     percent: (0, math_util_1.progressPercent)(total, current),
@@ -108,6 +117,9 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         };
         await (0, process_util_1.exec)(command, args, undefined, {
             log: this.verbose,
+            onSpawn: (p) => {
+                childProcess = p;
+            },
             stdout: {
                 onData,
             },
@@ -117,7 +129,7 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
         });
         await (0, process_util_1.exec)(command, [`--prepare`, `--target-dir=${targetPath}`], undefined, {
             log: this.verbose,
-            stderr: { onData: async () => { } },
+            stderr: { onData: () => { } },
         });
     }
     async onRestore(data) {

package/Task/MssqlTask.js

@@ -8,7 +8,6 @@ const fs_util_1 = require("../util/fs-util");
 const process_util_1 = require("../util/process-util");
 const TaskAbstract_1 = require("./TaskAbstract");
 const assert_1 = require("assert");
-const fs_extra_1 = require("fs-extra");
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
@@ -85,7 +84,7 @@ class MssqlTask extends TaskAbstract_1.TaskAbstract {
         const restorePath = data.package.restorePath;
         (0, assert_1.ok)(typeof restorePath === "string");
         await (0, fs_util_1.mkdirIfNotExists)(restorePath);
-        const files = await (0, fs_extra_1.readdir)(restorePath);
+        const files = await (0, promises_1.readdir)(restorePath);
         for (const file of files) {
             if (!file.endsWith(MssqlTask.SUFFIX))
                 continue;

package/Task/MysqlDumpTask.d.ts

@@ -8,7 +8,7 @@ export declare class MysqlDumpTask extends SqlDumpTaskAbstract<MysqlDumpTaskConf
     onDatabaseIsEmpty(name: string): Promise<boolean>;
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
-    onFetchTableNames(): Promise<string[]>;
+    onFetchTableNames(database: string): Promise<string[]>;
     onExport(tableNames: string[], output: string): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/MysqlDumpTask.js

@@ -17,6 +17,7 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         const password = await this.fetchPassword();
         return [
             `--host=${this.config.hostname}`,
+            ...(this.config.port ? [`--port=${this.config.port}`] : []),
             `--user=${this.config.username}`,
             `--password=${password ?? ""}`,
             ...(database && this.config.database ? [this.config.database] : []),
@@ -57,14 +58,14 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
             },
         });
     }
-    async onFetchTableNames() {
+    async onFetchTableNames(database) {
         return await this.fetchValues(`
       SELECT
         table_name 
       FROM
         information_schema.tables
       WHERE
-        table_schema = '${this.config.database}'
+        table_schema = '${database}'
 	`);
     }
     async onExport(tableNames, output) {
@@ -77,6 +78,7 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
             await (0, process_util_1.exec)("mysqldump", [
                 ...(await this.buildConnectionArgs()),
                 "--lock-tables=false",
+                "--skip-add-drop-table=false",
                 ...tableNames,
             ], null, {
                 pipe: { stream: stream },

package/Task/PostgresqlDumpTask.d.ts

@@ -8,7 +8,7 @@ export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDu
     onDatabaseIsEmpty(name: string): Promise<boolean>;
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
-    onFetchTableNames(): Promise<string[]>;
+    onFetchTableNames(database: string): Promise<string[]>;
     onExport(tableNames: string[], output: string): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/PostgresqlDumpTask.js

@@ -60,14 +60,14 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
             },
         });
     }
-    async onFetchTableNames() {
+    async onFetchTableNames(database) {
         return await this.fetchValues(`
       SELECT
         CONCAT(table_schema, '.', table_name)
       FROM
         information_schema.tables
       WHERE
-        table_catalog = '${this.config.database}' AND
+        table_catalog = '${database}' AND
         table_schema NOT IN ('pg_catalog', 'information_schema')
 	  `);
     }
@@ -80,8 +80,6 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
             }),
             (0, process_util_1.exec)("pg_dump", [
                 ...(await this.buildConnectionArgs()),
-                "--clean",
-                "--if-exists",
                 ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
             ], null, {
                 pipe: { stream: stream },

package/Task/SqlDumpTaskAbstract.d.ts

@@ -26,11 +26,10 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     fetchValues(query: string): Promise<string[]>;
     abstract onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
-    abstract onFetchTableNames(): Promise<string[]>;
+    abstract onFetchTableNames(database: string): Promise<string[]>;
     abstract onExecQuery(query: string): ReturnType<typeof exec>;
     abstract onExport(tableNames: string[], output: string): Promise<void>;
     abstract onImport(path: string, database: string): Promise<void>;
-    fetchTableNames(): Promise<string[]>;
     onBackup(data: BackupDataType): Promise<void>;
     onRestore(data: RestoreDataType): Promise<void>;
 }

package/Task/SqlDumpTaskAbstract.js

@@ -49,6 +49,39 @@ exports.sqlDumpTaskDefinition = {
         oneFileByTable: { type: "boolean" },
     },
 };
+function serializeSqlFile(input) {
+    if (input.database && input.table) {
+        return `${input.database}.${input.table}.table.sql`;
+    }
+    else if (input.database && !input.table) {
+        return `${input.database}.database.sql`;
+    }
+    else if (!input.database && input.table) {
+        return `${input.table}.table.sql`;
+    }
+    else {
+        throw new AppError_1.AppError(`Invalid sql file input: ${JSON.stringify(input)}`);
+    }
+}
+function parseSqlFile(fileName) {
+    if (!fileName.endsWith(".sql"))
+        return;
+    const regex = /^(.+)\.(table|database)\.sql$/;
+    const matches = regex.exec(fileName);
+    if (!matches)
+        return { fileName };
+    const [, name, type] = matches;
+    const lastName = name.split(".").pop();
+    if (type === "table") {
+        return { fileName, table: lastName };
+    }
+    else if (type === "database") {
+        return { fileName, database: lastName };
+    }
+    else {
+        throw new Error(`Invalid sql file type: ${type}`);
+    }
+}
 class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
     async fetchPassword() {
         if (typeof this.config.password === "string")
@@ -66,26 +99,23 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
             return result;
         }, []);
     }
-    async fetchTableNames() {
-        const tableNames = await this.onFetchTableNames();
+    async onBackup(data) {
+        this.verbose = data.options.verbose;
         const config = this.config;
-        return tableNames.filter((tableName) => {
+        const outputPath = data.package.path;
+        const allTableNames = await this.onFetchTableNames(this.config.database);
+        const tableNames = allTableNames.filter((tableName) => {
             if (config.includeTables && !(0, micromatch_1.isMatch)(tableName, config.includeTables))
                 return false;
             if (config.excludeTables && (0, micromatch_1.isMatch)(tableName, config.excludeTables))
                 return false;
             return true;
         });
-    }
-    async onBackup(data) {
-        this.verbose = data.options.verbose;
-        const outputPath = data.package.path;
-        const tableNames = await this.fetchTableNames();
         (0, assert_1.ok)(typeof outputPath === "string");
         if (!(await (0, fs_util_1.checkDir)(outputPath)))
             await (0, promises_1.mkdir)(outputPath, { recursive: true });
         if (!this.config.oneFileByTable) {
-            const outPath = (0, path_1.join)(outputPath, this.config.database) + ".database.sql";
+            const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ database: this.config.database }));
             await this.onExport(tableNames, outPath);
         }
         else {
@@ -98,7 +128,7 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
                     step: tableName,
                 });
                 current++;
-                const outPath = (0, path_1.join)(outputPath, tableName) + ".table.sql";
+                const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ table: tableName }));
                 await this.onExport([tableName], outPath);
             }
         }
@@ -125,20 +155,33 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
                 database: database.name,
             });
         }
-        if (!(await this.onDatabaseIsEmpty(database.name)))
+        const items = (await (0, promises_1.readdir)(restorePath))
+            .map(parseSqlFile)
+            .filter((v) => !!v);
+        // Database check
+        const databaseItems = items.filter((v) => v.database);
+        if (databaseItems.length && !(await this.onDatabaseIsEmpty(database.name)))
             throw new AppError_1.AppError(`Target database is not empty: ${database.name}`);
+        // Table check
+        const restoreTables = items
+            .filter((v) => v.table)
+            .map((v) => v.table);
+        const serverTables = await this.onFetchTableNames(database.name);
+        const errorTables = restoreTables.filter((v) => serverTables.includes(v));
+        if (errorTables.length) {
+            throw new AppError_1.AppError(`Target table already exists: ${errorTables.join(", ")}`);
+        }
         await this.onCreateDatabase(database);
         if (this.verbose)
             (0, cli_util_1.logExec)("readdir", [restorePath]);
-        const files = (await (0, promises_1.readdir)(restorePath)).filter((name) => /\.sql$/i.test(name));
         let current = 0;
-        for (const file of files) {
-            const path = (0, path_1.join)(restorePath, file);
+        for (const item of items) {
+            const path = (0, path_1.join)(restorePath, item.fileName);
             data.onProgress({
-                total: files.length,
+                total: items.length,
                 current: current,
-                percent: (0, math_util_1.progressPercent)(files.length, current),
-                step: file,
+                percent: (0, math_util_1.progressPercent)(items.length, current),
+                step: item.fileName,
             });
             current++;
             await this.onImport(path, database.name);

package/Task/TaskAbstract.d.ts

@@ -3,10 +3,10 @@ import { RestoreActionOptionsType } from "../Action/RestoreAction";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { SnapshotType } from "../Repository/RepositoryAbstract";
 export declare type ProgressDataType = {
-    total: number;
-    current: number;
-    percent: number;
-    step: string;
+    total?: number;
+    current?: number;
+    percent?: number;
+    step?: string;
     stepPercent?: number;
 };
 export declare type BackupDataType = {

package/config.schema.json

@@ -487,6 +487,10 @@
               }
             }
           ]
+        },
+        "fileCopyConcurrency": {
+          "type": "integer",
+          "minimum": 1
         }
       }
     },
@@ -615,6 +619,10 @@
         },
         "includeConfig": {
           "type": "boolean"
+        },
+        "fileCopyConcurrency": {
+          "type": "integer",
+          "minimum": 1
         }
       }
     },

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "dependencies": {
     "ajv": "^8.11.0",
+    "async": "^3.2.4",
     "chalk": "^4.1.2",
     "cli-table3": "^0.6.2",
     "commander": "^9.2.0",
     "dayjs": "^1.11.2",
     "fast-glob": "^3.2.11",
-    "fs-extra": "^10.1.0",
     "micromatch": "^4.0.5",
     "sqlite": "^4.1.1",
     "sqlite3": "^5.0.8"

package/util/GitUtil.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitUtil = void 0;
 const fs_util_1 = require("./fs-util");
 const process_util_1 = require("./process-util");
-const fs_extra_1 = require("fs-extra");
+const promises_1 = require("fs/promises");
 class GitUtil {
     constructor(options) {
         this.options = options;
@@ -16,7 +16,7 @@ class GitUtil {
     }
     async canBeInit(repo) {
         return ((0, fs_util_1.isLocalDir)(repo) &&
-            (!(await (0, fs_util_1.checkDir)(repo)) || !(await (0, fs_extra_1.readdir)(repo)).length));
+            (!(await (0, fs_util_1.checkDir)(repo)) || !(await (0, promises_1.readdir)(repo)).length));
     }
     async clone(options) {
         return await this.exec([

package/util/ResticUtil.d.ts

@@ -84,7 +84,7 @@ export declare class ResticUtil {
         excludeFile?: string[];
         parent?: string;
         allowEmptySnapshot?: boolean;
-        onStream?: (data: BackupStreamType) => Promise<void>;
+        onStream?: (data: BackupStreamType) => void;
     }): Promise<ExecResultType>;
     restore(options: {
         id: string;