@datatruck/cli 0.13.0 → 0.15.0

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...",
+                step: {
+                    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...",
+                step: {
+                    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...",
+            step: {
+                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...",
+            step: {
+                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?.stats?.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(", ") ?? "-",
+                        step: {
+                            description: "Copying file",
+                            item: streamData.current_files?.join(", ") ?? "-",
+                        },
+                        stats: {
+                            total: Math.max(lastProgress?.stats?.total || 0, streamData.total_files || 0),
+                            current: Math.max(lastProgress?.stats?.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,
+            stats: {
+                total: lastProgress?.stats?.total || 0,
+                current: lastProgress?.stats?.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),
+                        stats: {
+                            total: snapshot.size,
+                            current,
+                            percent: (0, math_util_1.progressPercent)(snapshot.size, current),
+                        },
                     });
                 }
             },

package/SessionDriver/ConsoleSessionDriver.d.ts

@@ -15,17 +15,16 @@ declare type MessageType = {
     progressCurrent?: number | null;
     progressTotal?: number | null;
     progressPercent?: number | null;
-    progressStep?: string | null;
+    progressStepDescription?: string | null;
+    progressStepItem?: string | null;
     progressStepPercent?: number | null;
 };
 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

@@ -83,8 +83,15 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             typeof message.progressTotal === "number") {
             parts.push(`${message.progressCurrent ?? "?"}/${message.progressTotal ?? "?"}`);
         }
-        if (typeof message.progressStep === "string")
-            parts.push(message.progressStep);
+        if (message.progressStepDescription && message.progressStepItem) {
+            parts.push(`${message.progressStepDescription}: ${message.progressStepItem}`);
+        }
+        else if (message.progressStepDescription) {
+            parts.push(message.progressStepDescription);
+        }
+        else if (message.progressStepItem) {
+            parts.push(message.progressStepItem);
+        }
         if (typeof message.progressStepPercent === "number") {
             parts.push((0, chalk_1.cyan)((0, cli_util_1.renderProgressBar)(message.progressStepPercent ?? 0, 10)));
         }
@@ -93,13 +100,6 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
     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: [],
@@ -135,7 +135,8 @@ class ConsoleSessionDriver extends SessionDriverAbstract_1.SessionDriverAbstract
             message.progressPercent = data.data.progressPercent;
             message.progressCurrent = data.data.progressCurrent;
             message.progressTotal = data.data.progressTotal;
-            message.progressStep = data.data.progressStep;
+            message.progressStepDescription = data.data.progressStepDescription;
+            message.progressStepItem = data.data.progressStepItem;
             message.progressStepPercent = data.data.progressStepPercent;
         }
         if (data.entity === SessionDriverAbstract_1.EntityEnum.BackupSession ||

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 { ProgressDataType } from "../Repository/RepositoryAbstract";
+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 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,13 @@ 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;
+    } & ProgressDataType): 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;
+    } & ProgressDataType): 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();
@@ -35,6 +39,9 @@ class BackupSessionManager {
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
+            !this.checkProgress(data.data.progressStepDescription))
+            return data.data.id;
         for (const driver of drivers) {
             await driver.onWrite(data);
         }
@@ -139,7 +146,13 @@ class BackupSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });
@@ -182,7 +195,13 @@ class BackupSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });

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 { ProgressDataType } from "../Repository/RepositoryAbstract";
+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 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 lastProgressStepDescription: string | null | undefined;
     findId(data: {
         packageName: string;
     }): number;
@@ -37,8 +34,12 @@ 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;
+    } & ProgressDataType): 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;
+    } & ProgressDataType): 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();
@@ -35,6 +39,9 @@ class RestoreSessionManager {
     }
     async alter(data) {
         const drivers = [this.options.driver, ...(this.options.altDrivers ?? [])];
+        if (data.action === SessionDriverAbstract_1.ActionEnum.Progress &&
+            !this.checkProgress(data.data.progressStepDescription))
+            return data.data.id;
         for (const driver of drivers) {
             await driver.onWrite(data);
         }
@@ -154,7 +161,13 @@ class RestoreSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });
@@ -182,7 +195,13 @@ class RestoreSessionManager {
             sessionData: this.sessionVault.get(object.sessionId),
             data: {
                 ...object,
-                ...input,
+                id: input.id,
+                progressCurrent: input.stats?.current,
+                progressTotal: input.stats?.total,
+                progressPercent: input.stats?.percent,
+                progressStepDescription: input.step?.description,
+                progressStepItem: input.step?.item,
+                progressStepPercent: input.step?.percent,
                 updatingDate: new Date().toISOString(),
             },
         });

package/SessionManager/SessionManagerAbstract.d.ts

@@ -0,0 +1,14 @@
+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 lastProgressStepDescription: string | null | undefined;
+    constructor(options: OptionsType);
+    protected checkProgress(description: string | null | undefined): boolean;
+}

