@datatruck/cli 0.14.0 → 0.16.1

package/SessionDriver/ConsoleSessionDriver.js

@@ -1,4 +1,7 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ConsoleSessionDriver = void 0;
 const AppError_1 = require("../Error/AppError");
@@ -6,6 +9,7 @@ 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 pretty_bytes_1 = __importDefault(require("pretty-bytes"));
 const sep = (0, chalk_1.grey)(`|`);
 const renderBadge = (badge) => `${badge.color(badge.name)}${(0, chalk_1.grey)(`:`)} ${(0, chalk_1.white)(badge.value)}`;
 const renderBadges = (badges) => badges.map(renderBadge).join(` ${sep} `);
@@ -72,34 +76,59 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         ]);
         const padding = "   ".repeat(message.level ?? 0);
         const sessionId = message.sessionId.toString().padStart(2, "0");
-        const parts = [
+        let parts = [
             `${padding}${message.textPrefix} [${(0, chalk_1.grey)(sessionId)}] ${message.text}`,
             badges,
         ];
-        if (typeof message.progressPercent === "number") {
-            parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressPercent ?? 0, 10)), `${message.progressPercent?.toFixed(2)}%`);
+        const progress = message.progress;
+        const absolute = progress?.absolute || {};
+        const relative = progress?.relative || {};
+        if (typeof absolute.percent === "number" ||
+            typeof relative.percent === "number") {
+            parts.push((0, cli_util_1.renderProgressBar)(absolute.percent ?? 0, 10, relative.percent ?? undefined));
         }
-        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)));
+        const createProgressParts = (p) => {
+            const result = [];
+            if (typeof p.percent === "number")
+                result.push(`${p.percent.toFixed(2)}%`);
+            if (typeof p.current === "number" || typeof p.total === "number") {
+                const format = (value) => p.format === "size" ? (0, pretty_bytes_1.default)(value) : value;
+                if (typeof p.current === "number" && typeof p.total === "number") {
+                    result.push(`${format(p.current)}/${format(p.total)}`);
+                }
+                else if (typeof p.current === "number") {
+                    result.push(`${format(p.current)}`);
+                }
+                else if (typeof p.total === "number") {
+                    result.push(`?/${format(p.total)}`);
+                }
+            }
+            if (p.description && p.payload) {
+                result.push(`${p.description}: ${p.payload}`);
+            }
+            else if (p.description) {
+                result.push(p.description);
+            }
+            else if (p.payload) {
+                result.push(p.payload);
+            }
+            return result;
+        };
+        if (progress?.absolute)
+            parts.push(...createProgressParts(progress?.absolute));
+        if (progress?.relative) {
+            const relativeParts = createProgressParts(progress?.relative);
+            if (relativeParts.length) {
+                return (parts.join(` ${sep} `) +
+                    `  ${(0, chalk_1.cyan)("▷")}  ` +
+                    relativeParts.join(` ${sep} `));
+            }
         }
         return parts.join(` ${sep} `);
     }
     async onWrite(data) {
         if (data.action === SessionDriverAbstract_1.ActionEnum.Init)
             return;
-        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress && this.options.progressInterval) {
-            const skip = this.lastProgressDate &&
-                Date.now() - this.lastProgressDate < this.options.progressInterval;
-            if (skip)
-                return;
-            this.lastProgressDate = Date.now();
-        }
         const message = {
             sessionId: "sessionId" in data.data ? data.data.sessionId : data.data.id,
             badges: [],
@@ -124,7 +153,9 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             if (data.data.error)
                 message.errorBadge = {
                     name: "error",
-                    value: this.tty ? data.data.error.split("\n")[0] : data.data.error,
+                    value: this.tty && data.data.error.startsWith(`${AppError_1.AppError.name} :`)
+                        ? data.data.error.split("\n")[0]
+                        : data.data.error,
                     color: chalk_1.red,
                 };
         }
