@datatruck/cli 0.0.1

package/lib/Factory/CommandFactory.d.ts

@@ -0,0 +1,42 @@
+import { CleanCacheActionOptionsType } from "../Action/CleanCacheAction";
+import { BackupCommandOptionsType } from "../Command/BackupCommand";
+import { BackupSessionsCommandOptionsType } from "../Command/BackupSessionsCommand";
+import { CleanCacheCommand } from "../Command/CleanCacheCommand";
+import { GlobalOptionsType } from "../Command/CommandAbstract";
+import { ConfigCommandLogType, ConfigCommandOptionsType } from "../Command/ConfigCommand";
+import { InitCommandLogType, InitCommandOptionsType } from "../Command/InitCommand";
+import { PruneCommandOptionsType } from "../Command/PruneCommand";
+import { RestoreCommandOptionsType } from "../Command/RestoreCommand";
+import { RestoreSessionsCommandOptionsType } from "../Command/RestoreSessionsCommand";
+import { SnapshotsCommandLogType, SnapshotsCommandOptionsType } from "../Command/SnapshotsCommand";
+export declare enum CommandEnum {
+    config = "config",
+    init = "init",
+    snapshots = "snapshots",
+    prune = "prune",
+    backup = "backup",
+    backupSessions = "backup-sessions",
+    restore = "restore",
+    restoreSessions = "restore-sessions",
+    cleanCache = "clean-cache"
+}
+export declare type OptionsMapType = {
+    [CommandEnum.config]: ConfigCommandOptionsType;
+    [CommandEnum.init]: InitCommandOptionsType;
+    [CommandEnum.snapshots]: SnapshotsCommandOptionsType;
+    [CommandEnum.prune]: PruneCommandOptionsType;
+    [CommandEnum.backup]: BackupCommandOptionsType;
+    [CommandEnum.backupSessions]: BackupSessionsCommandOptionsType;
+    [CommandEnum.restore]: RestoreCommandOptionsType;
+    [CommandEnum.restoreSessions]: RestoreSessionsCommandOptionsType;
+    [CommandEnum.cleanCache]: CleanCacheActionOptionsType;
+};
+export declare type LogMapType = {
+    [CommandEnum.config]: ConfigCommandLogType;
+    [CommandEnum.init]: InitCommandLogType;
+    [CommandEnum.snapshots]: SnapshotsCommandLogType;
+};
+export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): CleanCacheCommand;
+export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): Promise<number>;
+export declare function makeParseLog<TCommand extends keyof LogMapType>(type: TCommand): () => LogMapType[TCommand];
+export declare function CommandConstructorFactory(type: CommandEnum): typeof CleanCacheCommand;

