@datatruck/cli 0.32.3 → 0.34.0

package/lib/Action/CopyAction.js

@@ -1,164 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CopyAction = void 0;
-const RepositoryFactory_1 = require("../Factory/RepositoryFactory");
-const DataFormat_1 = require("../utils/DataFormat");
-const cli_1 = require("../utils/cli");
-const config_1 = require("../utils/datatruck/config");
-const snapshot_1 = require("../utils/datatruck/snapshot");
-const date_1 = require("../utils/date");
-const list_1 = require("../utils/list");
-const progress_1 = require("../utils/progress");
-const temp_1 = require("../utils/temp");
-const chalk_1 = __importDefault(require("chalk"));
-class CopyAction {
-    config;
-    options;
-    constructor(config, options) {
-        this.config = config;
-        this.options = options;
-    }
-    dataFormat(result, options = {}) {
-        const renderTitle = (item, color) => {
-            let title = item.key.slice(0, 1).toUpperCase() + item.key.slice(1);
-            return item.key === "copy" && color ? chalk_1.default.cyan(title) : title;
-        };
-        const renderData = (item, color, items = []) => {
-            const g = (v) => (color ? `${chalk_1.default.gray(`(${v})`)}` : `(${v})`);
-            return item.key === "snapshots"
-                ? item.data.snapshots.length
-                : item.key === "copy"
-                    ? `${item.data.packageName} ${g([
-                        item.data.snapshotId.slice(0, 8),
-                        item.data.mirrorRepositoryName,
-                    ].join(" "))}`
-                    : item.key === "summary"
-                        ? (0, cli_1.renderObject)({
-                            errors: item.data.errors,
-                            copied: items.filter((i) => i.key === "copy" && !i.error && !i.data.skipped).length,
-                            skipped: items.filter((i) => i.key === "copy" && !i.error && i.data.skipped).length,
-                        }, color)
-                        : "";
-        };
-        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.renderResult)(item.error),
-                    renderTitle(item, true),
-                    renderData(item, true, result),
-                    (0, date_1.duration)(item.elapsed),
-                    (0, cli_1.renderError)(item.error, options.verbose),
-                ]),
-            },
-        });
-    }
-    async exec() {
-        const { options } = this;
-        const pm = new progress_1.ProgressManager({
-            verbose: options.verbose,
-            tty: options.tty,
-            mode: options.progress,
-        });
-        const l = new list_1.Listr3({ progressManager: pm });
-        return l
-            .add(l.$task({
-            key: "snapshots",
-            data: { snapshots: [] },
-            title: {
-                initial: "Fetch snapshots",
-                started: "Fetching snapshots",
-                completed: "Snapshots fetched",
-                failed: "Snapshot fetch failed",
-            },
-            run: async (task, data) => {
-                if (this.config.minFreeDiskSpace)
-                    await (0, temp_1.ensureFreeDiskTempSpace)(this.config.minFreeDiskSpace);
-                const sourceRepoConfig = (0, config_1.findRepositoryOrFail)(this.config, this.options.repositoryName);
-                const repo = (0, RepositoryFactory_1.createRepo)(sourceRepoConfig);
-                let snapshots = await repo.fetchSnapshots({
-                    options: {
-                        ids: this.options.ids,
-                        packageNames: this.options.packageNames,
-                        packageTaskNames: this.options.packageTaskNames,
-                    },
-                });
-                if (this.options.last)
-                    snapshots = (0, snapshot_1.groupAndFilter)(snapshots, ["packageName"], {
-                        last: this.options.last,
-                    }).map(({ item }) => item);
-                data.snapshots = snapshots;
-                task.title = `Snapshots fetched: ${snapshots.length}`;
-                if (!snapshots.length)
-                    throw new Error("No snapshots found");
-                const repositoryNames2 = this.options.repositoryNames2 ||
-                    this.config.repositories
-                        .filter((r) => r.name !== sourceRepoConfig.name &&
-                        r.type === sourceRepoConfig.type &&
-                        (0, config_1.filterRepository)(r, "backup"))
-                        .map((r) => r.name);
-                if (!repositoryNames2.length)
-                    throw new Error("No mirror snapshots found");
-                return snapshots.flatMap((snapshot) => repositoryNames2.map((repo2) => {
-                    const id = snapshot.id.slice(0, 8);
-                    const pkgName = snapshot.packageName;
-                    return l.$task({
-                        key: "copy",
-                        keyIndex: [snapshot.packageName, repo2, snapshot.id],
-                        data: {
-                            snapshotId: snapshot.id,
-                            packageName: snapshot.packageName,
-                            repositoryName: sourceRepoConfig.name,
-                            mirrorRepositoryName: repo2,
-                            skipped: false,
-                        },
-                        title: {
-                            initial: `Copy snapshot: ${pkgName} (${id}) » ${repo2}`,
-                            started: `Copying snapshot: ${pkgName} (${id}) » ${repo2}`,
-                            completed: `Snapshot copied: ${pkgName} (${id}) » ${repo2}`,
-                            failed: `Snapshot copy failed: ${pkgName} (${id}) » ${repo2}`,
-                        },
-                        exitOnError: false,
-                        run: async (task, data) => {
-                            const mirrorConfig = (0, config_1.findRepositoryOrFail)(this.config, repo2);
-                            const mirrorRepo = (0, RepositoryFactory_1.createRepo)(mirrorConfig);
-                            (0, config_1.ensureSameRepositoryType)(sourceRepoConfig, mirrorConfig);
-                            const currentCopies = await mirrorRepo.fetchSnapshots({
-                                options: {
-                                    ids: [snapshot.id],
-                                    packageNames: [snapshot.packageName],
-                                },
-                            });
-                            if (currentCopies.length) {
-                                data.skipped = true;
-                                return task.skip(`Already exists at ${mirrorConfig.name}: ${pkgName} (${id})`);
-                            }
-                            if (this.config.minFreeDiskSpace)
-                                await mirrorRepo.ensureFreeDiskSpace(mirrorConfig.config, this.config.minFreeDiskSpace);
-                            await repo.copy({
-                                mirrorRepositoryConfig: mirrorConfig.config,
-                                options: { verbose: this.options.verbose },
-                                package: { name: snapshot.packageName },
-                                snapshot,
-                                onProgress: (p) => pm.update(p, (d) => (task.output = d)),
-                            });
-                        },
-                    });
-                }));
-            },
-        }))
-            .exec();
-    }
-}
-exports.CopyAction = CopyAction;