@@ -132,11 +163,7 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             message.textPrefix = "{spinner}";
         }
         if (hasProgress) {
-            message.progressPercent = data.data.progressPercent;
-            message.progressCurrent = data.data.progressCurrent;
-            message.progressTotal = data.data.progressTotal;
-            message.progressStep = data.data.progressStep;
-            message.progressStepPercent = data.data.progressStepPercent;
+            message.progress = data.data.progress;
         }
         if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSession ||
             data.entity === SessionDriverAbstract_1.EntityEnum.RestoreSession) {

package/SessionDriver/SqliteSessionDriver.js

@@ -134,6 +134,11 @@ class SqliteSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
         let stm;
         let object = data.data;
         const id = object.id;
+        object = {
+            ...object,
+            // @ts-expect-error
+            progress: data.data.progress ? JSON.stringify(data.data.progress) : null,
+        };
         if (data.action === SessionDriverAbstract_1.ActionEnum.Init) {
             // @ts-expect-error
             object = { ...object, id: null };

package/SessionManager/BackupSessionManager.d.ts

@@ -2,19 +2,14 @@ import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction"
 import { BackupSessionEntity } from "../Entity/BackupSessionEntity";
 import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
 import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
-import { WriteDataType, SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
 import { ObjectVault } from "../util/ObjectVault";
-export declare type OptionsType = {
-    driver: SessionDriverAbstract;
-    altDrivers?: SessionDriverAbstract[];
-    verbose?: boolean;
-};
-export declare class BackupSessionManager {
-    readonly options: OptionsType;
+import { Progress } from "../util/progress";
+import SessionManagerAbstract from "./SessionManagerAbstract";
+export declare class BackupSessionManager extends SessionManagerAbstract {
     sessionVault: ObjectVault<BackupSessionEntity>;
     taskVault: ObjectVault<BackupSessionTaskEntity>;
     repositoryVault: ObjectVault<BackupSessionRepositoryEntity>;
-    constructor(options: OptionsType);
     findId(data: {
         packageName: string;
     }): number;
@@ -36,9 +31,15 @@ export declare class BackupSessionManager {
     start(input: Pick<BackupSessionEntity, "id">): Promise<number>;
     end(input: Pick<BackupSessionEntity, "id" | "error">): Promise<number>;
     startTask(input: Pick<BackupSessionTaskEntity, "id">): Promise<number>;
-    progressTask(input: Pick<BackupSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressTask(input: {
+        id: number;
+        progress: Progress;
+    }): Promise<number>;
     endTask(input: Pick<BackupSessionTaskEntity, "id" | "error">): Promise<number>;
     startRepository(input: Pick<BackupSessionRepositoryEntity, "id">): Promise<number>;
-    progressRepository(input: Pick<BackupSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressRepository(input: {
+        id: number;
+        progress: Progress;
+    }): Promise<number>;
     endRepository(input: Pick<BackupSessionRepositoryEntity, "id" | "error">): Promise<number>;
 }

package/SessionManager/BackupSessionManager.js

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BackupSessionManager = void 0;
 const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
 const ObjectVault_1 = require("../util/ObjectVault");
-class BackupSessionManager {
-    constructor(options) {
-        this.options = options;
+const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
+class BackupSessionManager extends SessionManagerAbstract_1.default {
+    constructor() {
+        super(...arguments);
         this.sessionVault = new ObjectVault_1.ObjectVault();
         this.taskVault = new ObjectVault_1.ObjectVault();
         this.repositoryVault = new ObjectVault_1.ObjectVault();
@@ -29,14 +33,25 @@ class BackupSessionManager {
     }
     async endDrivers(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        this.stopDelayedProgress();
         for (const driver of drivers) {
             await driver.onEnd(data);
         }
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
-        for (const driver of drivers) {
-            await driver.onWrite(data);
+        const write = async () => {
+            for (const driver of drivers) {
+                await driver.onWrite(data);
+            }
+        };
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
+            !this.checkProgress(data.data.progress?.relative?.description)) {
+            this.delayProgress(write);
+        }
+        else {
+            this.stopDelayedProgress();
+            await write();
         }
         return data.data.id;
     }

package/SessionManager/RestoreSessionManager.d.ts

@@ -2,19 +2,16 @@ import { BackupSessionsActionOptionsType } from "../Action/BackupSessionsAction"
 import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
 import { RestoreSessionRepositoryEntity } from "../Entity/RestoreSessionRepositoryEntity";
 import { RestoreSessionTaskEntity } from "../Entity/RestoreSessionTaskEntity";
-import { WriteDataType, SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+import { WriteDataType } from "../SessionDriver/SessionDriverAbstract";
 import { ObjectVault } from "../util/ObjectVault";
-export declare type OptionsType = {
-    driver: SessionDriverAbstract;
-    altDrivers?: SessionDriverAbstract[];
-    verbose?: boolean;
-};
-export declare class RestoreSessionManager {
-    readonly options: OptionsType;
+import { Progress } from "../util/progress";
+import SessionManagerAbstract from "./SessionManagerAbstract";
+export declare class RestoreSessionManager extends SessionManagerAbstract {
     sessionVault: ObjectVault<RestoreSessionEntity>;
     repositoryVault: ObjectVault<RestoreSessionRepositoryEntity>;
     taskVault: ObjectVault<RestoreSessionTaskEntity>;
-    constructor(options: OptionsType);
+    protected lastProgressDate: number | undefined;
+    protected lastRelativeProgressDescription: string | null | undefined;
     findId(data: {
         packageName: string;
     }): number;
@@ -37,8 +34,14 @@ export declare class RestoreSessionManager {
     end(input: Pick<RestoreSessionEntity, "id" | "error">): Promise<number>;
     startTask(input: Pick<RestoreSessionTaskEntity, "id">): Promise<number>;
     startRepository(input: Pick<RestoreSessionRepositoryEntity, "id">): Promise<number>;
-    progressTask(input: Pick<RestoreSessionTaskEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressTask(input: {
+        id: number;
+        progress: Progress;
+    }): Promise<number>;
     endTask(input: Pick<RestoreSessionTaskEntity, "id" | "error">): Promise<number>;
-    progressRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "progressTotal" | "progressCurrent" | "progressPercent" | "progressStep" | "progressStepPercent">): Promise<number>;
+    progressRepository(input: {
+        id: number;
+        progress: Progress;
+    }): Promise<number>;
     endRepository(input: Pick<RestoreSessionRepositoryEntity, "id" | "error">): Promise<number>;
 }

package/SessionManager/RestoreSessionManager.js

@@ -1,11 +1,15 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestoreSessionManager = void 0;
 const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
 const ObjectVault_1 = require("../util/ObjectVault");
-class RestoreSessionManager {
-    constructor(options) {
-        this.options = options;
+const SessionManagerAbstract_1 = __importDefault(require("./SessionManagerAbstract"));
+class RestoreSessionManager extends SessionManagerAbstract_1.default {
+    constructor() {
+        super(...arguments);
         this.sessionVault = new ObjectVault_1.ObjectVault();
         this.repositoryVault = new ObjectVault_1.ObjectVault();
         this.taskVault = new ObjectVault_1.ObjectVault();
@@ -29,14 +33,25 @@ class RestoreSessionManager {
     }
     async endDrivers() {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        this.stopDelayedProgress();
         for (const driver of drivers) {
             await driver.onEnd();
         }
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
-        for (const driver of drivers) {
-            await driver.onWrite(data);
+        const write = async () => {
+            for (const driver of drivers) {
+                await driver.onWrite(data);
+            }
+        };
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
+            !this.checkProgress(data.data.progress?.relative?.description)) {
+            this.delayProgress(write);
+        }
+        else {
+            this.stopDelayedProgress();
+            await write();
         }
         return data.data.id;
     }

package/SessionManager/SessionManagerAbstract.d.ts

@@ -0,0 +1,18 @@
+/// <reference types="node" />
+import { SessionDriverAbstract } from "../SessionDriver/SessionDriverAbstract";
+export declare type OptionsType = {
+    driver: SessionDriverAbstract;
+    altDrivers?: SessionDriverAbstract[];
+    progressInterval?: number;
+    verbose?: boolean;
+};
+export default abstract class SessionManagerAbstract {
+    readonly options: OptionsType;
+    protected lastProgressDate: number | undefined;
+    protected lastRelativeProgressDescription: string | null | undefined;
+    protected progressTimeout: ReturnType<typeof setTimeout> | undefined;
+    constructor(options: OptionsType);
+    protected stopDelayedProgress(): void;
+    protected delayProgress(cb: () => Promise<any>): void;
+    protected checkProgress(description: string | null | undefined): boolean;
+}

package/SessionManager/SessionManagerAbstract.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SessionManagerAbstract {
+    constructor(options) {
+        this.options = options;
+    }
+    stopDelayedProgress() {
+        clearTimeout(this.progressTimeout);
+        this.progressTimeout = undefined;
+    }
+    delayProgress(cb) {
+        clearTimeout(this.progressTimeout);
+        this.progressTimeout = setTimeout(async () => {
+            this.progressTimeout = undefined;
+            await cb();
+        }, 1500);
+    }
+    checkProgress(description) {
+        const progressInterval = this.options.progressInterval;
+        if (progressInterval) {
+            const skip = this.lastProgressDate &&
+                description === this.lastRelativeProgressDescription &&
+                Date.now() - this.lastProgressDate < progressInterval;
+            if (skip)
+                return false;
+            this.lastProgressDate = Date.now();
+            this.lastRelativeProgressDescription = description;
+        }
+        return true;
+    }
+}
+exports.default = SessionManagerAbstract;

package/Task/GitTask.js

@@ -73,7 +73,9 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
         await data.onProgress({
-            step: "Creating bundle...",
+            relative: {
+                description: "Creating bundle",
+            },
         });
         await (0, process_util_1.exec)(this.command, ["bundle", "create", bundlePath, "--all"], {
             cwd: path,
@@ -174,10 +176,15 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                 onPath: async ({ entryPath }) => {
                     currentFiles++;
                     await data.onProgress({
-                        total,
-                        current: currentFiles,
-                        percent: (0, math_util_1.progressPercent)(total, currentFiles),
-                        step: entryPath,
+                        relative: {
+                            description: "Copying file",
+                            payload: entryPath,
+                        },
+                        absolute: {
+                            total,
+                            current: currentFiles,
+                            percent: (0, math_util_1.progressPercent)(total, currentFiles),
+                        },
                     });
                 },
             });
@@ -201,14 +208,17 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
         let totalFiles = 0;
         let currentFiles = 0;
         await (0, fs_util_1.forEachFile)(targetPath, () => totalFiles++, true);
-        const incrementProgress = async (step = "") => {
+        const incrementProgress = async (description, item, count = true) => {
             await data.onProgress({
-                total: totalFiles,
-                current: Math.max(currentFiles, 0),
-                percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
-                step,
+                absolute: {
+                    total: totalFiles,
+                    current: Math.max(currentFiles, 0),
+                    percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
+                },
+                relative: { description, payload: item },
             });
-            currentFiles++;
+            if (count)
+                currentFiles++;
         };
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
@@ -237,9 +247,7 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                     },
                     targetPath: restorePath,
                     concurrency: this.config.fileCopyConcurrency,
-                    onPath: async ({ entryPath }) => {
-                        await incrementProgress(entryPath);
-                    },
+                    onProgress: async (progress) => await incrementProgress(progress.type === "end" ? "Files copied" : "Copying file", progress.path, !progress.type),
                 });
             }
         }

package/Task/MariadbTask.js

@@ -108,10 +108,15 @@ class MariadbTask extends TaskAbstract_1.TaskAbstract {
             else if (paths.length) {
                 const path = (0, posix_1.normalize)(paths[0]);
                 await data.onProgress({
-                    current,
-                    percent: (0, math_util_1.progressPercent)(total, current),
-                    total,
-                    step: `Copying ${path}`,
+                    relative: {
+                        description: "Copying file",
+                        payload: path,
+                    },
+                    absolute: {
+                        current,
+                        percent: (0, math_util_1.progressPercent)(total, current),
+                        total,
+                    },
                 });
             }
         };

package/Task/MysqlDumpTask.d.ts

@@ -9,7 +9,9 @@ export declare class MysqlDumpTask extends SqlDumpTaskAbstract<MysqlDumpTaskConf
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
     onFetchTableNames(database: string): Promise<string[]>;
-    onExportTables(tableNames: string[], output: string): Promise<void>;
+    onExportTables(tableNames: string[], output: string, onProgress: (progress: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     onExportStoredPrograms(output: string): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/MysqlDumpTask.js

@@ -70,7 +70,7 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         table_name
 	`);
     }
-    async onExportTables(tableNames, output) {
+    async onExportTables(tableNames, output, onProgress) {
         const stream = (0, fs_1.createWriteStream)(output);
         await Promise.all([
             new Promise((resolve, reject) => {
@@ -83,7 +83,10 @@ class MysqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
                 "--skip-add-drop-table=false",
                 ...tableNames,
             ], null, {
-                pipe: { stream: stream },
+                pipe: {
+                    stream,
+                    onWriteProgress: onProgress,
+                },
                 log: {
                     exec: this.verbose,
                     stderr: this.verbose,

package/Task/PostgresqlDumpTask.d.ts

@@ -9,7 +9,9 @@ export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDu
     onCreateDatabase(database: TargetDatabaseType): Promise<void>;
     onExecQuery(query: string): Promise<import("../util/process-util").ExecResultType>;
     onFetchTableNames(database: string): Promise<string[]>;
-    onExportTables(tableNames: string[], output: string): Promise<void>;
+    onExportTables(tableNames: string[], output: string, onProgress: (progress: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     onExportStoredPrograms(): Promise<void>;
     onImport(path: string, database: string): Promise<void>;
 }

package/Task/PostgresqlDumpTask.js

@@ -73,7 +73,7 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
         CONCAT(table_schema, '.', table_name)
 	  `);
     }
-    async onExportTables(tableNames, output) {
+    async onExportTables(tableNames, output, onProgress) {
         const stream = (0, fs_1.createWriteStream)(output);
         await Promise.all([
             new Promise((resolve, reject) => {
@@ -84,7 +84,7 @@ class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
                 ...(await this.buildConnectionArgs()),
                 ...(tableNames?.flatMap((v) => ["-t", v]) ?? []),
             ], null, {
-                pipe: { stream: stream },
+                pipe: { stream, onWriteProgress: onProgress },
                 stderr: {
                     toExitCode: true,
                 },

package/Task/SqlDumpTaskAbstract.d.ts

@@ -29,7 +29,9 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     abstract onDatabaseIsEmpty(databaseName: string): Promise<boolean>;
     abstract onFetchTableNames(database: string): Promise<string[]>;
     abstract onExecQuery(query: string): ReturnType<typeof exec>;
-    abstract onExportTables(tableNames: string[], output: string): Promise<void>;
+    abstract onExportTables(tableNames: string[], output: string, onProgress: (data: {
+        totalBytes: number;
+    }) => void): Promise<void>;
     abstract onExportStoredPrograms(output: string): Promise<void>;
     abstract onImport(path: string, database: string): Promise<void>;
     onBackup(data: BackupDataType): Promise<void>;

package/Task/SqlDumpTaskAbstract.js

@@ -118,24 +118,61 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
             await (0, promises_1.mkdir)(outputPath, { recursive: true });
         if (!this.config.oneFileByTable) {
             const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ database: this.config.database }));
-            await this.onExportTables(tableNames, outPath);
+            data.onProgress({
+                relative: {
+                    description: "Exporting",
+                },
+            });
+            await this.onExportTables(tableNames, outPath, async (progress) => {
+                await data.onProgress({
+                    absolute: {
+                        description: "Exporting in single file",
+                        current: progress.totalBytes,
+                        format: "size",
+                    },
+                });
+            });
         }
         else {
             let current = 0;
             for (const tableName of tableNames) {
-                data.onProgress({
-                    total: tableNames.length,
-                    current: current,
-                    percent: (0, math_util_1.progressPercent)(tableNames.length, current),
-                    step: tableName,
+                await data.onProgress({
+                    relative: {
+                        description: "Exporting",
+                        payload: tableName,
+                    },
+                    absolute: {
+                        total: tableNames.length,
+                        current: current,
+                        percent: (0, math_util_1.progressPercent)(tableNames.length, current),
+                    },
                 });
-                current++;
                 const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ table: tableName }));
-                await this.onExportTables([tableName], outPath);
+                await this.onExportTables([tableName], outPath, async (progress) => {
+                    await data.onProgress({
+                        relative: {
+                            description: "Exporting",
+                            payload: tableName,
+                            current: progress.totalBytes,
+                            format: "size",
+                        },
+                        absolute: {
+                            total: tableNames.length,
+                            current: current,
+                            percent: (0, math_util_1.progressPercent)(tableNames.length, current),
+                        },
+                    });
+                });
+                current++;
             }
         }
         if (this.config.storedPrograms) {
             const outPath = (0, path_1.join)(outputPath, "stored-programs.sql");
+            data.onProgress({
+                relative: {
+                    description: "Exporting storaged programs",
+                },
+            });
             await this.onExportStoredPrograms(outPath);
         }
     }
@@ -184,13 +221,18 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         for (const item of items) {
             const path = (0, path_1.join)(restorePath, item.fileName);
             data.onProgress({
-                total: items.length,
-                current: current,
-                percent: (0, math_util_1.progressPercent)(items.length, current),
-                step: item.fileName,
+                relative: {
+                    description: "Importing",
+                    payload: item.fileName,
+                },
+                absolute: {
+                    total: items.length,
+                    current: current,
+                    percent: (0, math_util_1.progressPercent)(items.length, current),
+                },
             });
-            current++;
             await this.onImport(path, database.name);
+            current++;
         }
     }
 }

package/Task/TaskAbstract.d.ts

@@ -2,22 +2,16 @@ import { BackupActionOptionsType } from "../Action/BackupAction";
 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;
-    stepPercent?: number;
-};
+import { Progress } from "../util/progress";
 export declare type BackupDataType = {
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
     options: BackupActionOptionsType;
     package: PackageConfigType;
     targetPath: string | undefined;
     snapshot: SnapshotType;
 };
 export declare type RestoreDataType = {
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
     options: RestoreActionOptionsType;
     package: PackageConfigType;
     targetPath: string | undefined;