@datatruck/cli 0.13.1 → 0.16.0

package/Repository/RepositoryAbstract.d.ts

@@ -4,6 +4,7 @@ import type { RestoreActionOptionsType } from "../Action/RestoreAction";
 import type { SnapshotExtendedType, SnapshotsActionOptionsType } from "../Action/SnapshotsAction";
 import type { PackageConfigType } from "../Config/PackageConfig";
 import type { RepositoryConfigType } from "../Config/RepositoryConfig";
+import { Progress } from "../util/progress";
 export declare type SnapshotType = {
     id: string;
     date: string;
@@ -15,13 +16,6 @@ export declare type SnapshotResultType = SnapshotType & {
     tags: string[];
     size: number;
 };
-export declare type ProgressDataType = {
-    total?: number;
-    current?: number;
-    percent?: number;
-    step?: string;
-    stepPercent?: number | null;
-};
 export declare type InitDataType = {
     options: InitActionOptionsType;
 };
@@ -33,7 +27,7 @@ export declare type CopyBackupType<TRepositoryConfig> = {
     snapshot: SnapshotType;
     package: PackageConfigType;
     mirrorRepositoryConfig: TRepositoryConfig;
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
 };
 export declare type BackupDataType<TPackageConfig> = {
     options: BackupActionOptionsType;
@@ -41,7 +35,7 @@ export declare type BackupDataType<TPackageConfig> = {
     package: PackageConfigType;
     targetPath: string | undefined;
     packageConfig: TPackageConfig | undefined;
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
 };
 export declare type RestoreDataType<TPackageConfig> = {
     options: RestoreActionOptionsType;
@@ -49,7 +43,7 @@ export declare type RestoreDataType<TPackageConfig> = {
     package: PackageConfigType;
     targetPath: string | undefined;
     packageConfig: TPackageConfig;
-    onProgress: (data: ProgressDataType) => Promise<void>;
+    onProgress: (data: Progress) => Promise<void>;
 };
 export declare type PruneDataType = {
     snapshot: SnapshotExtendedType;

package/Repository/ResticRepository.js

@@ -195,7 +195,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 verbose: data.options.verbose,
             });
             await data.onProgress({
-                step: "Writing excluded paths list...",
+                relative: {
+                    description: "Writing excluded paths list",
+                },
             });
             const tmpDir = await (0, fs_util_1.mkTmpDir)("restic-exclude");
             const ignoredContents = (0, fs_util_1.fastglobToGitIgnore)(exclude, sourcePath).join("\n");
@@ -223,7 +225,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             if (data.options.verbose)
                 (0, cli_util_1.logExec)(`Writing paths lists`);
             await data.onProgress({
-                step: "Writing excluded paths list...",
+                relative: {
+                    description: "Writing excluded paths list",
+                },
             });
             gitignorePath = await (0, fs_util_1.writeGitIgnoreList)({
                 paths: stream,
@@ -233,7 +237,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             throw new AppError_1.AppError(`Tag prefix is not allowed`);
         const packageTag = ResticRepository.buildSnapshotTag(RepositoryAbstract_1.SnapshotTagEnum.PACKAGE, data.package.name);
         await data.onProgress({
-            step: "Fetching last snapshot...",
+            relative: {
+                description: "Fetching last snapshot",
+            },
         });
         const [lastSnapshot] = await restic.snapshots({
             json: true,
@@ -245,7 +251,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         let totalFilesChanges = 0;
         const totalFilesChangesLimit = 10;
         await data.onProgress({
-            step: "Executing backup action...",
+            relative: {
+                description: "Executing backup action",
+            },
         });
         let resticSnapshotId;
         let resticTotalBytes;
@@ -278,19 +286,24 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                     if (totalFilesChanges > totalFilesChangesLimit) {
                         showProgressBar = true;
                     }
-                    else if (lastProgress?.total !== streamData.total_files) {
+                    else if (lastProgress?.absolute?.total !== streamData.total_files) {
                         totalFilesChanges = 0;
                     }
                     else {
                         totalFilesChanges++;
                     }
                     await data.onProgress((lastProgress = {
-                        total: Math.max(lastProgress?.total || 0, streamData.total_files || 0),
-                        current: Math.max(lastProgress?.current || 0, streamData.files_done ?? 0),
-                        percent: showProgressBar
-                            ? Number((streamData.percent_done * 100).toFixed(2))
-                            : 0,
-                        step: streamData.current_files?.join(", ") ?? "-",
+                        relative: {
+                            description: "Copying file",
+                            payload: streamData.current_files?.join(", ") ?? "-",
+                        },
+                        absolute: {
+                            total: Math.max(lastProgress?.absolute?.total || 0, streamData.total_files || 0),
+                            current: Math.max(lastProgress?.absolute?.current || 0, streamData.files_done ?? 0),
+                            percent: showProgressBar
+                                ? Number((streamData.percent_done * 100).toFixed(2))
+                                : 0,
+                        },
                     }));
                 }
                 else if (streamData.message_type === "summary") {
@@ -306,9 +319,11 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const sizeTag = ResticRepository.buildSnapshotTag(RepositoryAbstract_1.SnapshotTagEnum.SIZE, resticTotalBytes.toString());
         await restic.exec(["tag", "--add", sizeTag, resticSnapshotId]);
         await data.onProgress({
-            total: lastProgress?.total || 0,
-            current: lastProgress?.total || 0,
-            percent: 100,
+            absolute: {
+                total: lastProgress?.absolute?.total || 0,
+                current: lastProgress?.absolute?.total || 0,
+                percent: 100,
+            },
         });
     }
     async onCopyBackup(data) {
@@ -357,9 +372,11 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 if (streamData.message_type === "restore-status") {
                     const current = Math.min(streamData.total_bytes, snapshot.size);
                     await data.onProgress({
-                        total: snapshot.size,
-                        current,
-                        percent: (0, math_util_1.progressPercent)(snapshot.size, current),
+                        absolute: {
+                            total: snapshot.size,
+                            current,
+                            percent: (0, math_util_1.progressPercent)(snapshot.size, current),
+                        },
                     });
                 }
             },

package/SessionDriver/ConsoleSessionDriver.d.ts

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+import { Progress } from "../util/progress";
 import { WriteDataType, ReadResultType, SessionDriverAbstract, SessionDriverOptions } from "./SessionDriverAbstract";
 declare type BadgeType = {
     name: string;
@@ -12,20 +13,14 @@ declare type MessageType = {
     text?: string;
     badges: BadgeType[];
     errorBadge?: BadgeType;
-    progressCurrent?: number | null;
-    progressTotal?: number | null;
-    progressPercent?: number | null;
-    progressStep?: string | null;
-    progressStepPercent?: number | null;
+    progress?: Progress;
 };
 declare type ConsoleSessionDriverOptions = SessionDriverOptions & {
     progress?: "auto" | "tty" | "plain";
-    progressInterval?: number;
 };
 export declare class ConsoleSessionDriver extends SessionDriverAbstract<ConsoleSessionDriverOptions> {
     protected lastMessage: MessageType | undefined;
     protected lastMessageText: string | undefined;
-    protected lastProgressDate: number | undefined;
     protected prints: number;
     protected renderInterval: NodeJS.Timeout;
     protected rendering?: boolean;

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