@datatruck/cli 0.26.2 → 0.28.0

package/utils/DataFormat.js

@@ -3,21 +3,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DataFormat = void 0;
+exports.DataFormat = exports.dataFormats = void 0;
 const AppError_1 = require("../Error/AppError");
-const cli_table3_1 = __importDefault(require("cli-table3"));
+const stream_1 = require("./stream");
+const tty_table_1 = __importDefault(require("tty-table"));
 const util_1 = require("util");
+exports.dataFormats = [
+    "json",
+    "list",
+    "pjson",
+    "table",
+    "yaml",
+    "custom",
+    "tpl",
+];
 const customPrefix = "custom=";
 const tplPrefix = "tpl=";
 class DataFormat {
     options;
+    streams;
     constructor(options) {
         this.options = options;
+        this.streams = (0, stream_1.createStreams)(options.streams);
+    }
+    getJson() {
+        return this.options.json;
     }
     formatToJson() {
-        return JSON.stringify(this.options.json
-            ? this.options.items.map(this.options.json)
-            : this.options.items);
+        return JSON.stringify(this.getJson());
     }
     formatToPrettyJson() {
         return (0, util_1.formatWithOptions)({
@@ -27,23 +40,32 @@ class DataFormat {
             maxStringLength: Infinity,
             breakLength: Infinity,
             compact: false,
-        }, this.options.items);
+        }, this.getJson());
     }
     formatToYaml() {
-        return require("yaml").stringify(this.options.items);
+        return require("yaml").stringify(this.getJson());
     }
     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();