package/lib/Command/BackupCommand.d.ts

@@ -1,19 +0,0 @@
-import { BackupAction } from "../Action/BackupAction";
-import { RepositoryConfig } from "../Config/RepositoryConfig";
-import { If, Unwrap } from "../utils/ts";
-import { CommandAbstract } from "./CommandAbstract";
-export type BackupCommandOptions<TResolved = false> = {
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
-    tag?: If<TResolved, string[]>;
-    dryRun?: boolean;
-    date?: string;
-    prune?: boolean;
-};
-export type BackupCommandResult = Unwrap<BackupAction["exec"]>;
-export declare class BackupCommand extends CommandAbstract<BackupCommandOptions<false>, BackupCommandOptions<true>> {
-    onOptions(): import("../utils/cli").OptionsType<BackupCommandOptions<false>, BackupCommandOptions<true>>;
-    onExec(): Promise<1 | 0>;
-}

package/lib/Command/ConfigCommand.d.ts

@@ -1,15 +0,0 @@
-import { ConfigAction } from "../Action/ConfigAction";
-import { RepositoryConfig } from "../Config/RepositoryConfig";
-import { If, Unwrap } from "../utils/ts";
-import { CommandAbstract } from "./CommandAbstract";
-export type ConfigCommandOptions<TResolved = false> = {
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
-};
-export type ConfigCommandResult = Unwrap<ConfigAction["exec"]>;
-export declare class ConfigCommand extends CommandAbstract<ConfigCommandOptions<false>, ConfigCommandOptions<true>> {
-    onOptions(): import("../utils/cli").OptionsType<ConfigCommandOptions<false>, ConfigCommandOptions<true>>;
-    onExec(): Promise<number>;
-}

