@datatruck/cli 0.14.0 → 0.16.1

package/Action/BackupAction.d.ts

@@ -23,10 +23,17 @@ export declare class BackupAction<TRequired extends boolean = true> {
     protected repoErrors: Record<string, Error[]>;
     constructor(config: ConfigType, options?: IfRequireKeys<TRequired, BackupActionOptionsType>);
     protected init(session: BackupSessionManager): Promise<[SnapshotType, PackageConfigType[]]>;
-    protected execTask(session: BackupSessionManager, pkg: PackageConfigType, task: TaskConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
-    protected execRepository(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
-    protected execCopyRepository(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, mirrorRepo: RepositoryConfigType, snapshot: SnapshotType): Promise<boolean>;
+    protected task(session: BackupSessionManager, pkg: PackageConfigType, task: TaskConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
+    protected backup(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
+    protected copyBackup(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, mirrorRepo: RepositoryConfigType, snapshot: SnapshotType): Promise<boolean>;
     protected getError(pkg: PackageConfigType): AppError | null;
+    protected splitRepositories(repositoryNames: string[]): {
+        repoNames: string[];
+        mirrors: {
+            sourceName: string;
+            name: string;
+        }[];
+    };
     exec(session: BackupSessionManager): Promise<{
         total: number;
         errors: number;

package/Action/BackupAction.js

@@ -15,7 +15,7 @@ class BackupAction {
     }
     async init(session) {
         const snapshot = {
-            id: (0, crypto_1.randomBytes)(20).toString("hex"),
+            id: (0, crypto_1.randomUUID)().replaceAll("-", ""),
             date: this.options.date ?? new Date().toISOString(),
         };
         await session.initDrivers();
@@ -53,7 +53,7 @@ class BackupAction {
         }
         return [snapshot, packages];
     }
-    async execTask(session, pkg, task, snapshot, targetPath) {
+    async task(session, pkg, task, snapshot, targetPath) {
         const taskId = session.findTaskId({
             packageName: pkg.name,
             taskName: task.name,
@@ -74,14 +74,10 @@ class BackupAction {
                     options: this.options,
                     snapshot,
                     targetPath,
-                    onProgress: async (data) => {
+                    onProgress: async (progress) => {
                         await session.progressTask({
                             id: taskId,
-                            progressCurrent: data.current,
-                            progressPercent: data.percent,
-                            progressStep: data.step,
-                            progressStepPercent: data.stepPercent,
-                            progressTotal: data.total,
+                            progress,
                         });
                     },
                 });
@@ -98,7 +94,7 @@ class BackupAction {
         });
         return error ? false : true;
     }
-    async execRepository(session, pkg, repo, snapshot, targetPath) {
+    async backup(session, pkg, repo, snapshot, targetPath) {
         const repositoryId = session.findRepositoryId({
             packageName: pkg.name,
             repositoryName: repo.name,
@@ -120,14 +116,10 @@ class BackupAction {
                         (!config.names || config.names.includes(repo.name)))?.config,
                     options: this.options,
                     snapshot: snapshot,
-                    onProgress: async (data) => {
+                    onProgress: async (progress) => {
                         await session.progressRepository({
                             id: repositoryId,
-                            progressCurrent: data.current,
-                            progressPercent: data.percent,
-                            progressStep: data.step,
-                            progressStepPercent: data.stepPercent,
-                            progressTotal: data.total,
+                            progress,
                         });
                     },
                 });
@@ -144,7 +136,7 @@ class BackupAction {
         });
         return error ? false : true;
     }
-    async execCopyRepository(session, pkg, repo, mirrorRepo, snapshot) {
+    async copyBackup(session, pkg, repo, mirrorRepo, snapshot) {
         const repositoryId = session.findRepositoryId({
             packageName: pkg.name,
             repositoryName: mirrorRepo.name,
@@ -164,14 +156,10 @@ class BackupAction {
                     package: pkg,
                     snapshot,
                     mirrorRepositoryConfig: mirrorRepo.config,
-                    onProgress: async (data) => {
+                    onProgress: async (progress) => {
                         await session.progressRepository({
                             id: repositoryId,
-                            progressCurrent: data.current,
-                            progressPercent: data.percent,
-                            progressStep: data.step,
-                            progressStepPercent: data.stepPercent,
-                            progressTotal: data.total,
+                            progress,
                         });
                     },
                 });
@@ -204,12 +192,33 @@ class BackupAction {
             return null;
         }
     }
+    splitRepositories(repositoryNames) {
+        const mirrorRepoMap = {};
+        const allMirrorRepoNames = [];
+        const repoNames = repositoryNames ?? [];
+        for (const repoName of repoNames) {
+            const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
+            if (repo.mirrorRepoNames)
+                mirrorRepoMap[repoName] = repo.mirrorRepoNames.filter((mirrorRepoName) => {
+                    allMirrorRepoNames.push(mirrorRepoName);
+                    return repoNames.includes(mirrorRepoName);
+                });
+        }
+        return {
+            repoNames: repoNames.filter((v) => !allMirrorRepoNames.includes(v)),
+            mirrors: repoNames.flatMap((sourceName) => {
+                const mirrorNames = mirrorRepoMap[sourceName] || [];
+                return mirrorNames.map((name) => ({
+                    sourceName,
+                    name,
+                }));
+            }),
+        };
+    }
     async exec(session) {
         const [snapshot, packages] = await this.init(session);
-        let total = 0;
         let errors = 0;
         for (const pkg of packages) {
-            total++;
             const id = session.findId({
                 packageName: pkg.name,
             });
@@ -224,34 +233,17 @@ class BackupAction {
                     package: pkg,
                     snapshot,
                 });
-                await this.execTask(session, pkg, pkg.task, snapshot, (targetPath = result?.targetPath));
+                await this.task(session, pkg, pkg.task, snapshot, (targetPath = result?.targetPath));
             }
-            const mirrorRepoMap = {};
-            const allMirrorRepoNames = [];
-            const repoNames = pkg.repositoryNames ?? [];
+            const { repoNames, mirrors } = this.splitRepositories(pkg.repositoryNames ?? []);
             for (const repoName of repoNames) {
                 const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                if (repo.mirrorRepoNames)
-                    mirrorRepoMap[repoName] = repo.mirrorRepoNames.filter((mirrorRepoName) => {
-                        allMirrorRepoNames.push(mirrorRepoName);
-                        return repoNames.includes(mirrorRepoName);
-                    });
+                await this.backup(session, pkg, repo, snapshot, targetPath);
             }
-            for (const repoName of repoNames) {
-                if (allMirrorRepoNames.includes(repoName))
-                    continue;
-                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                await this.execRepository(session, pkg, repo, snapshot, targetPath);
-            }
-            for (const repoName of repoNames) {
-                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                const mirrorRepoNames = mirrorRepoMap[repoName];
-                if (mirrorRepoNames) {
-                    for (const mirrorRepoName of mirrorRepoNames) {
-                        const mirrorRepo = (0, config_util_1.findRepositoryOrFail)(this.config, mirrorRepoName);
-                        await this.execCopyRepository(session, pkg, repo, mirrorRepo, snapshot);
-                    }
-                }
+            for (const mirror of mirrors) {
+                const repo = (0, config_util_1.findRepositoryOrFail)(this.config, mirror.sourceName);
+                const mirrorRepo = (0, config_util_1.findRepositoryOrFail)(this.config, mirror.name);
+                await this.copyBackup(session, pkg, repo, mirrorRepo, snapshot);
             }
             const error = this.getError(pkg);
             if (error)
@@ -265,7 +257,7 @@ class BackupAction {
             snapshotId: snapshot.id.slice(0, 8),
         });
         return {
-            total: total,
+            total: packages.length,
             errors: errors,
         };
     }

package/Action/RestoreAction.d.ts

@@ -30,8 +30,8 @@ export declare class RestoreAction<TRequired extends boolean = true> {
     protected init(session: RestoreSessionManager, snapshotId: string, snapshots: SnapshotAndConfigType[]): Promise<void>;
     protected findSnapshots(): Promise<SnapshotType[]>;
     protected groupSnapshots(snapshots: SnapshotType[]): SnapshotType[];
-    protected execTask(session: RestoreSessionManager, pkg: PackageConfigType, task: TaskConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
-    protected execRepository(session: RestoreSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
+    protected task(session: RestoreSessionManager, pkg: PackageConfigType, task: TaskConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
+    protected restore(session: RestoreSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<boolean>;
     protected getError(pkg: PackageConfigType): AppError | null;
     exec(session: RestoreSessionManager): Promise<boolean>;
 }

package/Action/RestoreAction.js

@@ -88,7 +88,7 @@ class RestoreAction {
             return true;
         });
     }
-    async execTask(session, pkg, task, snapshot, targetPath) {
+    async task(session, pkg, task, snapshot, targetPath) {
         const taskId = session.findTaskId({
             packageName: pkg.name,
             taskName: task.name,
@@ -111,14 +111,10 @@ class RestoreAction {
                     options: this.options,
                     snapshot,
                     targetPath,
-                    onProgress: async (data) => {
+                    onProgress: async (progress) => {
                         await session.progressTask({
                             id: taskId,
-                            progressCurrent: data.current,
-                            progressPercent: data.percent,
-                            progressStep: data.step,
-                            progressStepPercent: data.stepPercent,
-                            progressTotal: data.total,
+                            progress,
                         });
                     },
                 });
@@ -135,7 +131,7 @@ class RestoreAction {
         });
         return error ? false : true;
     }
-    async execRepository(session, pkg, repo, snapshot, targetPath) {
+    async restore(session, pkg, repo, snapshot, targetPath) {
         const repositoryId = session.findRepositoryId({
             packageName: pkg.name,
             repositoryName: repo.name,
@@ -160,14 +156,10 @@ class RestoreAction {
                     (!config.names || config.names.includes(repo.name)))?.config,
                 options: this.options,
                 snapshot: snapshot,
-                onProgress: async (data) => {
+                onProgress: async (progress) => {
                     await session.progressRepository({
                         id: repositoryId,
-                        progressCurrent: data.current,
-                        progressPercent: data.percent,
-                        progressStep: data.step,
-                        progressStepPercent: data.stepPercent,
-                        progressTotal: data.total,
+                        progress,
                     });
                 },
             });
@@ -240,9 +232,9 @@ class RestoreAction {
                 });
                 targetPath = result?.targetPath;
             }
-            await this.execRepository(session, pkg, repo, snapshot, targetPath);
+            await this.restore(session, pkg, repo, snapshot, targetPath);
             if (pkg.task)
-                await this.execTask(session, pkg, pkg.task, snapshot, targetPath);
+                await this.task(session, pkg, pkg.task, snapshot, targetPath);
             const error = this.getError(pkg);
             await session.end({
                 id,

package/Command/BackupCommand.js

@@ -68,9 +68,10 @@ class BackupCommand extends CommandAbstract_1.CommandAbstract {
                 new ConsoleSessionDriver_1.ConsoleSessionDriver({
                     verbose: verbose > 0,
                     progress: this.globalOptions.progress,
-                    progressInterval: this.globalOptions.progressInterval,
                 }),
             ],
+            verbose: verbose > 1,
+            progressInterval: this.globalOptions.progressInterval,
         });
         const result = await backup.exec(sessionManager);
         if (result.errors) {

package/Command/BackupSessionsCommand.js

@@ -50,6 +50,7 @@ class BackupSessionsCommand extends CommandAbstract_1.CommandAbstract {
                 verbose: verbose > 1,
             }),
             verbose: verbose > 1,
+            progressInterval: this.globalOptions.progressInterval,
         });
         const items = await action.exec(manager);
         const dataFormat = new DataFormat_1.DataFormat({

package/Command/RestoreCommand.js

@@ -68,10 +68,10 @@ class RestoreCommand extends CommandAbstract_1.CommandAbstract {
                 new ConsoleSessionDriver_1.ConsoleSessionDriver({
                     verbose: verbose > 0,
                     progress: this.globalOptions.progress,
-                    progressInterval: this.globalOptions.progressInterval,
                 }),
             ],
             verbose: verbose > 1,
+            progressInterval: this.globalOptions.progressInterval,
         });
         const result = await restore.exec(sessionManager);
         return result ? 0 : 1;

package/Command/RestoreSessionsCommand.js

@@ -49,6 +49,7 @@ class RestoreSessionsCommand extends CommandAbstract_1.CommandAbstract {
             driver: new SqliteSessionDriver_1.SqliteSessionDriver({
                 verbose: verbose > 1,
             }),
+            progressInterval: this.globalOptions.progressInterval,
         });
         const items = await action.exec(manager);
         const dataFormat = new DataFormat_1.DataFormat({

package/Entity/StateEntityAbstract.d.ts

@@ -1,12 +1,9 @@
+import { Progress } from "../util/progress";
 import { CrudEntityAbstract } from "./CrudEntityAbstract";
 export declare abstract class StateEntityAbstract extends CrudEntityAbstract {
     state: "started" | "ended" | null;
     error?: string | null;
     startDate?: string | null;
     endDate?: string | null;
-    progressTotal?: number | null;
-    progressCurrent?: number | null;
-    progressPercent?: number | null;
-    progressStep?: string | null;
-    progressStepPercent?: number | null;
+    progress?: Progress;
 }

package/Error/AppError.d.ts

@@ -1,2 +1,3 @@
 export declare class AppError extends Error {
+    constructor(message: string);
 }

package/Error/AppError.js

@@ -2,5 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AppError = void 0;
 class AppError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = AppError.name;
+    }
 }
 exports.AppError = AppError;

package/Repository/DatatruckRepository.d.ts

@@ -49,6 +49,7 @@ export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRep
     static stringifyMetaData(data: MetaDataType): string;
     onGetSource(): string;
     onInit(data: InitDataType): Promise<void>;
+    private createFileScanner;
     onPrune(data: PruneDataType): Promise<void>;
     onSnapshots(data: SnapshotsDataType): Promise<SnapshotResultType[]>;
     private normalizeCompressConfig;