@datatruck/cli 0.16.1 → 0.17.0

package/Action/BackupAction.d.ts

@@ -1,12 +1,12 @@
 import type { ConfigType } from "../Config/Config";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
-import { TaskConfigType } from "../Config/TaskConfig";
 import { AppError } from "../Error/AppError";
 import { SnapshotType } from "../Repository/RepositoryAbstract";
 import { BackupSessionManager } from "../SessionManager/BackupSessionManager";
+import { TaskAbstract } from "../Task/TaskAbstract";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type BackupActionOptionsType = {
+export type BackupActionOptionsType = {
     repositoryNames?: string[];
     repositoryTypes?: string[];
     packageNames?: string[];
@@ -23,9 +23,18 @@ 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 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 task(session: BackupSessionManager, pkg: PackageConfigType, task: TaskAbstract<any>, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
+    protected backup(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
+    protected copyBackup(session: BackupSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, mirrorRepo: RepositoryConfigType, snapshot: SnapshotType): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
     protected getError(pkg: PackageConfigType): AppError | null;
     protected splitRepositories(repositoryNames: string[]): {
         repoNames: string[];

package/Action/BackupAction.js

@@ -5,6 +5,7 @@ const AppError_1 = require("../Error/AppError");
 const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
 const TaskFactory_1 = require("../Factory/TaskFactory");
 const config_util_1 = require("../util/datatruck/config-util");
+const fs_util_1 = require("../util/fs-util");
 const crypto_1 = require("crypto");
 class BackupAction {
     constructor(config, options = {}) {
@@ -56,7 +57,7 @@ class BackupAction {
     async task(session, pkg, task, snapshot, targetPath) {
         const taskId = session.findTaskId({
             packageName: pkg.name,
-            taskName: task.name,
+            taskName: pkg.task.name,
         });
         await session.startTask({
             id: taskId,
@@ -68,8 +69,7 @@ class BackupAction {
         }
         else {
             try {
-                const taskInstance = (0, TaskFactory_1.TaskFactory)(task);
-                await taskInstance.onBackup({
+                await task.onBackup({
                     package: pkg,
                     options: this.options,
                     snapshot,
@@ -92,7 +92,10 @@ class BackupAction {
             id: taskId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: task.tmpDirs,
+        };
     }
     async backup(session, pkg, repo, snapshot, targetPath) {
         const repositoryId = session.findRepositoryId({
@@ -103,12 +106,13 @@ class BackupAction {
             id: repositoryId,
         });
         let error;
+        let repoInstance;
         if (this.taskErrors[pkg.name]?.length) {
             error = new AppError_1.AppError("Task failed");
         }
         else {
             try {
-                const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+                repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
                 await repoInstance.onBackup({
                     package: pkg,
                     targetPath,
@@ -134,7 +138,10 @@ class BackupAction {
             id: repositoryId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: repoInstance?.tmpDirs ?? [],
+        };
     }
     async copyBackup(session, pkg, repo, mirrorRepo, snapshot) {
         const repositoryId = session.findRepositoryId({
@@ -145,12 +152,13 @@ class BackupAction {
             id: repositoryId,
         });
         let error;
+        let repoInstance;
         if (this.taskErrors[pkg.name]?.length) {
             error = new AppError_1.AppError("Task failed");
         }
         else {
             try {
-                const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+                repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
                 await repoInstance.onCopyBackup({
                     options: this.options,
                     package: pkg,
@@ -174,7 +182,10 @@ class BackupAction {
             id: repositoryId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: repoInstance?.tmpDirs ?? [],
+        };
     }
     getError(pkg) {
         const taskErrors = this.taskErrors[pkg.name]?.length;
@@ -226,6 +237,7 @@ class BackupAction {
                 id,
             });
             let targetPath;
+            let taskTmpDirs = [];
             if (pkg.task) {
                 const taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
                 const result = await taskInstance.onBeforeBackup({
@@ -233,17 +245,28 @@ class BackupAction {
                     package: pkg,
                     snapshot,
                 });
-                await this.task(session, pkg, pkg.task, snapshot, (targetPath = result?.targetPath));
+                const taskResult = await this.task(session, pkg, taskInstance, snapshot, (targetPath = result?.targetPath));
+                taskTmpDirs.push(...taskResult.tmpDirs);
             }
             const { repoNames, mirrors } = this.splitRepositories(pkg.repositoryNames ?? []);
             for (const repoName of repoNames) {
                 const repo = (0, config_util_1.findRepositoryOrFail)(this.config, repoName);
-                await this.backup(session, pkg, repo, snapshot, targetPath);
+                const { tmpDirs } = await this.backup(session, pkg, repo, snapshot, targetPath);
+                if (!this.options.verbose)
+                    await (0, fs_util_1.rmTmpDir)(tmpDirs);
+            }
+            if (!this.options.verbose) {
+                await (0, fs_util_1.rmTmpDir)(taskTmpDirs);
+                if (pkg.path && (0, fs_util_1.isTmpDir)(pkg.path)) {
+                    await (0, fs_util_1.rmTmpDir)(pkg.path);
+                }
             }
             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 { tmpDirs } = await this.copyBackup(session, pkg, repo, mirrorRepo, snapshot);
+                if (!this.options.verbose)
+                    await (0, fs_util_1.rmTmpDir)(tmpDirs);
             }
             const error = this.getError(pkg);
             if (error)

package/Action/BackupSessionsAction.d.ts

@@ -2,7 +2,7 @@ import type { ConfigType } from "../Config/Config";
 import { ReadDataType } from "../SessionDriver/SessionDriverAbstract";
 import { BackupSessionManager } from "../SessionManager/BackupSessionManager";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type BackupSessionsActionOptionsType = ReadDataType & {
+export type BackupSessionsActionOptionsType = ReadDataType & {
     verbose?: boolean;
 };
 export declare class BackupSessionsAction<TRequired extends boolean = true> {

package/Action/CleanCacheAction.d.ts

@@ -1,5 +1,5 @@
 import { IfRequireKeys } from "../util/ts-util";
-export declare type CleanCacheActionOptionsType = {
+export type CleanCacheActionOptionsType = {
     verbose?: boolean;
 };
 export declare class CleanCacheAction<TRequired extends boolean = true> {

package/Action/ConfigAction.d.ts

@@ -1,7 +1,7 @@
 import { GlobalOptionsType } from "../Command/CommandAbstract";
 import type { ConfigType } from "../Config/Config";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type ConfigActionOptionsType = {
+export type ConfigActionOptionsType = {
     path: string;
     verbose?: boolean;
 };

package/Action/InitAction.d.ts

@@ -1,6 +1,6 @@
 import type { ConfigType } from "../Config/Config";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type InitActionOptionsType = {
+export type InitActionOptionsType = {
     repositoryNames?: string[];
     repositoryTypes?: string[];
     verbose?: boolean;

package/Action/PruneAction.d.ts

@@ -2,7 +2,7 @@ import type { ConfigType } from "../Config/Config";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { IfRequireKeys } from "../util/ts-util";
 import { SnapshotExtendedType, SnapshotsActionOptionsType } from "./SnapshotsAction";
-export declare type PruneActionsOptionsType = {
+export type PruneActionsOptionsType = {
     ids?: string[];
     packageNames?: string[];
     repositoryNames?: string[];
@@ -21,7 +21,7 @@ export declare type PruneActionsOptionsType = {
     longId?: boolean;
     returnsAll?: boolean;
 };
-export declare type PruneResultType = {
+export type PruneResultType = {
     total: number;
     prune: number;
     snapshots: (SnapshotExtendedType & {

package/Action/RestoreAction.d.ts

@@ -1,12 +1,12 @@
 import type { ConfigType } from "../Config/Config";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
-import { TaskConfigType } from "../Config/TaskConfig";
 import { AppError } from "../Error/AppError";
 import { SnapshotResultType } from "../Repository/RepositoryAbstract";
 import { RestoreSessionManager } from "../SessionManager/RestoreSessionManager";
+import { TaskAbstract } from "../Task/TaskAbstract";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type RestoreActionOptionsType = {
+export type RestoreActionOptionsType = {
     snapshotId: string;
     tags?: string[];
     packageNames?: string[];
@@ -16,10 +16,10 @@ export declare type RestoreActionOptionsType = {
     repositoryTypes?: string[];
     verbose?: boolean;
 };
-declare type SnapshotType = SnapshotResultType & {
+type SnapshotType = SnapshotResultType & {
     repositoryName: string;
 };
-declare type SnapshotAndConfigType = [SnapshotType, PackageConfigType | null];
+type SnapshotAndConfigType = [SnapshotType, PackageConfigType | null];
 export declare class RestoreAction<TRequired extends boolean = true> {
     readonly config: ConfigType;
     readonly options: IfRequireKeys<TRequired, RestoreActionOptionsType>;
@@ -30,8 +30,14 @@ 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 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 task(session: RestoreSessionManager, pkg: PackageConfigType, task: TaskAbstract<any>, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
+    protected restore(session: RestoreSessionManager, pkg: PackageConfigType, repo: RepositoryConfigType, snapshot: SnapshotType, targetPath: string | undefined): Promise<{
+        error: boolean;
+        tmpDirs: string[];
+    }>;
     protected getError(pkg: PackageConfigType): AppError | null;
     exec(session: RestoreSessionManager): Promise<boolean>;
 }

package/Action/RestoreAction.js

@@ -91,7 +91,7 @@ class RestoreAction {
     async task(session, pkg, task, snapshot, targetPath) {
         const taskId = session.findTaskId({
             packageName: pkg.name,
-            taskName: task.name,
+            taskName: pkg.task.name,
         });
         await session.startTask({
             id: taskId,
@@ -105,8 +105,7 @@ class RestoreAction {
         }
         else {
             try {
-                const taskInstance = (0, TaskFactory_1.TaskFactory)(task);
-                await taskInstance.onRestore({
+                await task.onRestore({
                     package: pkg,
                     options: this.options,
                     snapshot,
@@ -129,7 +128,10 @@ class RestoreAction {
             id: taskId,
             error: error?.stack,
         });
-        return error ? false : true;
+        return {
+            error: error ? false : true,
+            tmpDirs: task?.tmpDirs ?? [],
+        };
     }
     async restore(session, pkg, repo, snapshot, targetPath) {
         const repositoryId = session.findRepositoryId({
@@ -140,6 +142,7 @@ class RestoreAction {
             id: repositoryId,
         });
         let repoError;
+        let repoInstance;
         try {
             if (typeof pkg.restorePath !== "string")
                 throw new AppError_1.AppError("Restore path is not defined");
@@ -148,7 +151,7 @@ class RestoreAction {
                 throw new AppError_1.AppError(`Restore path is not empty: ${pkg.restorePath}`);
             if (this.options.verbose)
                 (0, cli_util_1.logExec)(`restorePath=${pkg.restorePath}`);
-            const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+            repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
             await repoInstance.onRestore({
                 package: pkg,
                 targetPath,
@@ -179,7 +182,10 @@ class RestoreAction {
             id: repositoryId,
             error: repoError?.stack,
         });
-        return repoError ? false : true;
+        return {
+            error: repoError ? false : true,
+            tmpDirs: repoInstance?.tmpDirs || [],
+        };
     }
     getError(pkg) {
         const taskErrors = this.taskErrors[pkg.name]?.length;
@@ -223,8 +229,9 @@ class RestoreAction {
             });
             await session.start({ id });
             let targetPath;
+            let taskInstance;
             if (pkg.task) {
-                const taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
+                taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
                 const result = await taskInstance.onBeforeRestore({
                     options: this.options,
                     package: pkg,
@@ -232,9 +239,16 @@ class RestoreAction {
                 });
                 targetPath = result?.targetPath;
             }
-            await this.restore(session, pkg, repo, snapshot, targetPath);
-            if (pkg.task)
-                await this.task(session, pkg, pkg.task, snapshot, targetPath);
+            const { tmpDirs } = await this.restore(session, pkg, repo, snapshot, targetPath);
+            if (taskInstance) {
+                await this.task(session, pkg, taskInstance, snapshot, targetPath);
+            }
+            if (!this.options.verbose) {
+                await (0, fs_util_1.rmTmpDir)(taskInstance?.tmpDirs || []);
+                await (0, fs_util_1.rmTmpDir)(tmpDirs);
+                if (pkg.restorePath && (0, fs_util_1.isTmpDir)(pkg.restorePath))
+                    await (0, fs_util_1.rmTmpDir)(pkg.restorePath);
+            }
             const error = this.getError(pkg);
             await session.end({
                 id,

package/Action/RestoreSessionsAction.d.ts

@@ -2,7 +2,7 @@ import type { ConfigType } from "../Config/Config";
 import { ReadDataType } from "../SessionDriver/SessionDriverAbstract";
 import { RestoreSessionManager } from "../SessionManager/RestoreSessionManager";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type RestoreSessionsActionOptionsType = ReadDataType & {
+export type RestoreSessionsActionOptionsType = ReadDataType & {
     verbose?: boolean;
 };
 export declare class RestoreSessionsAction<TRequired extends boolean = true> {

package/Action/SnapshotsAction.d.ts

@@ -2,8 +2,8 @@ import type { ConfigType } from "../Config/Config";
 import { RepositoryConfigEnabledActionType } from "../Config/RepositoryConfig";
 import { SnapshotResultType } from "../Repository/RepositoryAbstract";
 import { IfRequireKeys } from "../util/ts-util";
-export declare type SnapshotGroupByType = keyof Pick<SnapshotExtendedType, "packageName" | "repositoryName" | "repositoryType">;
-export declare type SnapshotsActionOptionsType = {
+export type SnapshotGroupByType = keyof Pick<SnapshotExtendedType, "packageName" | "repositoryName" | "repositoryType">;
+export type SnapshotsActionOptionsType = {
     ids?: string[];
     repositoryNames?: string[];
     packageNames?: string[];
@@ -21,7 +21,7 @@ export declare type SnapshotsActionOptionsType = {
     lastYearly?: number;
     groupBy?: SnapshotGroupByType[];
 };
-export declare type SnapshotExtendedType = {
+export type SnapshotExtendedType = {
     shortId: string;
     repositoryName: string;
     repositoryType: string;

package/Command/BackupCommand.d.ts

@@ -1,7 +1,7 @@
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type BackupCommandOptionsType<TResolved = false> = {
+export type BackupCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;

package/Command/BackupSessionsCommand.d.ts

@@ -1,6 +1,6 @@
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type BackupSessionsCommandOptionsType<TResolved = false> = {
+export type BackupSessionsCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     tag?: If<TResolved, string[]>;

package/Command/CleanCacheCommand.d.ts

@@ -1,5 +1,5 @@
 import { CommandAbstract } from "./CommandAbstract";
-export declare type CleanCacheCommandOptionsType<TResolved = false> = {};
+export type CleanCacheCommandOptionsType<TResolved = false> = {};
 export declare class CleanCacheCommand extends CommandAbstract<CleanCacheCommandOptionsType<false>, CleanCacheCommandOptionsType<true>> {
     onOptions(): import("../util/cli-util").OptionsType<CleanCacheCommandOptionsType<false>, CleanCacheCommandOptionsType<true>>;
     onExec(): Promise<number>;

package/Command/CommandAbstract.d.ts

@@ -2,14 +2,14 @@ import { ConfigType } from "../Config/Config";
 import { FormatType } from "../util/DataFormat";
 import { OptionsType } from "../util/cli-util";
 import { SimilarObject } from "../util/ts-util";
-export declare type GlobalOptionsType<TResolved = false> = {
+export type GlobalOptionsType<TResolved = false> = {
     config: string | ConfigType;
     outputFormat?: FormatType;
     verbose?: number;
     progress?: "auto" | "plain" | "tty";
     progressInterval?: number;
 };
-export declare type CommandConstructorType<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> = {
+export type CommandConstructorType<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> = {
     new (globalOptions: GlobalOptionsType<true>, options: TOptions): CommandAbstract<TUnresolvedOptions, TOptions>;
 };
 export declare abstract class CommandAbstract<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> {

package/Command/ConfigCommand.d.ts

@@ -1,13 +1,13 @@
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type ConfigCommandOptionsType<TResolved = false> = {
+export type ConfigCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
 };
-export declare type ConfigCommandLogType = {
+export type ConfigCommandLogType = {
     packageName: string;
     repositoryNames: string[];
     taskName: string | undefined;

package/Command/InitCommand.d.ts

@@ -2,11 +2,11 @@ import { InitAction } from "../Action/InitAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type InitCommandOptionsType<TResolved = false> = {
+export type InitCommandOptionsType<TResolved = false> = {
     repository?: If<TResolved, string[]>;
     repositoryType?: If<TResolved, RepositoryConfigType["type"][]>;
 };
-export declare type InitCommandLogType = Unwrap<InitAction["exec"]>;
+export type InitCommandLogType = Unwrap<InitAction["exec"]>;
 export declare class InitCommand extends CommandAbstract<InitCommandOptionsType<false>, InitCommandOptionsType<true>> {
     onOptions(): import("../util/cli-util").OptionsType<InitCommandOptionsType<false>, InitCommandOptionsType<true>>;
     onExec(): Promise<number>;

package/Command/PruneCommand.d.ts

@@ -2,7 +2,7 @@ import { SnapshotGroupByType } from "../Action/SnapshotsAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type PruneCommandOptionsType<TResolved = false> = {
+export type PruneCommandOptionsType<TResolved = false> = {
     id?: If<TResolved, string[]>;
     longId?: boolean;
     package?: If<TResolved, string[]>;

package/Command/RestoreCommand.d.ts

@@ -1,7 +1,7 @@
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type RestoreCommandOptionsType<TResolved = false> = {
+export type RestoreCommandOptionsType<TResolved = false> = {
     id: string;
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;

package/Command/RestoreSessionsCommand.d.ts

@@ -1,6 +1,6 @@
 import { If } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type RestoreSessionsCommandOptionsType<TResolved = false> = {
+export type RestoreSessionsCommandOptionsType<TResolved = false> = {
     package?: If<TResolved, string[]>;
     repository?: If<TResolved, string[]>;
     tag?: If<TResolved, string[]>;

package/Command/SnapshotsCommand.d.ts

@@ -2,7 +2,7 @@ import { SnapshotsAction } from "../Action/SnapshotsAction";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
 import { If, Unwrap } from "../util/ts-util";
 import { CommandAbstract } from "./CommandAbstract";
-export declare type SnapshotsCommandOptionsType<TResolved = false> = {
+export type SnapshotsCommandOptionsType<TResolved = false> = {
     id?: If<TResolved, string[]>;
     package?: If<TResolved, string[]>;
     packageTask?: If<TResolved, string[]>;
@@ -20,7 +20,7 @@ export declare type SnapshotsCommandOptionsType<TResolved = false> = {
     groupBy?: If<TResolved, SnapshotsAction["options"]["groupBy"]>;
     tag?: If<TResolved, string[]>;
 };
-export declare type SnapshotsCommandLogType = Unwrap<SnapshotsAction["exec"]>;
+export type SnapshotsCommandLogType = Unwrap<SnapshotsAction["exec"]>;
 export declare class SnapshotsCommand extends CommandAbstract<SnapshotsCommandOptionsType<false>, SnapshotsCommandOptionsType<true>> {
     onOptions(): import("../util/cli-util").OptionsType<SnapshotsCommandOptionsType<false>, SnapshotsCommandOptionsType<true>>;
     onExec(): Promise<number>;

package/Command/SnapshotsCommand.js

@@ -12,7 +12,12 @@ const CommandAbstract_1 = require("./CommandAbstract");
 const pretty_bytes_1 = __importDefault(require("pretty-bytes"));
 class SnapshotsCommand extends CommandAbstract_1.CommandAbstract {
     onOptions() {
-        const groupByValues = ["packageName", "repositoryName", "repositoryType"];
+        const groupByValues = [
+            "id",
+            "packageName",
+            "repositoryName",
+            "repositoryType",
+        ];
         return this.returnsOptions({
             groupBy: {
                 option: "-g,--group-by <values>",

package/Config/Config.d.ts

@@ -1,7 +1,7 @@
 import { PackageConfigType } from "./PackageConfig";
 import { RepositoryConfigType } from "./RepositoryConfig";
 import type { JSONSchema7 } from "json-schema";
-export declare type ConfigType = {
+export type ConfigType = {
     tempDir?: string;
     repositories: RepositoryConfigType[];
     packages: PackageConfigType[];

package/Config/PackageConfig.d.ts

@@ -4,12 +4,12 @@ import type { TaskConfigType } from "./TaskConfig";
 import { JSONSchema7 } from "json-schema";
 export declare const packageConfigDefinition: JSONSchema7;
 export declare const pathsObjectDefinition: JSONSchema7;
-export declare type PathsObjectType = {
+export type PathsObjectType = {
     type: "spawn";
     command: string;
     args?: string[];
 };
-export declare type PackageConfigType = {
+export type PackageConfigType = {
     name: string;
     enabled?: boolean;
     task?: TaskConfigType;

package/Config/PackageRepositoryConfig.d.ts

@@ -3,7 +3,7 @@ import { GitPackageRepositoryConfigType, gitRepositoryName } from "../Repository
 import { ResticPackageRepositoryConfigType, resticRepositoryName } from "../Repository/ResticRepository";
 import type { JSONSchema7 } from "json-schema";
 export declare const packageRepositoryConfigDefinition: JSONSchema7;
-export declare type PackageRepositoryConfigType = {
+export type PackageRepositoryConfigType = {
     names?: string[];
 } & ({
     type: typeof resticRepositoryName;

package/Config/PrunePolicyConfig.d.ts

@@ -1,4 +1,4 @@
 import { PruneActionsOptionsType } from "../Action/PruneAction";
 import { JSONSchema7 } from "json-schema";
 export declare const prunePolicyConfigDefinition: JSONSchema7;
-export declare type PrunePolicyConfigType = Pick<PruneActionsOptionsType, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;
+export type PrunePolicyConfigType = Pick<PruneActionsOptionsType, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;

package/Config/RepositoryConfig.d.ts

@@ -3,9 +3,9 @@ import { GitRepositoryConfigType, gitRepositoryName } from "../Repository/GitRep
 import { ResticRepositoryConfigType, resticRepositoryName } from "../Repository/ResticRepository";
 import type { JSONSchema7 } from "json-schema";
 export declare const repositoryConfigDefinition: JSONSchema7;
-export declare type RepositoryConfigTypeType = RepositoryConfigType["type"];
-export declare type RepositoryConfigEnabledActionType = "backup" | "init" | "prune" | "restore" | "snapshots";
-export declare type RepositoryConfigType = {
+export type RepositoryConfigTypeType = RepositoryConfigType["type"];
+export type RepositoryConfigEnabledActionType = "backup" | "init" | "prune" | "restore" | "snapshots";
+export type RepositoryConfigType = {
     name: string;
     mirrorRepoNames?: string[];
     enabled?: boolean | {

package/Config/TaskConfig.d.ts

@@ -6,7 +6,7 @@ import { PostgresqlDumpTaskConfigType, postgresqlDumpTaskName } from "../Task/Po
 import { ScriptTaskConfigType, scriptTaskName } from "../Task/ScriptTask";
 import { JSONSchema7 } from "json-schema";
 export declare const taskConfigDefinition: JSONSchema7;
-export declare type TaskConfigType = {
+export type TaskConfigType = {
     name: typeof gitTaskName;
     config?: GitTaskConfigType;
 } | {

package/Decorator/EntityDecorator.d.ts

@@ -1,4 +1,4 @@
-export declare type EntityDecoratorDataType = {
+export type EntityDecoratorDataType = {
     tableName: string;
 };
 export declare function EntityDecorator(data: EntityDecoratorDataType): (constructor: Function) => void;

package/Factory/CommandFactory.d.ts

@@ -20,7 +20,7 @@ export declare enum CommandEnum {
     restoreSessions = "restore-sessions",
     cleanCache = "clean-cache"
 }
-export declare type OptionsMapType = {
+export type OptionsMapType = {
     [CommandEnum.config]: ConfigCommandOptionsType;
     [CommandEnum.init]: InitCommandOptionsType;
     [CommandEnum.snapshots]: SnapshotsCommandOptionsType;
@@ -31,7 +31,7 @@ export declare type OptionsMapType = {
     [CommandEnum.restoreSessions]: RestoreSessionsCommandOptionsType;
     [CommandEnum.cleanCache]: CleanCacheActionOptionsType;
 };
-export declare type LogMapType = {
+export type LogMapType = {
     [CommandEnum.config]: ConfigCommandLogType;
     [CommandEnum.init]: InitCommandLogType;
     [CommandEnum.snapshots]: SnapshotsCommandLogType;