@datatruck/cli 0.0.1

package/lib/util/DataFormat.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DataFormat = void 0;
+const cli_table3_1 = __importDefault(require("cli-table3"));
+const util_1 = require("util");
+class DataFormat {
+    constructor(options) {
+        this.options = options;
+    }
+    formatToJson() {
+        return JSON.stringify(this.options.json
+            ? this.options.items.map(this.options.json)
+            : this.options.items);
+    }
+    formatToPrettyJson() {
+        return (0, util_1.formatWithOptions)({
+            colors: true,
+            depth: Infinity,
+        }, this.options.items);
+    }
+    formatToYaml() {
+        return require("yaml").stringify(this.options.items);
+    }
+    formatToTable() {
+        const table = new cli_table3_1.default({
+            head: this.options.table.labels,
+        });
+        for (const item of this.options.items)
+            table.push(this.options.table.handler(item));
+        return table.toString();
+    }
+    format(format) {
+        if (format === "table") {
+            return this.formatToTable();
+        }
+        else if (format === "json") {
+            return this.formatToJson();
+        }
+        else if (format === "pjson") {
+            return this.formatToPrettyJson();
+        }
+        else if (format === "yaml") {
+            return this.formatToYaml();
+        }
+    }
+}
+exports.DataFormat = DataFormat;

package/lib/util/GitUtil.d.ts

@@ -0,0 +1,38 @@
+import { ExecSettingsInterface } from "./process-util";
+export declare class GitUtil {
+    readonly options: {
+        dir: string;
+        log?: boolean;
+    };
+    constructor(options: {
+        dir: string;
+        log?: boolean;
+    });
+    exec(args: string[], settings?: ExecSettingsInterface, cwd?: boolean): Promise<import("./process-util").ExecResultType>;
+    canBeInit(repo: string): Promise<boolean>;
+    clone(options: {
+        repo: string;
+        branch?: string;
+        orphan?: boolean;
+    }): Promise<import("./process-util").ExecResultType>;
+    checkout(options: {
+        branchName: string;
+        orphan?: boolean;
+    }): Promise<import("./process-util").ExecResultType>;
+    checkBranch(options: {
+        name: string;
+        repo?: string;
+    }): Promise<boolean>;
+    removeAll(): Promise<import("./process-util").ExecResultType>;
+    haveChanges(): Promise<boolean>;
+    fetchCommitId(tag: string): Promise<string>;
+    getTags(names?: string[]): Promise<{
+        name: string;
+        message?: string | undefined;
+    }[]>;
+    addTag(name: string, message?: string): Promise<void>;
+    pushTags(): Promise<import("./process-util").ExecResultType>;
+    push(options: {
+        branchName: string;
+    }): Promise<import("./process-util").ExecResultType>;
+}