package/lib/Command/CopyCommand.d.ts

@@ -1,16 +0,0 @@
-import { CopyAction } from "../Action/CopyAction";
-import { If, Unwrap } from "../utils/ts";
-import { CommandAbstract } from "./CommandAbstract";
-export type CopyCommandOptionsType<TResolved = false> = {
-    id?: If<TResolved, string[]>;
-    last?: number;
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    repository: string;
-    repository2?: If<TResolved, string[]>;
-};
-export type CopyCommandResult = Unwrap<CopyAction["exec"]>;
-export declare class CopyCommand extends CommandAbstract<CopyCommandOptionsType<false>, CopyCommandOptionsType<true>> {
-    onOptions(): import("../utils/cli").OptionsType<CopyCommandOptionsType<false>, CopyCommandOptionsType<true>>;
-    onExec(): Promise<1 | 0>;
-}

package/lib/Command/InitCommand.d.ts

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

package/lib/Command/RestoreCommand.d.ts

@@ -1,17 +0,0 @@
-import { RepositoryConfig } from "../Config/RepositoryConfig";
-import { If } from "../utils/ts";
-import { CommandAbstract } from "./CommandAbstract";
-export type RestoreCommandOptionsType<TResolved = false> = {
-    id: string;
-    package?: If<TResolved, string[]>;
-    packageTask?: If<TResolved, string[]>;
-    packageConfig?: boolean;
-    repository?: If<TResolved, string[]>;
-    repositoryType?: If<TResolved, RepositoryConfig["type"][]>;
-    tag?: If<TResolved, string[]>;
-    initial?: boolean;
-};
-export declare class RestoreCommand extends CommandAbstract<RestoreCommandOptionsType<false>, RestoreCommandOptionsType<true>> {
-    onOptions(): import("../utils/cli").OptionsType<RestoreCommandOptionsType<false>, RestoreCommandOptionsType<true>>;
-    onExec(): Promise<1 | 0>;
-}

package/lib/Config/Config.d.ts

@@ -1,28 +0,0 @@
-import { DataFormatType } from "../utils/DataFormat";
-import { DatatruckCronServerOptions } from "../utils/datatruck/cron-server";
-import { DatatruckRepositoryServerOptions } from "../utils/datatruck/repository-server";
-import { ReportStep } from "../utils/reportSteps";
-import { SpawnStep } from "../utils/spawnSteps";
-import { PackageConfig } from "./PackageConfig";
-import { PrunePolicyConfig } from "./PrunePolicyConfig";
-import { RepositoryConfig } from "./RepositoryConfig";
-export type Config = {
-    $schema?: string;
-    tempDir?: string;
-    minFreeDiskSpace?: string | number;
-    repositories: RepositoryConfig[];
-    packages: PackageConfig[];
-    server?: DatatruckServerOptions;
-    reports?: ReportConfig[];
-    prunePolicy?: PrunePolicyConfig;
-};
-export type DatatruckServerOptions = {
-    log?: boolean;
-    repository?: DatatruckRepositoryServerOptions;
-    cron?: DatatruckCronServerOptions;
-};
-export type ReportConfig = {
-    when?: "success" | "error";
-    format?: Exclude<DataFormatType, "custom" | "tpl">;
-    run: SpawnStep | ReportStep;
-};

package/lib/Config/PackageConfig.d.ts

@@ -1,24 +0,0 @@
-import { SpawnStep } from "../utils/spawnSteps";
-import { PackageRepositoryConfig } from "./PackageRepositoryConfig";
-import { PrunePolicyConfig } from "./PrunePolicyConfig";
-import type { TaskConfig } from "./TaskConfig";
-export type Meta = {
-    [name: string]: any;
-};
-export type PackageConfig = {
-    name: string;
-    enabled?: boolean;
-    task?: TaskConfig;
-    path?: string;
-    restorePath?: string;
-    meta?: Meta;
-    restorePermissions?: {
-        uid: string | number;
-        gid: string | number;
-    };
-    include?: (string | SpawnStep)[];
-    exclude?: (string | SpawnStep)[];
-    repositoryNames?: string[];
-    prunePolicy?: PrunePolicyConfig;
-    repositoryConfigs?: PackageRepositoryConfig[];
-};