package/lib/Factory/CommandFactory.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandConstructorFactory = exports.makeParseLog = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
+const BackupCommand_1 = require("../Command/BackupCommand");
+const BackupSessionsCommand_1 = require("../Command/BackupSessionsCommand");
+const CleanCacheCommand_1 = require("../Command/CleanCacheCommand");
+const ConfigCommand_1 = require("../Command/ConfigCommand");
+const InitCommand_1 = require("../Command/InitCommand");
+const PruneCommand_1 = require("../Command/PruneCommand");
+const RestoreCommand_1 = require("../Command/RestoreCommand");
+const RestoreSessionsCommand_1 = require("../Command/RestoreSessionsCommand");
+const SnapshotsCommand_1 = require("../Command/SnapshotsCommand");
+const AppError_1 = require("../Error/AppError");
+var CommandEnum;
+(function (CommandEnum) {
+    CommandEnum["config"] = "config";
+    CommandEnum["init"] = "init";
+    CommandEnum["snapshots"] = "snapshots";
+    CommandEnum["prune"] = "prune";
+    CommandEnum["backup"] = "backup";
+    CommandEnum["backupSessions"] = "backup-sessions";
+    CommandEnum["restore"] = "restore";
+    CommandEnum["restoreSessions"] = "restore-sessions";
+    CommandEnum["cleanCache"] = "clean-cache";
+})(CommandEnum = exports.CommandEnum || (exports.CommandEnum = {}));
+function CommandFactory(type, globalOptions, options) {
+    const constructor = CommandConstructorFactory(type);
+    return new constructor(globalOptions, options);
+}
+exports.CommandFactory = CommandFactory;
+async function exec(type, globalOptions, options) {
+    return await CommandFactory(type, globalOptions, options).onExec();
+}
+exports.exec = exec;
+function makeParseLog(type) {
+    const data = [];
+    const consoleLog = console.log;
+    console.log = (...items) => {
+        data.push(...items);
+    };
+    return function parseLog() {
+        console.log = consoleLog;
+        return JSON.parse(data.flat().join("\n"));
+    };
+}
+exports.makeParseLog = makeParseLog;
+function CommandConstructorFactory(type) {
+    if (type === CommandEnum.config) {
+        return ConfigCommand_1.ConfigCommand;
+    }
+    else if (type === CommandEnum.init) {
+        return InitCommand_1.InitCommand;
+    }
+    else if (type === CommandEnum.snapshots) {
+        return SnapshotsCommand_1.SnapshotsCommand;
+    }
+    else if (type === CommandEnum.prune) {
+        return PruneCommand_1.PruneCommand;
+    }
+    else if (type === CommandEnum.backup) {
+        return BackupCommand_1.BackupCommand;
+    }
+    else if (type === CommandEnum.backupSessions) {
+        return BackupSessionsCommand_1.BackupSessionsCommand;
+    }
+    else if (type === CommandEnum.restore) {
+        return RestoreCommand_1.RestoreCommand;
+    }
+    else if (type === CommandEnum.restoreSessions) {
+        return RestoreSessionsCommand_1.RestoreSessionsCommand;
+    }
+    else if (type === CommandEnum.cleanCache) {
+        return CleanCacheCommand_1.CleanCacheCommand;
+    }
+    else {
+        throw new AppError_1.AppError(`Invalid command type: ${type}`);
+    }
+}
+exports.CommandConstructorFactory = CommandConstructorFactory;

package/lib/Factory/EntityFactory.d.ts

@@ -0,0 +1,6 @@
+import { BackupSessionRepositoryEntity } from "../Entity/BackupSessionRepositoryEntity";
+import { BackupSessionTaskEntity } from "../Entity/BackupSessionTaskEntity";
+import { RestoreSessionEntity } from "../Entity/RestoreSessionEntity";
+import { EntityEnum } from "../SessionDriver/SessionDriverAbstract";
+export declare function Entity(type: EntityEnum): BackupSessionRepositoryEntity | BackupSessionTaskEntity | RestoreSessionEntity;
+export declare function EntityConstructorFactory(type: EntityEnum): typeof BackupSessionRepositoryEntity | typeof BackupSessionTaskEntity | typeof RestoreSessionEntity;

package/lib/Factory/EntityFactory.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityConstructorFactory = exports.Entity = void 0;
+const BackupSessionEntity_1 = require("../Entity/BackupSessionEntity");
+const BackupSessionRepositoryEntity_1 = require("../Entity/BackupSessionRepositoryEntity");
+const BackupSessionTaskEntity_1 = require("../Entity/BackupSessionTaskEntity");
+const RestoreSessionEntity_1 = require("../Entity/RestoreSessionEntity");
+const RestoreSessionRepositoryEntity_1 = require("../Entity/RestoreSessionRepositoryEntity");
+const RestoreSessionTaskEntity_1 = require("../Entity/RestoreSessionTaskEntity");
+const AppError_1 = require("../Error/AppError");
+const SessionDriverAbstract_1 = require("../SessionDriver/SessionDriverAbstract");
+function Entity(type) {
+    const constructor = EntityConstructorFactory(type);
+    return new constructor();
+}
+exports.Entity = Entity;
+function EntityConstructorFactory(type) {
+    if (type === SessionDriverAbstract_1.EntityEnum.BackupSession) {
+        return BackupSessionEntity_1.BackupSessionEntity;
+    }
+    else if (type === SessionDriverAbstract_1.EntityEnum.BackupSessionRepository) {
+        return BackupSessionRepositoryEntity_1.BackupSessionRepositoryEntity;
+    }
+    else if (type === SessionDriverAbstract_1.EntityEnum.BackupSessionTask) {
+        return BackupSessionTaskEntity_1.BackupSessionTaskEntity;
+    }
+    else if (type === SessionDriverAbstract_1.EntityEnum.RestoreSession) {
+        return RestoreSessionEntity_1.RestoreSessionEntity;
+    }
+    else if (type === SessionDriverAbstract_1.EntityEnum.RestoreSessionRepository) {
+        return RestoreSessionRepositoryEntity_1.RestoreSessionRepositoryEntity;
+    }
+    else if (type === SessionDriverAbstract_1.EntityEnum.RestoreSessionTask) {
+        return RestoreSessionTaskEntity_1.RestoreSessionTaskEntity;
+    }
+    else {
+        throw new AppError_1.AppError(`Invalid entity type: ${type}`);
+    }
+}
+exports.EntityConstructorFactory = EntityConstructorFactory;