package/lib/util/GitUtil.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitUtil = void 0;
+const fs_util_1 = require("./fs-util");
+const process_util_1 = require("./process-util");
+const fs_extra_1 = require("fs-extra");
+class GitUtil {
+    constructor(options) {
+        this.options = options;
+    }
+    async exec(args, settings, cwd) {
+        return await (0, process_util_1.exec)("git", args, { cwd: cwd === false ? undefined : this.options.dir }, {
+            log: this.options.log,
+            ...(settings ?? {}),
+        });
+    }
+    async canBeInit(repo) {
+        return ((0, fs_util_1.isLocalDir)(repo) &&
+            (!(await (0, fs_util_1.checkDir)(repo)) || !(await (0, fs_extra_1.readdir)(repo)).length));
+    }
+    async clone(options) {
+        return await this.exec([
+            "clone",
+            ...(/^\w+\:\/\//.test(options.repo) ? ["--depth=1"] : []),
+            ...(options.orphan ? ["--orphan"] : []),
+            ...(options.branch ? ["--branch", options.branch] : []),
+            "--config",
+            "core.autocrlf=false",
+            options.repo,
+            ".",
+        ]);
+    }
+    async checkout(options) {
+        return await this.exec([
+            "checkout",
+            ...(options.orphan ? ["--orphan"] : []),
+            options.branchName,
+        ]);
+    }
+    async checkBranch(options) {
+        const result = await this.exec([
+            "ls-remote",
+            "--exit-code",
+            ...(options.repo ? [options.repo] : ["--heads", "origin"]),
+        ], {
+            stdout: { save: true },
+            onExitCodeError: () => false,
+        }, options.repo ? false : true);
+        return result.stdout
+            .split(/\r?\n/g)
+            .some((line) => line.endsWith(`refs/heads/${options.name}`));
+    }
+    async removeAll() {
+        return await this.exec(["rm", "--force", "--ignore-unmatch", "*"]);
+    }
+    async haveChanges() {
+        const statusResult = await this.exec(["status", "-s"], {
+            stdout: { save: true },
+        });
+        return !!statusResult.stdout.trim().length;
+    }
+    async fetchCommitId(tag) {
+        return (await this.exec(["rev-list", "-n", "1", tag], { stdout: { save: true } })).stdout?.trim();
+    }
+    async getTags(names) {
+        const result = await this.exec(["tag", "-n", ...(names ?? [])], {
+            stdout: { save: true },
+        });
+        return result.stdout.split(/\r?\n/).reduce((result, value) => {
+            value = value.trim();
+            if (!value.length)
+                return result;
+            let separatorIndex = value.indexOf(" ");
+            if (separatorIndex === -1)
+                separatorIndex = value.length;
+            const name = value.slice(0, separatorIndex);
+            const message = value.slice(separatorIndex + 1);
+            result.push({
+                name: name,
+                message: message ?? null,
+            });
+            return result;
+        }, []);
+    }
+    async addTag(name, message) {
+        if (message) {
+            await this.exec(["tag", "-a", name, "-m", message]);
+        }
+        else {
+            await this.exec(["tag", name]);
+        }
+    }
+    async pushTags() {
+        return await this.exec(["push", "--tags"]);
+    }
+    async push(options) {
+        return await this.exec([
+            "push",
+            "--progress",
+            "origin",
+            options.branchName,
+        ]);
+    }
+}
+exports.GitUtil = GitUtil;

package/lib/util/ObjectVault.d.ts

@@ -0,0 +1,13 @@
+export declare type KeysType = (string | number)[];
+export declare class ObjectVault<TObject> {
+    protected counter: number;
+    protected readonly ids: Record<string, number>;
+    protected readonly objects: Record<number, TObject>;
+    static serializeKeys(keys: KeysType): string;
+    get(id: number): TObject;
+    getId(keys: KeysType): number;
+    add(options: {
+        keys: KeysType;
+        handler: (id: number) => TObject;
+    }): TObject;
+}

package/lib/util/ObjectVault.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ObjectVault = void 0;
+class ObjectVault {
+    constructor() {
+        this.counter = 0;
+        this.ids = {};
+        this.objects = {};
+    }
+    static serializeKeys(keys) {
+        return JSON.stringify(keys);
+    }
+    get(id) {
+        if (!(id in this.objects))
+            throw new Error(`Object not found: ${id}`);
+        return this.objects[id];
+    }
+    getId(keys) {
+        const key = ObjectVault.serializeKeys(keys);
+        const id = this.ids[key];
+        if (!id)
+            throw new Error(`Id not found: ${JSON.stringify(keys)}`);
+        return id;
+    }
+    add(options) {
+        const key = ObjectVault.serializeKeys(options.keys);
+        const id = (this.ids[key] = ++this.counter);
+        return (this.objects[id] = options.handler(id));
+    }
+}
+exports.ObjectVault = ObjectVault;

package/lib/util/ResticUtil.d.ts

@@ -0,0 +1,92 @@
+import { ExecSettingsInterface } from "./process-util";
+import { UriType } from "./string-util";
+export declare type RepositoryType = {
+    name?: string;
+    env?: Record<string, string>;
+    passwordFile?: string;
+    backend: "local" | "rest" | "sftp" | "s3" | "azure" | "gs" | "rclone";
+} & UriType;
+export declare type BackupStreamType = {
+    message_type: "status";
+    seconds_elapsed: number;
+    percent_done: number;
+    total_files: number;
+    files_done?: number;
+    total_bytes: number;
+    bytes_done?: number;
+    current_files?: string[];
+} | {
+    message_type: "summary";
+    files_new: number;
+    files_changed: number;
+    files_unmodified: number;
+    dirs_new: number;
+    dirs_changed: number;
+    dirs_unmodified: number;
+    data_blobs: number;
+    tree_blobs: number;
+    data_added: number;
+    total_files_processed: number;
+    total_bytes_processed: number;
+    total_duration: number;
+    snapshot_id: string;
+};
+export declare class ResticUtil {
+    readonly options: {
+        log?: boolean;
+        env: Record<string, string>;
+    };
+    constructor(options: {
+        log?: boolean;
+        env: Record<string, string>;
+    });
+    static formatRepository(input: RepositoryType, hidePassword?: boolean): Promise<string>;
+    exec(args: string[], settings?: ExecSettingsInterface, options?: {
+        cwd?: string;
+    }): Promise<import("./process-util").ExecResultType>;
+    checkRepository(): Promise<boolean>;
+    forget(options: {
+        snapshotId?: string;
+        keepLast?: number;
+        keepHourly?: number;
+        keepDaily?: number;
+        keepWeekly?: number;
+        keepMonthly?: number;
+        keepYearly?: number;
+        keepWithin?: string;
+        keepTag?: string[];
+        tag?: string[];
+        prune?: boolean;
+    }): Promise<string>;
+    snapshots(options: {
+        tags?: string[];
+        paths?: string[];
+        latest?: number;
+        json?: boolean;
+    }): Promise<{
+        time: string;
+        tree: string;
+        paths: string[];
+        tags?: string[];
+        hostname: string;
+        username: string;
+        excludes: string[];
+        id: string;
+        short_id: string;
+    }[]>;
+    checkBackupSetPathSupport(): Promise<boolean>;
+    backup(options: {
+        cwd?: string;
+        tags?: string[];
+        paths: string[];
+        setPaths?: string[];
+        exclude?: string[];
+        parent?: string;
+        onStream?: (data: BackupStreamType) => Promise<void>;
+    }): Promise<import("./process-util").ExecResultType>;
+    restore(options: {
+        id: string;
+        target: string;
+        onStream?: (data: BackupStreamType) => Promise<void>;
+    }): Promise<import("./process-util").ExecResultType>;
+}

package/lib/util/ResticUtil.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ResticUtil = void 0;
+const process_util_1 = require("./process-util");
+const string_util_1 = require("./string-util");
+const fs_extra_1 = require("fs-extra");
+const path_1 = require("path");
+class ResticUtil {
+    constructor(options) {
+        this.options = options;
+    }
+    static async formatRepository(input, hidePassword) {
+        if (input.backend === "local") {
+            if (typeof input.path !== "string")
+                throw new Error(`Invalid path at "${input.name}" repository: ${input.path}`);
+            return (0, path_1.normalize)(input.path);
+        }
+        if (input.passwordFile)
+            input = {
+                ...input,
+                password: (await (0, fs_extra_1.readFile)(input.passwordFile)).toString(),
+            };
+        return `${input.backend}:${(0, string_util_1.formatUri)(input, hidePassword)}`;
+    }
+    async exec(args, settings, options) {
+        return await (0, process_util_1.exec)("restic", args, {
+            stdio: ["ignore", "pipe", "pipe"],
+            env: { ...this.options.env },
+            cwd: options?.cwd,
+        }, {
+            stderr: { toExitCode: true },
+            log: this.options.log
+                ? {
+                    exec: true,
+                    stdout: true,
+                    stderr: true,
+                    colorize: true,
+                    allToStderr: true,
+                    envNames: ["RESTIC_REPOSITORY"],
+                }
+                : {},
+            ...(settings ?? {}),
+        });
+    }
+    async checkRepository() {
+        const result = await this.exec(["cat", "config"], {
+            onExitCodeError: () => false,
+        });
+        return result.exitCode === 0;
+    }
+    async forget(options) {
+        const result = await this.exec([
+            "forget",
+            ...(options.keepLast ? ["--keep-last", options.keepLast.toString()] : []),
+            ...(options.keepHourly
+                ? ["--keep-hourly", options.keepHourly.toString()]
+                : []),
+            ...(options.keepDaily
+                ? ["--keep-daily", options.keepDaily.toString()]
+                : []),
+            ...(options.keepWeekly
+                ? ["--keep-weekly", options.keepWeekly.toString()]
+                : []),
+            ...(options.keepMonthly
+                ? ["--keep-monthly", options.keepMonthly.toString()]
+                : []),
+            ...(options.keepYearly
+                ? ["--keep-yearly", options.keepYearly.toString()]
+                : []),
+            ...(options.keepWithin
+                ? ["--keep-within", options.keepWithin.toString()]
+                : []),
+            ...(options.keepTag
+                ? options.keepTag.flatMap((v) => ["--keepTag", v])
+                : []),
+            ...(options.tag ? options.tag.flatMap((v) => ["--tag", v]) : []),
+            ...(options.prune ? ["--prune"] : []),
+            ...(options.snapshotId ? [options.snapshotId] : []),
+        ]);
+        return result.stdout;
+    }
+    async snapshots(options) {
+        const result = await this.exec([
+            "snapshots",
+            ...(options.tags?.flatMap((tag) => [`--tag`, tag]) ?? []),
+            ...(options.json ? ["--json"] : []),
+            ...(options.paths?.flatMap((path) => ["--path", path]) ?? []),
+            ...(options.latest ? ["--latest", options.latest.toString()] : []),
+        ], {
+            stdout: { save: true },
+        });
+        return JSON.parse(result.stdout);
+    }
+    async checkBackupSetPathSupport() {
+        const result = await this.exec(["backup", "--set-path"], {
+            onExitCodeError: () => false,
+            stderr: { save: true },
+        });
+        return result.stderr.includes("flag needs an argument");
+    }
+    async backup(options) {
+        return await this.exec([
+            "backup",
+            "--json",
+            ...(options.exclude?.flatMap((v) => ["-e", v]) ?? []),
+            ...(options.tags?.flatMap((v) => ["--tag", v]) ?? []),
+            ...(options.setPaths?.flatMap((v) => ["--set-path", v]) ?? []),
+            ...(options.parent ? ["--parent", options.parent] : []),
+            ...options.paths,
+        ], {
+            stderr: {
+                toExitCode: true,
+            },
+            stdout: {
+                ...(options.onStream && {
+                    onData: async (data) => {
+                        if (data.startsWith("{") && data.endsWith("}")) {
+                            await options.onStream?.(JSON.parse(data));
+                        }
+                    },
+                }),
+            },
+        }, {
+            cwd: options.cwd,
+        });
+    }
+    async restore(options) {
+        return await this.exec(["restore", "--json", options.id, "--target", options.target], {
+            stderr: {
+                toExitCode: true,
+            },
+            stdout: {
+                ...(options.onStream && {
+                    onData: async (data) => {
+                        if (data.startsWith("{") && data.endsWith("}")) {
+                            await options.onStream?.(JSON.parse(data));
+                        }
+                    },
+                }),
+            },
+        });
+    }
+}
+exports.ResticUtil = ResticUtil;

package/lib/util/cli-util.d.ts

@@ -0,0 +1,27 @@
+/// <reference types="node" />
+export declare function clearLastLine(): void;
+export declare const spinnerChars: string[];
+export declare const showCursorCommand = "\u001B[?25h";
+export declare const clearCommand = "\r\u001B[K";
+export declare const hideCursorCommand = "\u001B[?25l";
+export declare function renderSpinner(counter: number): string;
+export declare function renderProgressBar(progress: number, size?: number): string;
+export declare function logExec(command: string, argv?: string[], env?: NodeJS.ProcessEnv, logToStderr?: boolean): void;
+export declare function resultColumn(error: Error | null | string, state?: "started" | "ended"): "❌" | " ? " | "✅";
+export declare function errorColumn(error: Error | null | string, verbose: number): string;
+export declare type OptionsType<T1, T2 extends {
+    [K in keyof T1]: unknown;
+}> = {
+    [K in keyof Required<T1>]: {
+        option: string;
+        description: string;
+        required?: boolean;
+        defaults?: Exclude<T1[K], undefined>;
+        parser?: (value: Exclude<T1[K], undefined>) => Exclude<T2[K], undefined>;
+    };
+};
+export declare function parseOptions<T1, T2 extends {
+    [K in keyof T1]: unknown;
+}>(object: T1, options: OptionsType<T1, T2>): T2;
+export declare function truncate(text: string, limit: number): [string, boolean];
+export declare function confirm(message: string): Promise<unknown>;

package/lib/util/cli-util.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirm = exports.truncate = exports.parseOptions = exports.errorColumn = exports.resultColumn = exports.logExec = exports.renderProgressBar = exports.renderSpinner = exports.hideCursorCommand = exports.clearCommand = exports.showCursorCommand = exports.spinnerChars = exports.clearLastLine = void 0;
+const chalk_1 = __importDefault(require("chalk"));
+const chalk_2 = require("chalk");
+const readline_1 = require("readline");
+function clearLastLine() {
+    process.stdout.moveCursor(0, -1);
+    process.stdout.clearLine(1);
+}
+exports.clearLastLine = clearLastLine;
+exports.spinnerChars = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+exports.showCursorCommand = "\u001B[?25h";
+exports.clearCommand = "\r\x1b[K";
+exports.hideCursorCommand = "\x1B[?25l";
+function renderSpinner(counter) {
+    return exports.spinnerChars[counter % (exports.spinnerChars.length - 1)];
+}
+exports.renderSpinner = renderSpinner;
+function renderProgressBar(progress, size = 10) {
+    const completeChar = "\u2588";
+    const incompleteChar = "\u2591";
+    const completedSize = Math.round((progress * size) / 100);
+    const restSize = Math.max(size - completedSize, 0);
+    return completeChar.repeat(completedSize) + incompleteChar.repeat(restSize);
+}
+exports.renderProgressBar = renderProgressBar;
+function logExec(command, argv = [], env, logToStderr) {
+    const envText = env
+        ? Object.keys(env)
+            .reduce((items, key) => {
+            items.push(`${chalk_1.default.cyan(key)}${chalk_1.default.grey("=")}${chalk_1.default.white(env[key] ?? "")}`);
+            return items;
+        }, [])
+            .join(" ")
+        : "";
+    const text = `+ ${envText ? envText + " " : ""}${chalk_1.default.yellow(`${command} ${argv.join(" ")}`)}`;
+    logToStderr ? process.stderr.write(`${text}\n`) : console.info(text);
+}
+exports.logExec = logExec;
+function resultColumn(error, state) {
+    return error ? "❌" : state === "started" ? " ? " : "✅";
+}
+exports.resultColumn = resultColumn;
+function errorColumn(error, verbose) {
+    let message = null;
+    if (typeof error === "string") {
+        message = error;
+    }
+    else if (error) {
+        message = error.message;
+    }
+    else {
+        return "";
+    }
+    if (!verbose) {
+        message = message.split(/\r?\n/).shift() ?? "";
+    }
+    return chalk_1.default.red(message.trim());
+}
+exports.errorColumn = errorColumn;
+function parseOptions(object, options) {
+    const result = {};
+    for (const key in options) {
+        const value = object?.[key] ?? options[key].defaults;
+        const parser = options[key].parser;
+        if (typeof value !== "undefined") {
+            result[key] = parser ? parser(value) : value;
+        }
+    }
+    return result;
+}
+exports.parseOptions = parseOptions;
+function truncate(text, limit) {
+    let inColor = false;
+    let visibleLength = 0;
+    if (limit >= text.length)
+        return [text, false];
+    for (let index = 0; index < text.length; ++index) {
+        const c = text[index];
+        if (c === "\x1B") {
+            inColor = true;
+        }
+        else if (inColor) {
+            if (c === "m") {
+                inColor = false;
+            }
+        }
+        else {
+            visibleLength++;
+        }
+        if (visibleLength === limit) {
+            return [text.slice(0, index) + (inColor ? `\x1B[39m` : ""), true];
+        }
+    }
+    return [text, false];
+}
+exports.truncate = truncate;
+function confirm(message) {
+    const rl = (0, readline_1.createInterface)({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    let result = false;
+    return new Promise((resolve) => {
+        rl.question(`${(0, chalk_2.cyan)("?")} ${message} ${(0, chalk_2.grey)("(y/N)")}: `, function (answer) {
+            result = /^\s*y(es)?\s*$/i.test(answer);
+            rl.close();
+        });
+        rl.on("close", () => {
+            resolve(result);
+        });
+    });
+}
+exports.confirm = confirm;

package/lib/util/datatruck/config-util.d.ts

@@ -0,0 +1,55 @@
+import { ConfigType } from "../../Config/Config";
+import type { PackageConfigType } from "../../Config/PackageConfig";
+export declare function findRepositoryOrFail(config: ConfigType, repositoryName: string): import("../../Config/RepositoryConfig").RepositoryConfigType;
+export declare function filterPackages(config: ConfigType, options: {
+    packageNames?: string[];
+    repositoryNames?: string[];
+    repositoryTypes?: string[];
+}): PackageConfigType[];
+declare type ResolvePackagePathParamsType = ResolvePackageParamsType & {
+    packageName: string;
+    path: string | undefined;
+};
+export declare function resolvePackagePath(value: string, params: ResolvePackagePathParamsType): string;
+declare type ResolveDatabaseNameParamsType = ResolvePackageParamsType & {
+    packageName: string;
+    database: string | undefined;
+};
+export declare function resolveDatabaseName(value: string, params: ResolveDatabaseNameParamsType): string;
+declare type ResolvePackageParamsType = {
+    snapshotId: string;
+    action: "backup" | "restore";
+};
+export declare function resolvePackage(pkg: PackageConfigType, params: ResolvePackageParamsType): PackageConfigType;
+export declare function resolvePackages(packages: PackageConfigType[], params: ResolvePackageParamsType): PackageConfigType[];
+export declare const pkgPathParams: {
+    [name in "temp" | Exclude<keyof ResolvePackagePathParamsType, "path">]: string;
+};
+export declare const pkgRestorePathParams: {
+    [name in "temp" | keyof ResolvePackagePathParamsType]: string;
+};
+export declare const dbNameParams: {
+    [name in keyof ResolveDatabaseNameParamsType]: string;
+};
+export declare const params: {
+    pkgPath: {
+        packageName: string;
+        temp: string;
+        snapshotId: string;
+        action: string;
+    };
+    pkgRestorePath: {
+        packageName: string;
+        path: string;
+        temp: string;
+        snapshotId: string;
+        action: string;
+    };
+    dbName: {
+        snapshotId: string;
+        action: string;
+        packageName: string;
+        database: string;
+    };
+};
+export {};