@datatruck/cli 0.26.2 → 0.28.0

package/Repository/DatatruckRepository.js

@@ -4,10 +4,13 @@ exports.DatatruckRepository = exports.datatruckPackageRepositoryDefinition = exp
 const AppError_1 = require("../Error/AppError");
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_1 = require("../utils/cli");
+const client_1 = require("../utils/datatruck/client");
 const paths_1 = require("../utils/datatruck/paths");
 const fs_1 = require("../utils/fs");
+const math_1 = require("../utils/math");
 const string_1 = require("../utils/string");
 const tar_1 = require("../utils/tar");
+const temp_1 = require("../utils/temp");
 const RepositoryAbstract_1 = require("./RepositoryAbstract");
 const assert_1 = require("assert");
 const promises_1 = require("fs/promises");
@@ -16,10 +19,10 @@ const path_1 = require("path");
 exports.datatruckRepositoryName = "datatruck";
 exports.datatruckRepositoryDefinition = {
     type: "object",
-    required: ["outPath"],
+    required: ["backend"],
     additionalProperties: false,
     properties: {
-        outPath: { type: "string" },
+        backend: { type: "string" },
         compress: {
             anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
         },
@@ -52,10 +55,10 @@ exports.datatruckPackageRepositoryDefinition = {
 };
 class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static zipBasenameTpl = `.*.dd.tar.gz`;
-    static buildSnapshotName(data) {
-        const date = data.snapshotDate.replace(/:/g, "-");
-        const pkgName = encodeURIComponent(data.packageName).replace(/%40/g, "@");
-        const snapshotShortId = data.snapshotId.slice(0, 8);
+    static buildSnapshotName(snapshot, pkg) {
+        const date = snapshot.date.replace(/:/g, "-");
+        const pkgName = encodeURIComponent(pkg.name).replace(/%40/g, "@");
+        const snapshotShortId = snapshot.id.slice(0, 8);
         return `${date}_${pkgName}_${snapshotShortId}`;
     }
     static parseSnapshotName(name) {
@@ -69,49 +72,36 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         packageName = decodeURIComponent(packageName);
         return { snapshotDate, packageName, snapshotShortId, sourcePath: name };
     }
-    buildMetaPath(snapshotName, packageName) {
-        return (0, path_1.join)(this.config.outPath, snapshotName, packageName) + ".meta.json";
+    static async parseMetaData(data) {
+        return JSON.parse(data.toString());
     }
-    static async parseMetaData(path) {
-        let contents;
-        try {
-            contents = await (0, promises_1.readFile)(path);
-        }
-        catch (error) {
-            if ((0, fs_1.isNotFoundError)(error))
-                return;
-            throw error;
-        }
-        return JSON.parse(contents.toString());
-    }
-    static stringifyMetaData(data) {
-        return JSON.stringify(data);
+    getSource() {
+        return this.config.backend;
     }
-    onGetSource() {
-        return this.config.outPath;
+    fetchDiskStats(config) {
+        const fs = (0, client_1.createFs)(config.backend);
+        return fs.fetchDiskStats(".");
     }
-    async onInit(data) {
-        await (0, fs_1.mkdirIfNotExists)(this.config.outPath);
+    async init(data) {
+        const fs = (0, client_1.createFs)(this.config.backend);
+        await fs.mkdir(".");
     }
-    async onPrune(data) {
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.snapshot.packageName,
+    async prune(data) {
+        const fs = (0, client_1.createFs)(this.config.backend);
+        const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, {
+            name: data.snapshot.packageName,
         });
-        const snapshotPath = (0, path_1.join)(this.config.outPath, snapshotName);
         if (data.options.verbose)
-            (0, cli_1.logExec)(`Deleting ${snapshotPath}`);
-        if (await (0, fs_1.existsDir)(snapshotPath))
-            await (0, promises_1.rm)(snapshotPath, {
-                recursive: true,
-            });
+            (0, cli_1.logExec)(`Deleting ${fs.resolvePath(snapshotName)}`);
+        if (await fs.existsDir(snapshotName))
+            await fs.rmAll(snapshotName);
     }
-    async onSnapshots(data) {
-        if (!(await (0, fs_1.existsDir)(this.config.outPath)))
-            throw new Error(`Repository (${this.repository.name}) out path does not exist: ${this.config.outPath}`);
-        const snapshotNames = await (0, fs_1.readDir)(this.config.outPath);
+    async fetchSnapshots(data) {
+        const fs = (0, client_1.createFs)(this.config.backend);
+        if (!(await fs.existsDir(".")))
+            throw new Error(`Repository (${this.repository.name}) out path does not exist: ${fs.resolvePath(".")}`);
         const snapshots = [];
+        const snapshotNames = await fs.readdir(".");
         const packagePatterns = (0, string_1.makePathPatterns)(data.options.packageNames);
         const taskPatterns = (0, string_1.makePathPatterns)(data.options.packageTaskNames);
         for (const snapshotName of snapshotNames) {
@@ -124,8 +114,8 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             if (data.options.ids &&
                 !data.options.ids.some((id) => snapshotNameData.snapshotShortId.startsWith(id.slice(0, 8))))
                 continue;
-            const metaPath = (0, path_1.join)(this.config.outPath, snapshotName, "meta.json");
-            const meta = await DatatruckRepository.parseMetaData(metaPath);
+            const metaData = await fs.readFileIfExists(`${snapshotName}/meta.json`);
+            const meta = !!metaData && (await DatatruckRepository.parseMetaData(metaData));
             if (!meta)
                 continue;
             if (taskPatterns && !(0, string_1.checkMatch)(meta.task, taskPatterns))
@@ -148,27 +138,25 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         }
         return snapshots;
     }
-    async onBackup(data) {
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.package.name,
-        });
-        const outPath = (0, path_1.resolve)((0, path_1.join)(this.config.outPath, snapshotName));
+    async backup(data) {
+        const fs = (0, client_1.createFs)(this.config.backend);
+        const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
+        const outPath = fs.isLocal()
+            ? fs.resolvePath(snapshotName)
+            : await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "backup", "fs-remote");
         const pkg = data.package;
-        const sourcePath = data.targetPath ?? pkg.path;
-        (0, assert_1.ok)(sourcePath);
-        await (0, promises_1.mkdir)(outPath, { recursive: true });
+        const path = pkg.path;
+        await fs.mkdir(snapshotName);
         const backupPathsOptions = {
             package: data.package,
             snapshot: data.snapshot,
-            targetPath: sourcePath,
+            path: path,
             verbose: data.options.verbose,
         };
         const scanner = await (0, fs_1.createFileScanner)({
             onProgress: data.onProgress,
             glob: {
-                cwd: sourcePath,
+                cwd: path,
                 onlyFiles: false,
                 include: await (0, paths_1.parseBackupPaths)(pkg.include ?? ["**"], backupPathsOptions),
                 ignore: pkg.exclude
@@ -187,7 +175,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const packs = [defaultsPack, ...configPacks];
         const defaultsPackIndex = packs.findIndex((p) => p === defaultsPack);
         const stream = (0, fs_1.createWriteStreamPool)({
-            path: await this.mkTmpDir("files"),
+            path: await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "backup", "stream-pool"),
             onStreamPath: (key) => `files-${key}.txt`,
         });
         scanner.total++;
@@ -209,7 +197,7 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
                 scanner.total++;
                 stream.writeLine(packIndex, ".");
             }
-            stream.writeLine(packIndex, entry.path);
+            stream.writeLine(packIndex, (0, tar_1.normalizeTarPath)(entry.path));
             return true;
         });
         await stream.end();
@@ -224,21 +212,28 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             if (includeList) {
                 tarStats[packBasename] = {
                     files: stream.lines(packIndex),
+                    size: 0,
                 };
+                const tarPath = (0, path_1.join)(outPath, packBasename);
                 await (0, tar_1.createTar)({
                     compress: pack.compress,
                     verbose: data.options.verbose,
                     includeList,
-                    path: sourcePath,
-                    output: (0, path_1.join)(outPath, packBasename),
-                    onEntry: async (data) => await scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
+                    path: path,
+                    output: tarPath,
+                    onEntry: async (data) => scanner.progress(pack.compress ? "Compressing" : "Packing", data.path),
                 });
+                tarStats[packBasename].size = (await (0, promises_1.stat)(tarPath)).size;
+                if (!fs.isLocal()) {
+                    await fs.upload(tarPath, `${snapshotName}/${packBasename}`);
+                    await (0, promises_1.rm)(tarPath);
+                }
             }
             packIndex++;
         }
-        await scanner.end();
+        scanner.end();
         // Meta
-        const metaPath = `${outPath}/meta.json`;
+        const metaPath = `${snapshotName}/meta.json`;
         const nodePkg = (0, fs_1.parsePackageFile)();
         const meta = {
             id: data.snapshot.id,
@@ -247,112 +242,99 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
             package: data.package.name,
             task: data.package.task?.name,
             version: nodePkg.version,
-            size: await (0, fs_1.fastFolderSizeAsync)(outPath),
+            size: Object.values(tarStats).reduce((total, { size }) => total + size, 0),
             tarStats,
         };
         if (data.options.verbose)
-            (0, cli_1.logExec)(`Writing metadata into ${metaPath}`);
-        await (0, promises_1.writeFile)(metaPath, DatatruckRepository.stringifyMetaData(meta));
+            (0, cli_1.logExec)(`Writing metadata into ${fs.resolvePath(metaPath)}`);
+        await fs.writeFile(`${snapshotName}/meta.json`, JSON.stringify(meta));
     }
-    async onCopyBackup(data) {
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.package.name,
-        });
-        const sourcePath = (0, path_1.resolve)((0, path_1.join)(this.config.outPath, snapshotName));
-        const targetPath = (0, path_1.resolve)((0, path_1.join)(data.mirrorRepositoryConfig.outPath, snapshotName));
+    async copy(data) {
+        const sourceFs = (0, client_1.createFs)(this.config.backend);
+        const targetFs = (0, client_1.createFs)(data.mirrorRepositoryConfig.backend);
+        const snapshotName = DatatruckRepository.buildSnapshotName(data.snapshot, data.package);
         if (data.options.verbose)
-            (0, cli_1.logExec)(`Copying backup files to ${targetPath}`);
-        await (0, promises_1.mkdir)(targetPath, { recursive: true });
-        await (0, fs_1.ensureEmptyDir)(targetPath);
-        const scanner = await (0, fs_1.createFileScanner)({
-            onProgress: data.onProgress,
-            glob: {
-                include: ["**/*"],
-                cwd: sourcePath,
-            },
-        });
-        const entryPaths = [];
-        await scanner.start(async (entry) => {
-            entryPaths.push(entry.path);
-            return true;
-        });
-        for (const entryPath of entryPaths) {
-            const sourceFile = (0, path_1.join)(sourcePath, entryPath);
-            const targetFile = (0, path_1.join)(targetPath, entryPath);
-            await scanner.progress("Copying", entryPath);
-            await (0, promises_1.mkdir)((0, path_1.dirname)(targetFile), { recursive: true });
-            await (0, promises_1.cp)(sourceFile, targetFile);
+            (0, cli_1.logExec)(`Copying backup files to ${data.mirrorRepositoryConfig.backend}`);
+        await targetFs.mkdir(snapshotName);
+        await targetFs.ensureEmptyDir(snapshotName);
+        const entries = await sourceFs.readdir(snapshotName);
+        const total = entries.length;
+        let current = 0;
+        for (const entry of entries) {
+            data.onProgress({
+                absolute: {
+                    current,
+                    description: "Copying",
+                    payload: entry,
+                    total,
+                    percent: (0, math_1.progressPercent)(total, current),
+                },
+            });
+            current++;
+            const sourceEntry = `${snapshotName}/${entry}`;
+            if (targetFs.isLocal()) {
+                await sourceFs.download(sourceEntry, targetFs.resolvePath(sourceEntry));
+            }
+            else {
+                const tempDir = await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "remote-copy", entry);
+                const tempFile = (0, path_1.join)(tempDir, entry);
+                try {
+                    await sourceFs.download(sourceEntry, tempFile);
+                    await targetFs.upload(tempFile, sourceEntry);
+                }
+                finally {
+                    await (0, fs_1.tryRm)(tempFile);
+                }
+            }
         }
-        await scanner.end();
     }
-    async onRestore(data) {
-        const relRestorePath = data.targetPath ?? data.package.restorePath;
+    async restore(data) {
+        const fs = (0, client_1.createFs)(this.config.backend);
+        const relRestorePath = data.snapshotPath;
         (0, assert_1.ok)(relRestorePath);
         const restorePath = (0, path_1.resolve)(relRestorePath);
-        const [snapshot] = await this.onSnapshots({
+        const [snapshot] = await this.fetchSnapshots({
             options: {
                 ids: [data.options.snapshotId],
             },
         });
         if (!snapshot)
             throw new AppError_1.AppError("Snapshot not found");
-        const snapshotName = DatatruckRepository.buildSnapshotName({
-            snapshotId: data.snapshot.id,
-            snapshotDate: data.snapshot.date,
-            packageName: data.package.name,
-        });
-        const sourcePath = (0, path_1.join)(this.config.outPath, snapshotName);
-        const metaPath = (0, path_1.join)(sourcePath, "meta.json");
-        const meta = await DatatruckRepository.parseMetaData(metaPath);
-        const scanner = await (0, fs_1.createFileScanner)({
-            onProgress: data.onProgress,
-            glob: {
-                cwd: sourcePath,
-                include: ["**/*"],
-            },
-        });
-        const tarFiles = [];
+        const snapshotName = DatatruckRepository.buildSnapshotName(snapshot, data.package);
+        const meta = await DatatruckRepository.parseMetaData(await fs.readFile(`${snapshotName}/meta.json`));
+        const progress = (0, fs_1.createProgress)({ onProgress: data.onProgress });
+        progress.update("Scanning files");
+        const entries = (await fs.readdir(snapshotName)).filter((v) => v.endsWith(".tar") || v.endsWith(".tar.gz"));
         const tarStats = meta?.tarStats || {};
-        await scanner.start(async (entry) => {
-            const path = (0, path_1.join)(sourcePath, entry.name);
-            const isTar = entry.name.endsWith(".tar");
-            const isTarGz = entry.name.endsWith(".tar.gz");
-            if (isTar || isTarGz) {
-                tarFiles.push(path);
-                if (typeof tarStats[entry.name]?.files === "number") {
-                    scanner.total += tarStats[entry.name].files;
-                }
-                else {
-                    scanner.progress("Scanning", entry.name, false);
-                    const selfTarStats = (tarStats[entry.name] = { files: 0 });
-                    await (0, tar_1.listTar)({
-                        input: path,
-                        verbose: data.options.verbose,
-                        onEntry: () => {
-                            scanner.total++;
-                            selfTarStats.files++;
-                        },
-                    });
-                }
-            }
-            return false;
-        });
+        for (const file in tarStats)
+            progress.total += tarStats[file].files;
+        progress.update(`Scanned files: ${progress.total}`);
         if (data.options.verbose)
             (0, cli_1.logExec)(`Unpacking files to ${restorePath}`);
-        for (const tarFile of tarFiles) {
-            const entryName = (0, path_1.basename)(tarFile);
-            await (0, tar_1.extractTar)({
-                total: tarStats[entryName].files,
-                input: tarFile,
-                output: restorePath,
-                decompress: tarFile.endsWith(".tar.gz"),
-                verbose: data.options.verbose,
-                onEntry: async (data) => await scanner.progress(tarFile.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
-            });
+        for (const entry of entries) {
+            let tempEntry;
+            try {
+                const sourceEntry = `${snapshotName}/${entry}`;
+                if (!fs.isLocal()) {
+                    const tempDir = await (0, temp_1.mkTmpDir)(exports.datatruckRepositoryName, "repo", "restore", "remote-fs", entry);
+                    tempEntry = `${tempDir}/${entry}`;
+                    await fs.download(sourceEntry, tempEntry);
+                }
+                await (0, tar_1.extractTar)({
+                    total: tarStats[entry].files,
+                    input: tempEntry ?? fs.resolvePath(sourceEntry),
+                    output: restorePath,
+                    decompress: entry.endsWith(".tar.gz"),
+                    verbose: data.options.verbose,
+                    onEntry: (data) => progress.update(entry.endsWith(".tar.gz") ? "Extracting" : "Unpacking", data.path),
+                });
+            }
+            finally {
+                if (tempEntry)
+                    await (0, fs_1.tryRm)(tempEntry);
+            }
         }
-        await scanner.end();
+        progress.update("Finished");
     }
 }
 exports.DatatruckRepository = DatatruckRepository;

package/Repository/GitRepository.d.ts

@@ -1,4 +1,4 @@
-import { RepositoryAbstract, BackupDataType, InitDataType, RestoreDataType, SnapshotsDataType, SnapshotResultType, SnapshotTagEnum, SnapshotTagObjectType, PruneDataType, CopyBackupType } from "./RepositoryAbstract";
+import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, SnapshotTagEnum, SnapshotTagObjectType, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
 import { JSONSchema7 } from "json-schema";
 export type GitRepositoryConfigType = {
     repo: string;
@@ -10,7 +10,8 @@ export declare const gitRepositoryDefinition: JSONSchema7;
 export declare const gitPackageRepositoryDefinition: JSONSchema7;
 export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfigType> {
     static refPrefix: string;
-    onGetSource(): string;
+    getSource(): string;
+    fetchDiskStats(config: GitRepositoryConfigType): Promise<import("../utils/fs").DiskStats | undefined>;
     static buildSnapshotTagName(tag: Pick<SnapshotTagObjectType, SnapshotTagEnum.PACKAGE | SnapshotTagEnum.ID>): string;
     static buildSnapshotTag(tag: SnapshotTagObjectType): {
         name: string;
@@ -21,10 +22,10 @@ export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfi
         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>;
-    onCopyBackup(data: CopyBackupType<GitRepositoryConfigType>): Promise<void>;
-    onRestore(data: RestoreDataType<GitPackageRepositoryConfigType>): Promise<void>;
+    init(data: RepoInitData): Promise<void>;
+    prune(data: RepoPruneData): Promise<void>;
+    fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
+    backup(data: RepoBackupData<GitPackageRepositoryConfigType>): Promise<void>;
+    copy(data: RepoCopyData<GitRepositoryConfigType>): Promise<void>;
+    restore(data: RepoRestoreData<GitPackageRepositoryConfigType>): Promise<void>;
 }

package/Repository/GitRepository.js

@@ -4,14 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GitRepository = exports.gitPackageRepositoryDefinition = exports.gitRepositoryDefinition = exports.gitRepositoryName = void 0;
-const AppError_1 = require("../Error/AppError");
 const Git_1 = require("../utils/Git");
 const cli_1 = require("../utils/cli");
 const paths_1 = require("../utils/datatruck/paths");
 const fs_1 = require("../utils/fs");
 const string_1 = require("../utils/string");
+const temp_1 = require("../utils/temp");
 const RepositoryAbstract_1 = require("./RepositoryAbstract");
-const assert_1 = require("assert");
 const fast_glob_1 = __importDefault(require("fast-glob"));
 const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
@@ -33,9 +32,13 @@ exports.gitPackageRepositoryDefinition = {
 };
 class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static refPrefix = "dt";
-    onGetSource() {
+    getSource() {
         return this.config.repo;
     }
+    async fetchDiskStats(config) {
+        if ((0, fs_1.isLocalDir)(config.repo))
+            return await (0, fs_1.fetchDiskStats)(config.repo);
+    }
     static buildSnapshotTagName(tag) {
         return `${GitRepository.refPrefix}/${tag.package}/${tag.id}`;
     }
@@ -56,9 +59,9 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static buildBranchName(packageName) {
         return `${GitRepository.refPrefix}/${packageName}`;
     }
-    async onInit(data) {
+    async init(data) {
         const git = new Git_1.Git({
-            dir: (0, fs_1.tmpDir)(GitRepository.name + "-snapshot"),
+            dir: (0, temp_1.tmpDir)(exports.gitRepositoryName, "repository", "init"),
             log: data.options.verbose,
         });
         if (await git.canBeInit(this.config.repo)) {
@@ -83,9 +86,9 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
             await git.push({ branchName });
         }
     }
-    async onPrune(data) {
+    async prune(data) {
         const git = new Git_1.Git({
-            dir: await this.mkTmpDir(GitRepository.name + "-snapshot"),
+            dir: await (0, temp_1.mkTmpDir)(exports.gitRepositoryName, "repo", "prune"),
             log: data.options.verbose,
         });
         const branchName = GitRepository.buildBranchName(data.snapshot.packageName);
@@ -106,9 +109,9 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await git.exec(["push", "origin", branchName, "--force-with-lease"]);
         await git.exec(["push", "--delete", "origin", data.snapshot.originalId]);
     }
-    async onSnapshots(data) {
+    async fetchSnapshots(data) {
         const git = new Git_1.Git({
-            dir: await this.mkTmpDir(GitRepository.name + "-snapshot"),
+            dir: await (0, temp_1.mkTmpDir)(exports.gitRepositoryName, "repo", "snapshots"),
             log: data.options.verbose,
         });
         const pkgPatterns = (0, string_1.makePathPatterns)(data.options.packageNames);
@@ -143,13 +146,10 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
         }, [])
             .sort((a, b) => a.date.localeCompare(b.date));
     }
-    async onBackup(data) {
+    async backup(data) {
         const pkg = data.package;
-        const sourcePath = data.targetPath ?? pkg.path;
-        (0, assert_1.ok)(typeof sourcePath === "string");
-        if (!(await (0, fs_1.existsDir)(sourcePath)))
-            throw new AppError_1.AppError(`Package path not exists: ${sourcePath}`);
-        const tmpPath = await this.mkTmpDir(GitRepository.name + "-backup");
+        const path = pkg.path;
+        const tmpPath = await (0, temp_1.mkTmpDir)(exports.gitRepositoryName, "repo", "backup");
         const branchName = GitRepository.buildBranchName(data.package.name);
         const git = new Git_1.Git({
             dir: tmpPath,
@@ -169,7 +169,7 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const backupPathsOptions = {
             package: data.package,
             snapshot: data.snapshot,
-            targetPath: sourcePath,
+            path: path,
             verbose: data.options.verbose,
         };
         const include = await (0, paths_1.parseBackupPaths)(pkg.include ?? ["**"], backupPathsOptions);
@@ -177,13 +177,13 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
             ? await (0, paths_1.parseBackupPaths)(pkg.exclude, backupPathsOptions)
             : undefined;
         const stream = await (0, fast_glob_1.default)(include, {
-            cwd: sourcePath,
+            cwd: path,
             ignore: exclude,
             dot: true,
         });
         let files = 0;
         for await (const entry of stream) {
-            const source = (0, path_1.join)(sourcePath, entry);
+            const source = (0, path_1.join)(path, entry);
             const target = (0, path_1.join)(tmpPath, entry);
             const dir = (0, path_1.dirname)(target);
             if (!createdPaths.includes(dir)) {
@@ -215,16 +215,13 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
         await git.addTag(meta.name, meta.message);
         await git.push({ branchName });
         await git.pushTags();
-        await (0, promises_1.rm)(tmpPath, {
-            recursive: true,
-        });
+        await (0, promises_1.rm)(tmpPath, { recursive: true });
     }
-    onCopyBackup(data) {
+    copy(data) {
         throw new Error("Method not implemented.");
     }
-    async onRestore(data) {
-        const restorePath = data.targetPath ?? data.package.restorePath;
-        (0, assert_1.ok)(restorePath);
+    async restore(data) {
+        const restorePath = data.snapshotPath;
         const tagName = GitRepository.buildSnapshotTagName({
             id: data.snapshot.id,
             package: data.package.name,