package/lib/Factory/RepositoryFactory.d.ts

@@ -0,0 +1,3 @@
+import type { RepositoryConfigType } from "../Config/RepositoryConfig";
+import type { RepositoryAbstract } from "../Repository/RepositoryAbstract";
+export declare function RepositoryFactory(repository: RepositoryConfigType): RepositoryAbstract<any>;

package/lib/Factory/RepositoryFactory.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RepositoryFactory = void 0;
+const AppError_1 = require("../Error/AppError");
+const GitRepository_1 = require("../Repository/GitRepository");
+const LocalRepository_1 = require("../Repository/LocalRepository");
+const ResticRepository_1 = require("../Repository/ResticRepository");
+function RepositoryFactory(repository) {
+    const type = repository.type;
+    if (type === GitRepository_1.gitRepositoryName) {
+        return new GitRepository_1.GitRepository(repository);
+    }
+    else if (type === ResticRepository_1.resticRepositoryName) {
+        return new ResticRepository_1.ResticRepository(repository);
+    }
+    else if (type === LocalRepository_1.localRepositoryName) {
+        return new LocalRepository_1.LocalRepository(repository);
+    }
+    else {
+        throw new AppError_1.AppError(`Invalid repository type: ${type}`);
+    }
+}
+exports.RepositoryFactory = RepositoryFactory;

package/lib/Factory/TaskFactory.d.ts

@@ -0,0 +1,3 @@
+import { TaskConfigType } from "../Config/TaskConfig";
+import type { TaskAbstract } from "../Task/TaskAbstract";
+export declare function TaskFactory(task: TaskConfigType): TaskAbstract;

package/lib/Factory/TaskFactory.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskFactory = void 0;
+const AppError_1 = require("../Error/AppError");
+const GitTask_1 = require("../Task/GitTask");
+const MariadbTask_1 = require("../Task/MariadbTask");
+const MssqlTask_1 = require("../Task/MssqlTask");
+const MysqlDumpTask_1 = require("../Task/MysqlDumpTask");
+const PostgresqlDumpTask_1 = require("../Task/PostgresqlDumpTask");
+function TaskFactory(task) {
+    if (task.name === GitTask_1.gitTaskName) {
+        return new GitTask_1.GitTask(task.config ?? {});
+    }
+    else if (task.name === MariadbTask_1.mariadbTaskName) {
+        return new MariadbTask_1.MariadbTask(task.config ?? {});
+    }
+    else if (task.name === MysqlDumpTask_1.mysqlDumpTaskName) {
+        return new MysqlDumpTask_1.MysqlDumpTask(task.config ?? {});
+    }
+    else if (task.name === PostgresqlDumpTask_1.postgresqlDumpTaskName) {
+        return new PostgresqlDumpTask_1.PostgresqlDumpTask(task.config ?? {});
+    }
+    else if (task.name === MssqlTask_1.mssqlTaskName) {
+        return new MssqlTask_1.MssqlTask(task.config ?? {});
+    }
+    else {
+        throw new AppError_1.AppError(`Invalid task name: ${task["name"]}`);
+    }
+}
+exports.TaskFactory = TaskFactory;

package/lib/JsonSchema/DefinitionEnum.d.ts

@@ -0,0 +1,25 @@
+export declare enum DefinitionEnum {
+    config = "config",
+    repository = "repository",
+    package = "package",
+    packageRepository = "package-repository",
+    task = "task",
+    resticRepository = "restic-repository",
+    resticPackageRepository = "restic-package-repository",
+    localRepository = "local-repository",
+    localPackageRepository = "local-package-repository",
+    gitRepository = "git-repository",
+    gitPackageRepository = "git-package-repository",
+    gitTask = "git-task",
+    mariadbTask = "mariadb-task",
+    mssqlTask = "mssql-task",
+    mysqlDumpTask = "mysql-dump-task",
+    postgresqlDumpTask = "postgresql-dump-task",
+    sqlDumpTask = "sqldump-task",
+    stringListUtil = "stringlist-util",
+    prunePolicy = "prune-policy",
+    pathsObject = "paths-object"
+}
+export declare function makeRef(type: DefinitionEnum): {
+    $ref: string;
+};