+        if (!this.options.table)
+            throw new Error(`Unsupported format: table`);
+        const table = (0, tty_table_1.default)(this.options.table.headers, this.options.table.rows(), {});
+        return table.render();
+    }
+    formatToList() {
+        if (!this.options.list)
+            throw new Error(`Unsupported format: list`);
+        return this.options.list().join("\n");
+    }
+    log(format, options) {
+        this.streams.stdout.write(`${this.format(format, options)}\n`);
     }
     format(format, options) {
         if (format === "table") {
             return this.formatToTable();
         }
+        else if (format === "list") {
+            return this.formatToList();
+        }
         else if (format === "json") {
             return this.formatToJson();
         }
@@ -55,7 +77,7 @@ class DataFormat {
         }
         else if (format.startsWith(customPrefix)) {
             const code = format.slice(customPrefix.length);
-            return runCustomCode(this.options.items, code);
+            return runCustomCode(this.getJson(), code);
         }
         else if (format.startsWith(tplPrefix)) {
             const name = format.slice(tplPrefix.length);

package/utils/cli.d.ts

@@ -1,15 +1,9 @@
 /// <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, subprogress?: number): string;
-export declare function logVars(data: Record<string, any>): void;
 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 function resultColumn(error: Error | null | string | boolean | undefined, color?: boolean): string;
+export declare function errorColumn(error: Error | null | string | undefined, verbose?: number): string;
 export type OptionsType<T1, T2 extends {
     [K in keyof T1]: unknown;
 }> = {
@@ -24,5 +18,4 @@ export type OptionsType<T1, T2 extends {
 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/utils/cli.js

@@ -3,23 +3,11 @@ 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.logVars = exports.renderProgressBar = exports.renderSpinner = exports.hideCursorCommand = exports.clearCommand = exports.showCursorCommand = exports.spinnerChars = exports.clearLastLine = void 0;
+exports.confirm = exports.parseOptions = exports.errorColumn = exports.resultColumn = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = 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, subprogress) {
     if (progress > 100)
         throw new Error(`Invalid progress value: ${progress}`);
@@ -45,18 +33,6 @@ function renderProgressBar(progress, size = 10, subprogress) {
     return (0, chalk_2.cyan)(result);
 }
 exports.renderProgressBar = renderProgressBar;
-function logVars(data) {
-    let first = true;
-    for (const key in data) {
-        if (first) {
-            console.info();
-            first = false;
-        }
-        const value = data[key];
-        console.info(`${chalk_1.default.cyan(key)}${chalk_1.default.grey(":")} ${chalk_1.default.white(value ?? "")}`);
-    }
-}
-exports.logVars = logVars;
 function logExec(command, argv = [], env, logToStderr) {
     const envText = env
         ? Object.keys(env)
@@ -72,8 +48,14 @@ function logExec(command, argv = [], env, logToStderr) {
         : console.info(text);
 }
 exports.logExec = logExec;
-function resultColumn(error, state) {
-    return error ? "❌" : state === "started" ? " ? " : "✅";
+function resultColumn(error, color = true) {
+    return error
+        ? color
+            ? chalk_1.default.red("Χ")
+            : "Χ"
+        : color
+            ? chalk_1.default.green("✓")
+            : "✓";
 }
 exports.resultColumn = resultColumn;
 function errorColumn(error, verbose) {
@@ -107,31 +89,6 @@ function parseOptions(object, options) {
     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,

package/utils/datatruck/client.d.ts

@@ -0,0 +1,24 @@
+import { DiskStats } from "../fs";
+import { AbstractFs, FsOptions } from "../virtual-fs";
+export declare class RemoteFs extends AbstractFs {
+    readonly options: FsOptions;
+    protected url: string;
+    protected headers: Record<string, string>;
+    constructor(options: FsOptions);
+    isLocal(): boolean;
+    protected fetchJson(name: string, params: any[]): Promise<any>;
+    protected post(name: string, params: any[], data: string): Promise<void>;
+    existsDir(path: string): Promise<any>;
+    mkdir(path: string): Promise<any>;
+    readFile(path: string): Promise<any>;
+    readdir(path: string): Promise<any>;
+    readFileIfExists(path: string): Promise<string | undefined>;
+    ensureEmptyDir(path: string): Promise<void>;
+    writeFile(path: string, contents: string): Promise<void>;
+    rmAll(path: string): Promise<void>;
+    fetchDiskStats(path: string): Promise<DiskStats>;
+    upload(source: string, target: string): Promise<void>;
+    download(source: string, target: string, timeout?: number): Promise<void>;
+}
+export declare function isRemoteBackend(backend: string): boolean;
+export declare function createFs(backend: string): AbstractFs;

package/utils/datatruck/client.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createFs = exports.isRemoteBackend = exports.RemoteFs = void 0;
+const http_1 = require("../http");
+const virtual_fs_1 = require("../virtual-fs");
+const server_1 = require("./server");
+class RemoteFs extends virtual_fs_1.AbstractFs {
+    options;
+    url;
+    headers;
+    constructor(options) {
+        super(options);
+        this.options = options;
+        const url = new URL(options.backend);
+        this.headers = {
+            [server_1.headerKey.user]: url.username,
+            [server_1.headerKey.password]: url.password,
+        };
+        url.username = "";
+        url.password = "";
+        this.url = url.href;
+        if (this.url.endsWith("/"))
+            this.url = this.url.slice(0, -1);
+    }
+    isLocal() {
+        return false;
+    }
+    async fetchJson(name, params) {
+        return await (0, http_1.fetchJson)(`${this.url}/${name}`, {
+            headers: this.headers,
+            query: {
+                params: JSON.stringify(params),
+            },
+        });
+    }
+    async post(name, params, data) {
+        return await (0, http_1.post)(`${this.url}/${name}`, data, {
+            headers: this.headers,
+            query: {
+                params: JSON.stringify(params),
+            },
+        });
+    }
+    async existsDir(path) {
+        return await this.fetchJson("existsDir", [path]);
+    }
+    async mkdir(path) {
+        return await this.fetchJson("mkdir", [path]);
+    }
+    async readFile(path) {
+        return await this.fetchJson("readFile", [path]);
+    }
+    async readdir(path) {
+        return await this.fetchJson("readdir", [path]);
+    }
+    async readFileIfExists(path) {
+        return await this.fetchJson("readFileIfExists", [path]);
+    }
+    async ensureEmptyDir(path) {
+        return await this.fetchJson("readdir", [path]);
+    }
+    async writeFile(path, contents) {
+        await this.post("writeFile", [path], contents);
+    }
+    async rmAll(path) {
+        await this.fetchJson("rmAll", [path]);
+    }
+    async fetchDiskStats(path) {
+        return await this.fetchJson("fetchDiskStats", [path]);
+    }
+    async upload(source, target) {
+        await (0, http_1.uploadFile)(`${this.url}/upload`, source, {
+            headers: this.headers,
+            query: {
+                params: JSON.stringify([target]),
+            },
+        });
+    }
+    async download(source, target, timeout = 100000) {
+        await (0, http_1.downloadFile)(`${this.url}/download`, target, {
+            timeout,
+            headers: this.headers,
+            query: {
+                params: JSON.stringify([source]),
+            },
+        });
+    }
+}
+exports.RemoteFs = RemoteFs;
+function isRemoteBackend(backend) {
+    return backend.startsWith("http:") || backend.startsWith("https:");
+}
+exports.isRemoteBackend = isRemoteBackend;
+function createFs(backend) {
+    return isRemoteBackend(backend)
+        ? new RemoteFs({ backend })
+        : new virtual_fs_1.LocalFs({ backend });
+}
+exports.createFs = createFs;

package/utils/datatruck/config.d.ts

@@ -2,6 +2,8 @@ import { ConfigType } from "../../Config/Config";
 import type { PackageConfigType } from "../../Config/PackageConfig";
 import { RepositoryConfigEnabledActionType, RepositoryConfigType } from "../../Config/RepositoryConfig";
 export declare function findRepositoryOrFail(config: ConfigType, repositoryName: string): RepositoryConfigType;
+export declare function findPackageOrFail(config: ConfigType, packageName: string): PackageConfigType;
+export declare function ensureSameRepositoryType(a: RepositoryConfigType, b: RepositoryConfigType): void;
 export declare function filterRepository(repository: RepositoryConfigType, action?: RepositoryConfigEnabledActionType): boolean;
 export declare function filterPackages(config: ConfigType, options: {
     packageNames?: string[];
@@ -31,18 +33,18 @@ export declare const pkgPathParams: {
     [name in "temp" | Exclude<keyof ResolvePackagePathParamsType, "path">]: string;
 };
 export declare const pkgIncludeParams: {
+    action: string;
     packageName: string;
     temp: string;
     snapshotId: string;
     snapshotDate: string;
-    action: string;
 };
 export declare const pkgExcludeParams: {
+    action: string;
     packageName: string;
     temp: string;
     snapshotId: string;
     snapshotDate: string;
-    action: string;
 };
 export declare const pkgRestorePathParams: {
     [name in "temp" | keyof ResolvePackagePathParamsType]: string;
@@ -52,33 +54,33 @@ export declare const dbNameParams: {
 };
 export declare const params: {
     pkgPath: {
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     pkgRestorePath: {
         path: string;
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     pkgInclude: {
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     pkgExclude: {
+        action: string;
         packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
-        action: string;
     };
     dbName: {
         snapshotId: string;

package/utils/datatruck/config.js

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepository = exports.findRepositoryOrFail = void 0;
+exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepository = exports.ensureSameRepositoryType = exports.findPackageOrFail = exports.findRepositoryOrFail = void 0;
 const AppError_1 = require("../../Error/AppError");
-const fs_1 = require("../fs");
 const string_1 = require("../string");
+const temp_1 = require("../temp");
 const micromatch_1 = require("micromatch");
 function findRepositoryOrFail(config, repositoryName) {
     const repo = config.repositories.find((v) => v.name === repositoryName);
@@ -12,6 +12,21 @@ function findRepositoryOrFail(config, repositoryName) {
     return repo;
 }
 exports.findRepositoryOrFail = findRepositoryOrFail;
+function findPackageOrFail(config, packageName) {
+    const pkg = config.packages.find((v) => v.name === packageName);
+    if (!pkg)
+        throw new AppError_1.AppError(`Package '${packageName}' not found`);
+    return pkg;
+}
+exports.findPackageOrFail = findPackageOrFail;
+function ensureSameRepositoryType(a, b) {
+    if (a.type !== b.type) {
+        const names = [a.name, b.name].join(" and ");
+        const types = [a.type, b.type].join(" != ");
+        throw new Error(`Incompatible repository types between ${names} (${types})`);
+    }
+}
+exports.ensureSameRepositoryType = ensureSameRepositoryType;
 function filterRepository(repository, action) {
     const enabled = repository.enabled ?? true;
     if (typeof enabled === "boolean")
@@ -50,7 +65,7 @@ function resolvePackagePath(value, params) {
     return (0, string_1.render)(value, {
         ...params,
         ...{
-            temp: (0, fs_1.tmpDir)("pkg"),
+            temp: (0, temp_1.tmpDir)("pkg"),
         },
     });
 }

package/utils/datatruck/paths.d.ts

@@ -1,21 +1,17 @@
 import { PackageConfigType } from "../../Config/PackageConfig";
-import { SnapshotType } from "../../Repository/RepositoryAbstract";
+import { PreSnapshot } from "../../Repository/RepositoryAbstract";
 import { Step } from "../steps";
 export type ParsePathsOptions = {
     cwd?: string;
     verbose?: boolean;
     vars?: Record<string, any>;
-};
-export declare function parsePaths(values: (string | Step)[], options: {
-    cwd?: string;
-    verbose?: boolean;
-    vars?: Record<string, any>;
     tempDir?: () => Promise<string>;
-}): Promise<string[]>;
+};
+export declare function parsePaths(values: (string | Step)[], options: ParsePathsOptions): Promise<string[]>;
 export type BackupPathsOptions = {
     package: PackageConfigType;
-    snapshot: SnapshotType;
-    targetPath: string;
+    snapshot: PreSnapshot;
+    path: string;
     verbose?: boolean;
 };
 export declare function parseBackupPaths(paths: (string | Step)[], options: BackupPathsOptions): Promise<string[]>;

package/utils/datatruck/paths.js

@@ -21,13 +21,13 @@ async function parsePaths(values, options) {
 exports.parsePaths = parsePaths;
 async function parseBackupPaths(paths, options) {
     return parsePaths(paths, {
-        cwd: options.targetPath,
+        cwd: options.path,
         verbose: options.verbose,
         vars: {
             dtt: {
                 package: options.package,
                 snapshot: options.snapshot,
-                targetPath: options.targetPath,
+                path: options.path,
             },
         },
     });

package/utils/datatruck/server.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="node" />
+import { IncomingMessage } from "http";
+type User = {
+    name: string;
+    password: string;
+};
+export type DatatruckServerOptions = {
+    path?: string;
+    log?: boolean;
+    listen?: {
+        port?: number;
+        address?: string;
+    };
+    users?: User[];
+};
+export declare const headerKey: {
+    user: string;
+    password: string;
+};
+export declare function createDatatruckServer(options: DatatruckServerOptions): import("node:http").Server<typeof IncomingMessage, typeof import("node:http").ServerResponse>;
+export {};

package/utils/datatruck/server.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDatatruckServer = exports.headerKey = void 0;
+const http_1 = require("../http");
+const virtual_fs_1 = require("../virtual-fs");
+const fs_1 = require("fs");
+const http_2 = require("http");
+function parseUrl(inUrl) {
+    const url = new URL(`http://127.0.0.1${inUrl}`);
+    const inParams = url.searchParams.get("params");
+    const action = url.pathname.slice(1);
+    if (typeof inParams === "string") {
+        const params = JSON.parse(inParams);
+        if (!Array.isArray(params))
+            throw new Error(`Invalid params`);
+        return { action, params };
+    }
+    else {
+        return { action, params: [] };
+    }
+}
+exports.headerKey = {
+    user: "x-dtt-user",
+    password: "x-dtt-password",
+};
+function validateRequest(req, users) {
+    const name = req.headers[exports.headerKey.user];
+    const password = req.headers[exports.headerKey.password];
+    return users.some((user) => user.name.length &&
+        user.password.length &&
+        user.name === name &&
+        user.password === password);
+}
+function createDatatruckServer(options) {
+    const log = options.log ?? true;
+    return (0, http_2.createServer)(async (req, res) => {
+        try {
+            if (req.url === "/" || req.url === "/favicon.ico") {
+                return res.end();
+            }
+            else if (!validateRequest(req, options.users || [])) {
+                res.statusCode = 401;
+                return res.end();
+            }
+            if (log)
+                console.info(`> ${req.url}`);
+            const fs = new virtual_fs_1.LocalFs({
+                backend: options.path ?? ".",
+            });
+            const { action, params } = parseUrl(req.url);
+            if (action === "upload") {
+                const [target] = params;
+                const file = (0, fs_1.createWriteStream)(fs.resolvePath(target));
+                req.pipe(file);
+                await new Promise((resolve, reject) => {
+                    req.on("error", reject);
+                    file.on("error", reject);
+                    file.on("close", resolve);
+                });
+            }
+            else if (action === "download") {
+                const [target] = params;
+                const file = (0, fs_1.createReadStream)(fs.resolvePath(target));
+                file.pipe(res);
+                await new Promise((resolve, reject) => {
+                    req.on("error", reject);
+                    file.on("error", reject);
+                    res.on("error", reject);
+                    res.on("close", resolve);
+                });
+            }
+            else if (action === "writeFile") {
+                const data = await (0, http_1.readRequestData)(req);
+                const [target] = params;
+                await fs.writeFile(target, data);
+            }
+            else {
+                const object = fs[action]?.bind(fs);
+                if (!object)
+                    throw new Error(`Invalid action: ${action}`);
+                const json = await object(...params);
+                if (json !== undefined)
+                    res.write(JSON.stringify(json));
+            }
+            res.end();
+            if (log)
+                console.info(`<${action}`);
+        }
+        catch (error) {
+            if (log)
+                console.error(`<${req.url}`, error);
+            res.statusCode = 500;
+        }
+    });
+}
+exports.createDatatruckServer = createDatatruckServer;

package/utils/datatruck/snapshot.d.ts

@@ -1,4 +1,4 @@
 import { SnapshotGroupByType } from "../../Action/SnapshotsAction";
-import { SnapshotResultType } from "../../Repository/RepositoryAbstract";
+import { Snapshot } from "../../Repository/RepositoryAbstract";
 import { FilterByLastOptionsType } from "../date";
-export declare function groupAndFilter<TSnapshot extends SnapshotResultType>(snapshots: TSnapshot[], groupByKey?: SnapshotGroupByType[], filter?: FilterByLastOptionsType | ((groupedSnapshots: TSnapshot[]) => FilterByLastOptionsType), reasons?: Record<number, string[]>): TSnapshot[];
+export declare function groupAndFilter<TSnapshot extends Snapshot>(snapshots: TSnapshot[], groupByKey?: SnapshotGroupByType[], filter?: FilterByLastOptionsType | ((groupedSnapshots: TSnapshot[]) => FilterByLastOptionsType), reasons?: Record<number, string[]>): TSnapshot[];

package/utils/date.d.ts

@@ -10,7 +10,11 @@ export type FilterByLastOptionsType = {
 export declare function filterByLast<TItem extends {
     date: string;
 }>(items: TItem[], options: FilterByLastOptionsType, reasons?: Record<number, string[]>): TItem[];
-export declare function createChron(): {
-    start: () => number;
-    elapsed: (formatted?: boolean) => string | number;
+export type Timer = {
+    reset: (min?: number) => boolean;
+    check: (min: number) => boolean;
+    elapsed: () => number;
+    stop: () => void;
 };
+export declare function createTimer(): Timer;
+export declare function duration(ms: number): string;