package/SessionManager/SessionManagerAbstract.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+class SessionManagerAbstract {
+    constructor(options) {
+        this.options = options;
+    }
+    checkProgress(description) {
+        const progressInterval = this.options.progressInterval;
+        if (progressInterval) {
+            const skip = this.lastProgressDate &&
+                description === this.lastProgressStepDescription &&
+                Date.now() - this.lastProgressDate < progressInterval;
+            if (skip)
+                return false;
+            this.lastProgressDate = Date.now();
+            this.lastProgressStepDescription = 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...",
+            step: {
+                description: "Creating bundle",
+            },
         });
         await (0, process_util_1.exec)(this.command, ["bundle", "create", bundlePath, "--all"], {
             cwd: path,
@@ -169,14 +171,20 @@ class GitTask extends TaskAbstract_1.TaskAbstract {
                     basePath: path,
                 },
                 targetPath: outPath,
+                skipNotFoundError: true,
                 concurrency: this.config.fileCopyConcurrency,
                 onPath: async ({ entryPath }) => {
                     currentFiles++;
                     await data.onProgress({
-                        total,
-                        current: currentFiles,
-                        percent: (0, math_util_1.progressPercent)(total, currentFiles),
-                        step: entryPath,
+                        step: {
+                            description: "Copying file",
+                            item: entryPath,
+                        },
+                        stats: {
+                            total,
+                            current: currentFiles,
+                            percent: (0, math_util_1.progressPercent)(total, currentFiles),
+                        },
                     });
                 },
             });
@@ -200,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,
+                stats: {
+                    total: totalFiles,
+                    current: Math.max(currentFiles, 0),
+                    percent: (0, math_util_1.progressPercent)(totalFiles, Math.max(currentFiles, 0)),
+                },
+                step: { description, item },
             });
-            currentFiles++;
+            if (count)
+                currentFiles++;
         };
         // Bundle
         const bundlePath = (0, path_1.join)(targetPath, "repo.bundle");
@@ -236,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}`,
+                    step: {
+                        description: "Copying file",
+                        item: path,
+                    },
+                    stats: {
+                        current,
+                        percent: (0, math_util_1.progressPercent)(total, current),
+                        total,
+                    },
                 });
             }
         };

package/Task/SqlDumpTaskAbstract.js

@@ -15,6 +15,7 @@ const path_1 = require("path");
 exports.sqlDumpTaskDefinition = {
     type: "object",
     required: ["password", "hostname", "username", "database"],
+    additionalProperties: false,
     properties: {
         password: {
             anyOf: [
@@ -117,24 +118,39 @@ 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 }));
+            data.onProgress({
+                step: {
+                    description: "Exporting",
+                },
+            });
             await this.onExportTables(tableNames, outPath);
         }
         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,
+                    step: {
+                        description: "Exporting",
+                        item: tableName,
+                    },
+                    stats: {
+                        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);
+                current++;
             }
         }
         if (this.config.storedPrograms) {
             const outPath = (0, path_1.join)(outputPath, "stored-programs.sql");
+            data.onProgress({
+                step: {
+                    description: "Exporting storaged programs",
+                },
+            });
             await this.onExportStoredPrograms(outPath);
         }
     }
@@ -183,13 +199,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,
+                step: {
+                    description: "Importing",
+                    item: item.fileName,
+                },
+                stats: {
+                    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

@@ -3,11 +3,16 @@ 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;
+    stats?: {
+        total?: number;
+        current?: number;
+        percent?: number;
+    };
+    step?: {
+        description?: string;
+        item?: string;
+        percent?: number;
+    };
 };
 export declare type BackupDataType = {
     onProgress: (data: ProgressDataType) => Promise<void>;

package/cli.js

@@ -81,7 +81,7 @@ program.usage("dtt");
 program.option("-v,--verbose", "Verbose", (_, previous) => previous + 1, 0);
 program.option("-c,--config <path>", "Config path", process.env["DATATRUCK_CONFIG"] ?? (cwd.endsWith(path_1.sep) ? cwd : `${cwd}${path_1.sep}`));
 program.option("--progress <value>", "Progress type (auto, plain, tty)", "auto");
-program.option("--progress-interval <ms>", "Progress interval");
+program.option("--progress-interval <ms>", "Progress interval", Number, 1000);
 program.option("-o,--output-format <format>", "Output format (json, pjson, yaml, table, custom=$, tpl=name)", "table");
 makeCommand(CommandFactory_1.CommandEnum.config).alias("c");
 makeCommand(CommandFactory_1.CommandEnum.init).alias("i");

package/config.schema.json

@@ -475,6 +475,9 @@
                       "include"
                     ],
                     "properties": {
+                      "name": {
+                        "type": "string"
+                      },
                       "include": {
                         "$ref": "#/definitions/stringlist-util"
                       },
@@ -683,6 +686,7 @@
         "username",
         "database"
       ],
+      "additionalProperties": false,
       "properties": {
         "password": {
           "anyOf": [