package/lib/JsonSchema/DefinitionEnum.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.makeRef = exports.DefinitionEnum = void 0;
+var DefinitionEnum;
+(function (DefinitionEnum) {
+    DefinitionEnum["config"] = "config";
+    DefinitionEnum["repository"] = "repository";
+    DefinitionEnum["package"] = "package";
+    DefinitionEnum["packageRepository"] = "package-repository";
+    DefinitionEnum["task"] = "task";
+    DefinitionEnum["resticRepository"] = "restic-repository";
+    DefinitionEnum["resticPackageRepository"] = "restic-package-repository";
+    DefinitionEnum["localRepository"] = "local-repository";
+    DefinitionEnum["localPackageRepository"] = "local-package-repository";
+    DefinitionEnum["gitRepository"] = "git-repository";
+    DefinitionEnum["gitPackageRepository"] = "git-package-repository";
+    DefinitionEnum["gitTask"] = "git-task";
+    DefinitionEnum["mariadbTask"] = "mariadb-task";
+    DefinitionEnum["mssqlTask"] = "mssql-task";
+    DefinitionEnum["mysqlDumpTask"] = "mysql-dump-task";
+    DefinitionEnum["postgresqlDumpTask"] = "postgresql-dump-task";
+    DefinitionEnum["sqlDumpTask"] = "sqldump-task";
+    DefinitionEnum["stringListUtil"] = "stringlist-util";
+    DefinitionEnum["prunePolicy"] = "prune-policy";
+    DefinitionEnum["pathsObject"] = "paths-object";
+})(DefinitionEnum = exports.DefinitionEnum || (exports.DefinitionEnum = {}));
+function makeRef(type) {
+    return {
+        $ref: `#/definitions/${type}`,
+    };
+}
+exports.makeRef = makeRef;

package/lib/JsonSchema/JsonSchema.d.ts

@@ -0,0 +1,4 @@
+import { DefinitionEnum } from "./DefinitionEnum";
+import { JSONSchema7 } from "json-schema";
+export declare const definitions: Record<DefinitionEnum, JSONSchema7>;
+export declare const schema: JSONSchema7;

