@datatruck/cli 0.26.2 → 0.28.0

package/Action/RestoreAction.js

@@ -1,17 +1,22 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RestoreAction = void 0;
-const AppError_1 = require("../Error/AppError");
 const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
 const TaskFactory_1 = require("../Factory/TaskFactory");
+const DataFormat_1 = require("../utils/DataFormat");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
+const date_1 = require("../utils/date");
 const fs_1 = require("../utils/fs");
-const object_1 = require("../utils/object");
-const process_1 = require("../utils/process");
+const list_1 = require("../utils/list");
+const progress_1 = require("../utils/progress");
+const temp_1 = require("../utils/temp");
 const SnapshotsAction_1 = require("./SnapshotsAction");
 const assert_1 = require("assert");
-const os_1 = require("os");
+const chalk_1 = __importDefault(require("chalk"));
 class RestoreAction {
     config;
     options;
@@ -21,36 +26,6 @@ class RestoreAction {
         this.config = config;
         this.options = options;
     }
-    assocConfigs(packages, snapshots) {
-        return snapshots.map((snapshot) => {
-            const pkg = packages.find((pkg) => pkg.name === snapshot.packageName) ?? null;
-            return [snapshot, pkg];
-        });
-    }
-    async init(session, snapshotId, snapshots) {
-        await session.initDrivers();
-        for (const [snapshot, pkg] of snapshots) {
-            if (!pkg)
-                throw new AppError_1.AppError(`Package config not found: ${snapshot.packageName}`);
-            const sessionId = await session.init({
-                snapshotId: snapshotId,
-                packageName: pkg.name,
-            });
-            if (pkg.task)
-                await session.initTask({
-                    sessionId: sessionId,
-                    taskName: pkg.task.name,
-                });
-            for (const repositoryName of pkg.repositoryNames ?? []) {
-                const repo = (0, config_1.findRepositoryOrFail)(this.config, repositoryName);
-                await session.initRepository({
-                    sessionId: sessionId,
-                    repositoryName: repositoryName,
-                    repositoryType: repo.type,
-                });
-            }
-        }
-    }
     async findSnapshots() {
         const result = [];
         for (const repository of this.config.repositories) {
@@ -90,178 +65,166 @@ class RestoreAction {
             return true;
         });
     }
-    async task(session, pkg, task, snapshot, targetPath) {
-        const taskId = session.findTaskId({
-            packageName: pkg.name,
-            taskName: pkg.task.name,
-        });
-        await session.startTask({
-            id: taskId,
-        });
-        let error;
-        if (this.repoErrors[pkg.name]?.length) {
-            error = AppError_1.AppError.create("Repository failed", this.repoErrors[pkg.name]);
-        }
-        else if (this.taskErrors[pkg.name]?.length) {
-            error = AppError_1.AppError.create("Previous task failed", this.taskErrors[pkg.name]);
-        }
-        else {
-            try {
-                await task.onRestore({
-                    package: pkg,
+    async restore(data) {
+        let { snapshot, pkg, task } = data;
+        const repoConfig = (0, config_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
+        const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
+        if (!this.options.restorePath)
+            pkg = { ...pkg, restorePath: pkg.path };
+        let snapshotPath = pkg.restorePath ?? pkg.path;
+        await data.gc.cleanupIfFail(async () => {
+            if (task) {
+                const taskResult = await task.prepareRestore({
                     options: this.options,
+                    package: pkg,
                     snapshot,
-                    targetPath,
-                    onProgress: async (progress) => {
-                        await session.progressTask({
-                            id: taskId,
-                            progress,
-                        });
-                    },
                 });
+                snapshotPath = taskResult?.snapshotPath;
             }
-            catch (_) {
-                if (!this.taskErrors[pkg.name])
-                    this.taskErrors[pkg.name] = [];
-                this.taskErrors[pkg.name].push((error = _));
-            }
-        }
-        await session.endTask({
-            id: taskId,
-            error: error?.stack,
-        });
-        return {
-            error: error ? false : true,
-            tmpDirs: task?.tmpDirs ?? [],
-        };
-    }
-    async restore(session, pkg, repo, snapshot, targetPath) {
-        const repositoryId = session.findRepositoryId({
-            packageName: pkg.name,
-            repositoryName: repo.name,
-        });
-        await session.startRepository({
-            id: repositoryId,
-        });
-        let repoError;
-        let repoInstance;
-        if (!this.options.restorePath)
-            pkg = {
-                ...pkg,
-                restorePath: pkg.path,
-            };
-        try {
-            if (typeof pkg.restorePath !== "string")
-                throw new AppError_1.AppError("Restore path is not defined");
-            await (0, fs_1.mkdirIfNotExists)(pkg.restorePath);
-            if (!(await (0, fs_1.isEmptyDir)(pkg.restorePath)))
-                throw new AppError_1.AppError(`Restore path is not empty: ${pkg.restorePath}`);
-            if (this.options.verbose)
-                (0, cli_1.logExec)(`restorePath=${pkg.restorePath}`);
-            repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
-            await repoInstance.onRestore({
-                package: pkg,
-                targetPath,
-                packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repo.type &&
-                    (!config.names || config.names.includes(repo.name)))?.config,
+            await (0, fs_1.initEmptyDir)(snapshotPath);
+            if (this.config.minFreeDiskSpace)
+                await (0, fs_1.ensureFreeDiskSpace)([snapshotPath], this.config.minFreeDiskSpace);
+            await repo.restore({
                 options: this.options,
-                snapshot: snapshot,
-                onProgress: async (progress) => {
-                    await session.progressRepository({
-                        id: repositoryId,
-                        progress,
-                    });
-                },
+                snapshot: data.snapshot,
+                package: pkg,
+                snapshotPath: snapshotPath,
+                packageConfig: pkg.repositoryConfigs?.find((config) => config.type === repoConfig.type &&
+                    (!config.names || config.names.includes(repoConfig.name)))?.config,
+                onProgress: data.onProgress,
             });
-            if (pkg.restorePermissions && (0, os_1.platform)() !== "win32")
-                await (0, process_1.exec)("chown", [
-                    "-R",
-                    `${pkg.restorePermissions.uid}:${pkg.restorePermissions.gid}`,
-                    pkg.restorePath,
-                ], {}, {
-                    log: this.options.verbose,
-                });
-        }
-        catch (error) {
-            (0, object_1.push)(this.repoErrors, pkg.name, (repoError = error));
-        }
-        await session.endRepository({
-            id: repositoryId,
-            error: repoError?.stack,
         });
-        return {
-            error: repoError ? false : true,
-            tmpDirs: repoInstance?.tmpDirs || [],
-        };
+        return { snapshotPath };
     }
-    getError(pkg) {
-        const taskErrors = this.taskErrors[pkg.name] || [];
-        const repoErrors = this.repoErrors[pkg.name] || [];
-        const errors = [...taskErrors, ...repoErrors];
-        if (!errors.length)
-            return;
-        return AppError_1.AppError.create(taskErrors.length && repoErrors.length
-            ? "Task and repository failed"
-            : taskErrors.length && !repoErrors.length
-                ? "Task failed"
-                : "Repository failed", errors);
+    dataFormat(result, options = {}) {
+        const renderTitle = (item, color) => {
+            let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
+            return item.key === "restore" && color ? chalk_1.default.cyan(title) : title;
+        };
+        const renderData = (item, color) => {
+            const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
+            return item.key === "snapshots"
+                ? `${item.data.id.slice(0, 8)} ${g(`${item.data.packages} packages`)}`
+                : item.key === "task"
+                    ? `${item.data.packageName} ${g(item.data.taskName)}`
+                    : item.key === "restore"
+                        ? `${item.data.packageName} ${g(item.data.repositoryName)}`
+                        : "";
+        };
+        return new DataFormat_1.DataFormat({
+            streams: options.streams,
+            json: result,
+            table: {
+                headers: [
+                    { value: "", width: 3 },
+                    { value: "Title", width: 15 },
+                    { value: "Data" },
+                    { value: "Duration", width: 10 },
+                    { value: "Error", width: 50 },
+                ],
+                rows: () => result.map((item) => [
+                    (0, cli_1.resultColumn)(item.error),
+                    renderTitle(item, true),
+                    renderData(item, true),
+                    (0, date_1.duration)(item.elapsed),
+                    (0, cli_1.errorColumn)(item.error, options.verbose),
+                ]),
+            },
+        });
     }
-    async exec(session) {
-        if (!this.options.snapshotId)
-            throw new AppError_1.AppError("Snapshot id is required");
-        const snapshots = this.groupSnapshots(await this.findSnapshots());
-        if (!snapshots.length)
-            throw new AppError_1.AppError("None snapshot found");
-        let packages = (0, config_1.filterPackages)(this.config, {
-            ...this.options,
-            sourceAction: "restore",
+    async exec() {
+        const { options } = this;
+        const pm = new progress_1.ProgressManager({
+            verbose: options.verbose,
+            tty: options.tty,
+            enabled: options.progress,
+            interval: options.progressInterval,
         });
-        packages = (0, config_1.resolvePackages)(packages, {
-            snapshotId: this.options.snapshotId,
-            snapshotDate: snapshots[0].date,
-            action: "restore",
+        const l = new list_1.Listr3({
+            streams: options.streams,
+            progressManager: pm,
         });
-        const snapshotAndConfigs = this.assocConfigs(packages, snapshots);
-        await this.init(session, this.options.snapshotId, snapshotAndConfigs);
-        const errors = [];
-        for (const [snapshot, pkg] of snapshotAndConfigs) {
-            (0, assert_1.ok)(pkg);
-            const repo = (0, config_1.findRepositoryOrFail)(this.config, snapshot.repositoryName);
-            const id = session.findId({
-                packageName: pkg.name,
-            });
-            await session.start({ id });
-            let targetPath;
-            let taskInstance;
-            if (pkg.task) {
-                taskInstance = (0, TaskFactory_1.TaskFactory)(pkg.task);
-                const result = await taskInstance.onBeforeRestore({
-                    options: this.options,
-                    package: pkg,
-                    snapshot,
-                });
-                targetPath = result?.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_1.rmTmpDir)(taskInstance?.tmpDirs || []);
-                await (0, fs_1.rmTmpDir)(tmpDirs);
-                if (pkg.restorePath && (0, fs_1.isTmpDir)(pkg.restorePath))
-                    await (0, fs_1.rmTmpDir)(pkg.restorePath);
-            }
-            const error = this.getError(pkg);
-            await session.end({
-                id,
-                error: error?.message,
-            });
-            if (error)
-                errors.push(error);
-        }
-        await session.endDrivers();
-        return { errors };
+        return l
+            .add(l.$task({
+            key: "snapshots",
+            data: {
+                id: "",
+                packages: 0,
+            },
+            title: {
+                initial: "Fetch snapshots",
+                started: "Fetching snapshots",
+                completed: "Snapshots fetched",
+                failed: "Snapshot fetch failed",
+            },
+            run: async (_, data) => {
+                const { minFreeDiskSpace } = this.config;
+                if (minFreeDiskSpace)
+                    await (0, temp_1.ensureFreeDiskTempSpace)(minFreeDiskSpace);
+                if (!options.snapshotId)
+                    throw new Error("Snapshot id is required");
+                const snapshots = this.groupSnapshots(await this.findSnapshots());
+                if (!snapshots.length)
+                    throw new Error("None snapshot found");
+                data.id = options.snapshotId;
+                data.packages = snapshots.length;
+                return snapshots.map((snapshot) => l.$task({
+                    key: "restore",
+                    keyIndex: snapshot.packageName,
+                    data: snapshot,
+                    title: {
+                        initial: `Restore ${snapshot.packageName} snapshot`,
+                        started: `Restoring ${snapshot.packageName} snapshot`,
+                        completed: `Snapshot restored: ${snapshot.packageName}`,
+                        failed: `Snapshot restore failed: ${snapshot.packageName}`,
+                    },
+                    exitOnError: false,
+                    run: async (listTask) => {
+                        const pkg = (0, config_1.resolvePackage)((0, config_1.findPackageOrFail)(this.config, snapshot.packageName), {
+                            snapshotId: options.snapshotId,
+                            snapshotDate: snapshot.date,
+                            action: "restore",
+                        });
+                        const gc = new temp_1.GargabeCollector();
+                        const task = pkg.task ? (0, TaskFactory_1.createTask)(pkg.task) : undefined;
+                        const restore = await this.restore({
+                            gc,
+                            pkg,
+                            task,
+                            snapshot: snapshot,
+                            onProgress: (p) => pm.update(p, (t) => (listTask.output = t)),
+                        });
+                        if (!task)
+                            return await gc.cleanup();
+                        return l.$tasks({
+                            key: "task",
+                            keyIndex: pkg.name,
+                            data: { taskName: pkg.task.name, packageName: pkg.name },
+                            title: {
+                                initial: `Execute ${pkg.task?.name} task`,
+                                started: `Executing ${pkg.task?.name} task`,
+                                completed: `Task executed: ${pkg.task?.name}`,
+                                failed: `Task execute failed: ${pkg.task?.name}`,
+                            },
+                            exitOnError: false,
+                            runWrapper: gc.cleanup.bind(gc),
+                            run: async (listTask) => {
+                                const { snapshotPath } = restore;
+                                (0, assert_1.ok)(snapshotPath);
+                                await task.restore({
+                                    package: pkg,
+                                    options,
+                                    snapshot,
+                                    snapshotPath,
+                                    onProgress: (p) => pm.update(p, (t) => (listTask.output = t)),
+                                });
+                            },
+                        });
+                    },
+                }));
+            },
+        }))
+            .exec();
     }
 }
 exports.RestoreAction = RestoreAction;

package/Action/SnapshotsAction.d.ts

@@ -1,9 +1,9 @@
 import type { ConfigType } from "../Config/Config";
 import { RepositoryConfigEnabledActionType } from "../Config/RepositoryConfig";
-import { SnapshotResultType } from "../Repository/RepositoryAbstract";
+import { Snapshot } from "../Repository/RepositoryAbstract";
 import { IfRequireKeys } from "../utils/ts";
-export type SnapshotGroupByType = keyof Pick<SnapshotExtendedType, "packageName" | "repositoryName" | "repositoryType">;
-export type SnapshotsActionOptionsType = {
+export type SnapshotGroupByType = keyof Pick<ExtendedSnapshot, "packageName" | "repositoryName" | "repositoryType">;
+export type SnapshotsActionOptions = {
     ids?: string[];
     repositoryNames?: string[];
     packageNames?: string[];
@@ -21,14 +21,14 @@ export type SnapshotsActionOptionsType = {
     lastYearly?: number;
     groupBy?: SnapshotGroupByType[];
 };
-export type SnapshotExtendedType = {
+export type ExtendedSnapshot = {
     shortId: string;
     repositoryName: string;
     repositoryType: string;
-} & SnapshotResultType;
+} & Snapshot;
 export declare class SnapshotsAction<TRequired extends boolean = true> {
     readonly config: ConfigType;
-    readonly options: IfRequireKeys<TRequired, SnapshotsActionOptionsType>;
-    constructor(config: ConfigType, options: IfRequireKeys<TRequired, SnapshotsActionOptionsType>);
-    exec(sourceAction?: RepositoryConfigEnabledActionType): Promise<SnapshotExtendedType[]>;
+    readonly options: IfRequireKeys<TRequired, SnapshotsActionOptions>;
+    constructor(config: ConfigType, options: IfRequireKeys<TRequired, SnapshotsActionOptions>);
+    exec(sourceAction?: RepositoryConfigEnabledActionType): Promise<ExtendedSnapshot[]>;
 }

package/Action/SnapshotsAction.js

@@ -15,21 +15,21 @@ class SnapshotsAction {
         if (!sourceAction)
             sourceAction = "snapshots";
         let result = [];
-        for (const repo of this.config.repositories) {
-            if (!(0, config_1.filterRepository)(repo, sourceAction))
+        for (const repoConfig of this.config.repositories) {
+            if (!(0, config_1.filterRepository)(repoConfig, sourceAction))
                 continue;
             if (this.options.repositoryNames &&
-                !this.options.repositoryNames.includes(repo.name))
+                !this.options.repositoryNames.includes(repoConfig.name))
                 continue;
             if (this.options.repositoryTypes &&
-                !this.options.repositoryTypes.includes(repo.type))
+                !this.options.repositoryTypes.includes(repoConfig.type))
                 continue;
-            const repoInstance = (0, RepositoryFactory_1.RepositoryFactory)(repo);
+            const repo = (0, RepositoryFactory_1.createRepo)(repoConfig);
             const configPackageNames = this.config.packages.map((pkg) => pkg.name);
             const packageNames = this.options.packageConfig
                 ? this.options.packageNames?.filter((name) => configPackageNames.includes(name)) || configPackageNames
                 : this.options.packageNames;
-            const snapshots = await repoInstance.onSnapshots({
+            const snapshots = await repo.fetchSnapshots({
                 options: {
                     ...this.options,
                     packageNames,
@@ -38,8 +38,8 @@ class SnapshotsAction {
             const extentedItems = snapshots.map((ss) => ({
                 ...ss,
                 shortId: ss.id.slice(0, 8),
-                repositoryName: repo.name,
-                repositoryType: repo.type,
+                repositoryName: repoConfig.name,
+                repositoryType: repoConfig.type,
             }));
             result.push(...extentedItems);
         }