package/lib/Config/PackageRepositoryConfig.d.ts

@@ -1,15 +0,0 @@
-import { DatatruckPackageRepositoryConfig, datatruckRepositoryName } from "../Repository/DatatruckRepository";
-import { GitPackageRepositoryConfig, gitRepositoryName } from "../Repository/GitRepository";
-import { ResticPackageRepositoryConfig, resticRepositoryName } from "../Repository/ResticRepository";
-export type PackageRepositoryConfig = {
-    names?: string[];
-} & ({
-    type: typeof resticRepositoryName;
-    config: ResticPackageRepositoryConfig;
-} | {
-    type: typeof datatruckRepositoryName;
-    config: DatatruckPackageRepositoryConfig;
-} | {
-    type: typeof gitRepositoryName;
-    config: GitPackageRepositoryConfig;
-});

package/lib/Config/PrunePolicyConfig.d.ts

@@ -1,2 +0,0 @@
-import { PruneActionsOptions } from "../Action/PruneAction";
-export type PrunePolicyConfig = Pick<PruneActionsOptions, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;

package/lib/Config/RepositoryConfig.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Config/TaskConfig.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/lib/Factory/CommandFactory.d.ts

@@ -1,45 +0,0 @@
-import { CleanCacheActionOptions } from "../Action/CleanCacheAction";
-import { BackupCommandOptions, BackupCommandResult } from "../Command/BackupCommand";
-import { GlobalOptions } from "../Command/CommandAbstract";
-import { ConfigCommandResult, ConfigCommandOptions } from "../Command/ConfigCommand";
-import { CopyCommandOptionsType } from "../Command/CopyCommand";
-import { InitCommandResult, InitCommandOptions } from "../Command/InitCommand";
-import { PruneCommandOptions } from "../Command/PruneCommand";
-import { RestoreCommandOptionsType } from "../Command/RestoreCommand";
-import { SnapshotsCommandResult, SnapshotsCommandOptions } from "../Command/SnapshotsCommand";
-import { StartServerCommand, StartServerCommandOptions } from "../Command/StartServerCommand";
-import { Streams } from "../utils/stream";
-export declare enum CommandEnum {
-    config = "config",
-    init = "init",
-    snapshots = "snapshots",
-    prune = "prune",
-    backup = "backup",
-    restore = "restore",
-    copy = "copy",
-    cleanCache = "clean-cache",
-    startServer = "start-server"
-}
-export type OptionsMap = {
-    [CommandEnum.config]: ConfigCommandOptions;
-    [CommandEnum.init]: InitCommandOptions;
-    [CommandEnum.snapshots]: SnapshotsCommandOptions;
-    [CommandEnum.prune]: PruneCommandOptions;
-    [CommandEnum.backup]: BackupCommandOptions;
-    [CommandEnum.restore]: RestoreCommandOptionsType;
-    [CommandEnum.copy]: CopyCommandOptionsType;
-    [CommandEnum.cleanCache]: CleanCacheActionOptions;
-    [CommandEnum.startServer]: StartServerCommandOptions;
-};
-export type LogMap = {
-    [CommandEnum.config]: ConfigCommandResult;
-    [CommandEnum.init]: InitCommandResult;
-    [CommandEnum.snapshots]: SnapshotsCommandResult;
-    [CommandEnum.backup]: BackupCommandResult;
-};
-export declare function CommandFactory<TCommand extends keyof OptionsMap>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMap[TCommand], streams?: Partial<Streams>, configPath?: string): StartServerCommand;
-export declare function exec<TCommand extends keyof OptionsMap>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMap[TCommand], streams?: Partial<Streams>): Promise<number>;
-export declare function createActionInterface(globalOptions: GlobalOptions<true>): {
-    [K in keyof OptionsMap as `${K}`]: (options: OptionsMap[K]) => Promise<K extends keyof LogMap ? LogMap[K] : never>;
-};
-export declare function CommandConstructorFactory(type: CommandEnum): typeof StartServerCommand;

package/lib/Factory/CommandFactory.js