package/lib/JsonSchema/JsonSchema.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schema = exports.definitions = void 0;
+const Config_1 = require("../Config/Config");
+const PackageConfig_1 = require("../Config/PackageConfig");
+const PackageRepositoryConfig_1 = require("../Config/PackageRepositoryConfig");
+const PrunePolicyConfig_1 = require("../Config/PrunePolicyConfig");
+const RepositoryConfig_1 = require("../Config/RepositoryConfig");
+const TaskConfig_1 = require("../Config/TaskConfig");
+const GitRepository_1 = require("../Repository/GitRepository");
+const LocalRepository_1 = require("../Repository/LocalRepository");
+const ResticRepository_1 = require("../Repository/ResticRepository");
+const GitTask_1 = require("../Task/GitTask");
+const MariadbTask_1 = require("../Task/MariadbTask");
+const MssqlTask_1 = require("../Task/MssqlTask");
+const MysqlDumpTask_1 = require("../Task/MysqlDumpTask");
+const PostgresqlDumpTask_1 = require("../Task/PostgresqlDumpTask");
+const SqlDumpTaskAbstract_1 = require("../Task/SqlDumpTaskAbstract");
+const DefinitionEnum_1 = require("./DefinitionEnum");
+exports.definitions = {
+    [DefinitionEnum_1.DefinitionEnum.stringListUtil]: {
+        type: "array",
+        items: {
+            type: "string",
+        },
+    },
+    [DefinitionEnum_1.DefinitionEnum.repository]: RepositoryConfig_1.repositoryConfigDefinition,
+    [DefinitionEnum_1.DefinitionEnum.package]: PackageConfig_1.packageConfigDefinition,
+    [DefinitionEnum_1.DefinitionEnum.packageRepository]: PackageRepositoryConfig_1.packageRepositoryConfigDefinition,
+    [DefinitionEnum_1.DefinitionEnum.task]: TaskConfig_1.taskConfigDefinition,
+    [DefinitionEnum_1.DefinitionEnum.gitRepository]: GitRepository_1.gitRepositoryDefinition,
+    [DefinitionEnum_1.DefinitionEnum.gitPackageRepository]: GitRepository_1.gitPackageRepositoryDefinition,
+    [DefinitionEnum_1.DefinitionEnum.localRepository]: LocalRepository_1.localRepositoryDefinition,
+    [DefinitionEnum_1.DefinitionEnum.localPackageRepository]: LocalRepository_1.localPackageRepositoryDefinition,
+    [DefinitionEnum_1.DefinitionEnum.resticRepository]: ResticRepository_1.resticRepositoryDefinition,
+    [DefinitionEnum_1.DefinitionEnum.resticPackageRepository]: ResticRepository_1.resticPackageRepositoryDefinition,
+    [DefinitionEnum_1.DefinitionEnum.gitTask]: GitTask_1.gitTaskDefinition,
+    [DefinitionEnum_1.DefinitionEnum.sqlDumpTask]: SqlDumpTaskAbstract_1.sqlDumpTaskDefinition,
+    [DefinitionEnum_1.DefinitionEnum.mariadbTask]: MariadbTask_1.mariadbTaskDefinition,
+    [DefinitionEnum_1.DefinitionEnum.mssqlTask]: MssqlTask_1.mssqlTaskDefinition,
+    [DefinitionEnum_1.DefinitionEnum.mysqlDumpTask]: MysqlDumpTask_1.mysqlDumpTaskDefinition,
+    [DefinitionEnum_1.DefinitionEnum.postgresqlDumpTask]: PostgresqlDumpTask_1.postgresqlDumpTaskDefinition,
+    [DefinitionEnum_1.DefinitionEnum.config]: Config_1.configDefinition,
+    [DefinitionEnum_1.DefinitionEnum.prunePolicy]: PrunePolicyConfig_1.prunePolicyConfigDefinition,
+    [DefinitionEnum_1.DefinitionEnum.pathsObject]: PackageConfig_1.pathsObjectDefinition,
+};
+exports.schema = {
+    definitions: exports.definitions,
+    ...(0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.config),
+};

package/lib/Repository/GitRepository.d.ts

@@ -0,0 +1,29 @@
+import { RepositoryAbstract, BackupDataType, InitDataType, RestoreDataType, SnapshotsDataType, SnapshotResultType, SnapshotTagEnum, SnapshotTagObjectType, PruneDataType } from "./RepositoryAbstract";
+import { JSONSchema7 } from "json-schema";
+export declare type GitRepositoryConfigType = {
+    repo: string;
+    branch?: string;
+};
+export declare type GitPackageRepositoryConfigType = {};
+export declare const gitRepositoryName = "git";
+export declare const gitRepositoryDefinition: JSONSchema7;
+export declare const gitPackageRepositoryDefinition: JSONSchema7;
+export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfigType> {
+    static refPrefix: string;
+    onGetSource(): string;
+    static buildSnapshotTagName(tag: Pick<SnapshotTagObjectType, SnapshotTagEnum.PACKAGE | SnapshotTagEnum.ID>): string;
+    static buildSnapshotTag(tag: SnapshotTagObjectType): {
+        name: string;
+        message: string;
+    };
+    static isSnapshotTag(name: string): boolean;
+    static parseSnapshotTag(name: string, message: string): (Omit<SnapshotTagObjectType, "tags"> & {
+        tags: string[];
+    }) | null;
+    static buildBranchName(packageName: string): string;
+    onInit(data: InitDataType): Promise<void>;
+    onPrune(data: PruneDataType): Promise<void>;
+    onSnapshots(data: SnapshotsDataType): Promise<SnapshotResultType[]>;
+    onBackup(data: BackupDataType<GitPackageRepositoryConfigType>): Promise<void>;
+    onRestore(data: RestoreDataType<GitPackageRepositoryConfigType>): Promise<void>;
+}

package/lib/Repository/GitRepository.js

@@ -0,0 +1,237 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitRepository = exports.gitPackageRepositoryDefinition = exports.gitRepositoryDefinition = exports.gitRepositoryName = void 0;
+const AppError_1 = require("../Error/AppError");
+const GitUtil_1 = require("../util/GitUtil");
+const cli_util_1 = require("../util/cli-util");
+const paths_util_1 = require("../util/datatruck/paths-util");
+const fs_util_1 = require("../util/fs-util");
+const string_util_1 = require("../util/string-util");
+const RepositoryAbstract_1 = require("./RepositoryAbstract");
+const assert_1 = require("assert");
+const fast_glob_1 = __importDefault(require("fast-glob"));
+const fs_extra_1 = require("fs-extra");
+const promises_1 = require("fs/promises");
+const micromatch_1 = require("micromatch");
+const path_1 = require("path");
+exports.gitRepositoryName = "git";
+exports.gitRepositoryDefinition = {
+    type: "object",
+    additionalProperties: false,
+    required: ["repo"],
+    properties: {
+        repo: { type: "string" },
+        branch: { type: "string" },
+    },
+};
+exports.gitPackageRepositoryDefinition = {
+    type: "object",
+    additionalProperties: false,
+    properties: {},
+};
+class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
+    onGetSource() {
+        return this.config.repo;
+    }
+    static buildSnapshotTagName(tag) {
+        return `${GitRepository.refPrefix}/${tag.package}/${tag.id}`;
+    }
+    static buildSnapshotTag(tag) {
+        return {
+            name: GitRepository.buildSnapshotTagName(tag),
+            message: JSON.stringify(tag),
+        };
+    }
+    static isSnapshotTag(name) {
+        return name.startsWith(`${GitRepository.refPrefix}/`);
+    }
+    static parseSnapshotTag(name, message) {
+        if (GitRepository.isSnapshotTag(name))
+            return JSON.parse(message);
+        return null;
+    }
+    static buildBranchName(packageName) {
+        return `${GitRepository.refPrefix}/${packageName}`;
+    }
+    async onInit(data) {
+        const git = new GitUtil_1.GitUtil({
+            dir: (0, fs_util_1.tmpDir)(GitRepository.name + "-snapshot"),
+            log: data.options.verbose,
+        });
+        if (await git.canBeInit(this.config.repo)) {
+            await (0, fs_extra_1.mkdir)(git.options.dir);
+            await git.exec(["init", "--bare", this.config.repo]);
+        }
+        const branchName = this.config.branch ?? "master";
+        const existsBranch = await git.checkBranch({
+            name: branchName,
+            repo: this.config.repo,
+        });
+        if (!existsBranch) {
+            await (0, fs_util_1.mkdirIfNotExists)(git.options.dir);
+            await git.clone({
+                repo: this.config.repo,
+            });
+            await git.checkout({
+                branchName,
+                orphan: true,
+            });
+            await git.exec(["commit", "-m", "Initial commit", "--allow-empty"]);
+            await git.push({ branchName });
+        }
+    }
+    async onPrune(data) {
+        const git = new GitUtil_1.GitUtil({
+            dir: await (0, fs_util_1.mkTmpDir)(GitRepository.name + "-snapshot"),
+            log: data.options.verbose,
+        });
+        const branchName = GitRepository.buildBranchName(data.snapshot.packageName);
+        const commitId = await git.fetchCommitId(data.snapshot.originalId);
+        await git.clone({ repo: this.config.repo });
+        await git.checkout({
+            branchName,
+            orphan: (await git.checkBranch({ name: branchName })) ? false : true,
+        });
+        await git.exec([
+            "rebase",
+            "-X theirs",
+            "--rebase-merges",
+            "--onto",
+            `${commitId}^`,
+            commitId,
+        ]);
+        await git.exec(["push", "origin", branchName, "--force-with-lease"]);
+        await git.exec(["push", "--delete", "origin", data.snapshot.originalId]);
+    }
+    async onSnapshots(data) {
+        const git = new GitUtil_1.GitUtil({
+            dir: await (0, fs_util_1.mkTmpDir)(GitRepository.name + "-snapshot"),
+            log: data.options.verbose,
+        });
+        const pkgPatterns = (0, string_util_1.makePathPatterns)(data.options.packageNames);
+        await git.clone({ repo: this.config.repo });
+        const tagNames = data.options.ids?.map((id) => `${GitRepository.refPrefix}/*/${id}*`) || [`${GitRepository.refPrefix}/*`];
+        const tags = await git.getTags(tagNames);
+        return tags
+            .reduce((result, tag) => {
+            const parsedTag = tag.message
+                ? GitRepository.parseSnapshotTag(tag.name, tag.message)
+                : null;
+            if (!parsedTag)
+                return result;
+            if (pkgPatterns && !(0, micromatch_1.isMatch)(parsedTag.package, pkgPatterns))
+                return result;
+            if (data.options.tags &&
+                !parsedTag.tags.some((value) => data.options.tags?.includes(value)))
+                return result;
+            result.push({
+                originalId: tag.name,
+                id: parsedTag.id,
+                date: parsedTag.date,
+                packageName: parsedTag.package,
+                tags: parsedTag.tags,
+            });
+            return result;
+        }, [])
+            .sort((a, b) => a.date.localeCompare(b.date));
+    }
+    async onBackup(data) {
+        const pkg = data.package;
+        const sourcePath = data.targetPath ?? pkg.path;
+        (0, assert_1.ok)(typeof sourcePath === "string");
+        if (!(await (0, fs_util_1.existsDir)(sourcePath)))
+            throw new AppError_1.AppError(`Package path not exists: ${sourcePath}`);
+        const tmpPath = await (0, fs_util_1.mkTmpDir)(GitRepository.name + "-backup");
+        const branchName = GitRepository.buildBranchName(data.package.name);
+        const git = new GitUtil_1.GitUtil({
+            dir: tmpPath,
+            log: data.options.verbose,
+        });
+        if (data.options.verbose)
+            (0, cli_util_1.logExec)("cd", [tmpPath]);
+        await git.clone({
+            repo: this.config.repo,
+        });
+        await git.checkout({
+            branchName,
+            orphan: (await git.checkBranch({ name: branchName })) ? false : true,
+        });
+        await git.removeAll();
+        const createdPaths = [];
+        const include = await (0, paths_util_1.parsePaths)(pkg.include ?? ["**"], {
+            cwd: sourcePath,
+            verbose: data.options.verbose,
+        });
+        const exclude = pkg.exclude
+            ? await (0, paths_util_1.parsePaths)(pkg.exclude, {
+                cwd: sourcePath,
+                verbose: data.options.verbose,
+            })
+            : undefined;
+        const stream = await (0, fast_glob_1.default)(include, {
+            cwd: sourcePath,
+            ignore: exclude,
+            dot: true,
+        });
+        let files = 0;
+        for await (const entry of stream) {
+            const source = (0, path_1.join)(sourcePath, entry);
+            const target = (0, path_1.join)(tmpPath, entry);
+            const dir = (0, path_1.dirname)(target);
+            if (!createdPaths.includes(dir)) {
+                await (0, fs_extra_1.mkdir)(dir, {
+                    recursive: true,
+                });
+                createdPaths.push(dir);
+            }
+            files++;
+            await (0, promises_1.copyFile)(source, target);
+        }
+        if (data.options.verbose)
+            console.info(`Copied ${files} files`);
+        await git.exec(["add", "--verbose", "."]);
+        if (await git.haveChanges())
+            await git.exec(["commit", "-m", data.snapshot.id]);
+        const nodePkg = (0, fs_util_1.parsePackageFile)();
+        const meta = GitRepository.buildSnapshotTag({
+            id: data.snapshot.id,
+            shortId: data.snapshot.id.slice(0, 8),
+            tags: data.options.tags ?? [],
+            date: data.snapshot.date,
+            package: data.package.name,
+            version: nodePkg.version,
+        });
+        await git.addTag(meta.name, meta.message);
+        await git.push({ branchName });
+        await git.pushTags();
+        await (0, promises_1.rm)(tmpPath, {
+            recursive: true,
+        });
+    }
+    async onRestore(data) {
+        const restorePath = data.targetPath ?? data.package.restorePath;
+        (0, assert_1.ok)(restorePath);
+        const tagName = GitRepository.buildSnapshotTagName({
+            id: data.snapshot.id,
+            package: data.package.name,
+        });
+        const git = new GitUtil_1.GitUtil({
+            dir: restorePath,
+            log: data.options.verbose,
+        });
+        if (data.options.verbose)
+            (0, cli_util_1.logExec)("cd", [restorePath]);
+        await git.clone({
+            repo: this.config.repo,
+            branch: tagName,
+        });
+        await (0, promises_1.rm)(`${restorePath}/.git`, {
+            recursive: true,
+        });
+    }
+}
+exports.GitRepository = GitRepository;
+GitRepository.refPrefix = "dt";