@@ -1,96 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandConstructorFactory = exports.createActionInterface = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
-const BackupCommand_1 = require("../Command/BackupCommand");
-const CleanCacheCommand_1 = require("../Command/CleanCacheCommand");
-const ConfigCommand_1 = require("../Command/ConfigCommand");
-const CopyCommand_1 = require("../Command/CopyCommand");
-const InitCommand_1 = require("../Command/InitCommand");
-const PruneCommand_1 = require("../Command/PruneCommand");
-const RestoreCommand_1 = require("../Command/RestoreCommand");
-const SnapshotsCommand_1 = require("../Command/SnapshotsCommand");
-const StartServerCommand_1 = require("../Command/StartServerCommand");
-const AppError_1 = require("../Error/AppError");
-const stream_1 = require("stream");
-var CommandEnum;
-(function (CommandEnum) {
-    CommandEnum["config"] = "config";
-    CommandEnum["init"] = "init";
-    CommandEnum["snapshots"] = "snapshots";
-    CommandEnum["prune"] = "prune";
-    CommandEnum["backup"] = "backup";
-    CommandEnum["restore"] = "restore";
-    CommandEnum["copy"] = "copy";
-    CommandEnum["cleanCache"] = "clean-cache";
-    CommandEnum["startServer"] = "start-server";
-})(CommandEnum || (exports.CommandEnum = CommandEnum = {}));
-function CommandFactory(type, globalOptions, options, streams, configPath) {
-    const constructor = CommandConstructorFactory(type);
-    return new constructor(globalOptions, options, streams, configPath);
-}
-exports.CommandFactory = CommandFactory;
-async function exec(type, globalOptions, options, streams) {
-    return await CommandFactory(type, globalOptions, options, streams).onExec();
-}
-exports.exec = exec;
-function createActionInterface(globalOptions) {
-    const object = {};
-    for (const type of Object.values(CommandEnum)) {
-        object[type] = async (options) => {
-            let stdoutData = "";
-            const stdout = new stream_1.Writable({
-                write(chunk, encoding, callback) {
-                    stdoutData += chunk.toString();
-                    process.stdout.write(chunk, encoding, callback);
-                },
-            }).on("data", (chunk) => (stdoutData += chunk.toString()));
-            const end = () => !stdout.closed &&
-                new Promise((resolve) => stdout.end().on("close", resolve));
-            try {
-                const exitCode = await exec(type, { ...globalOptions, outputFormat: "json", verbose: 1 }, options, { stdout });
-                if (exitCode !== 0)
-                    throw new Error(`Invalid exit code: ${exitCode}`);
-                await end();
-                return JSON.parse(stdoutData);
-            }
-            finally {
-                await end();
-            }
-        };
-    }
-    return object;
-}
-exports.createActionInterface = createActionInterface;
-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.restore) {
-        return RestoreCommand_1.RestoreCommand;
-    }
-    else if (type === CommandEnum.copy) {
-        return CopyCommand_1.CopyCommand;
-    }
-    else if (type === CommandEnum.cleanCache) {
-        return CleanCacheCommand_1.CleanCacheCommand;
-    }
-    else if (type === CommandEnum.startServer) {
-        return StartServerCommand_1.StartServerCommand;
-    }
-    else {
-        throw new AppError_1.AppError(`Invalid command type: ${type}`);
-    }
-}
-exports.CommandConstructorFactory = CommandConstructorFactory;

package/lib/Factory/RepositoryFactory.d.ts

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

package/lib/Factory/RepositoryFactory.js

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createRepo = void 0;
-const AppError_1 = require("../Error/AppError");
-const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
-const GitRepository_1 = require("../Repository/GitRepository");
-const ResticRepository_1 = require("../Repository/ResticRepository");
-function createRepo(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 === DatatruckRepository_1.datatruckRepositoryName) {
-        return new DatatruckRepository_1.DatatruckRepository(repository);
-    }
-    else {
-        throw new AppError_1.AppError(`Invalid repository type: ${type}`);
-    }
-}
-exports.createRepo = createRepo;

package/lib/Factory/TaskFactory.d.ts

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