@datatruck/cli 0.32.1 → 0.32.2

package/JsonSchema/copy-def.d.ts

@@ -1,24 +0,0 @@
-export declare const copyCommandOptionsDef: {
-    type: "object";
-    additionalProperties: false;
-    properties: {
-        id: {
-            type: "string";
-        };
-        last: {
-            type: "integer";
-        };
-        package: {
-            type: "string";
-        };
-        packageTask: {
-            type: "string";
-        };
-        repository: {
-            type: "string";
-        };
-        repository2: {
-            type: "string";
-        };
-    };
-};

package/JsonSchema/copy-def.js

@@ -1,15 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.copyCommandOptionsDef = void 0;
-exports.copyCommandOptionsDef = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        id: { type: "string" },
-        last: { type: "integer" },
-        package: { type: "string" },
-        packageTask: { type: "string" },
-        repository: { type: "string" },
-        repository2: { type: "string" },
-    },
-};

package/Repository/GitRepository.d.ts

@@ -1,31 +0,0 @@
-import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, SnapshotTagEnum, SnapshotTagObjectType, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
-import { JSONSchema7 } from "json-schema";
-export type GitRepositoryConfigType = {
-    repo: string;
-    branch?: string;
-};
-export type GitPackageRepositoryConfigType = {};
-export declare const gitRepositoryName = "git";
-export declare const gitRepositoryDefinition: JSONSchema7;
-export declare const gitPackageRepositoryDefinition: JSONSchema7;
-export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfigType> {
-    static refPrefix: string;
-    getSource(): string;
-    fetchDiskStats(config: GitRepositoryConfigType): Promise<import("../utils/fs").DiskStats | undefined>;
-    static buildSnapshotTagName(tag: Pick<SnapshotTagObjectType, SnapshotTagEnum.PACKAGE | SnapshotTagEnum.ID>): string;
-    static buildSnapshotTag(tag: SnapshotTagObjectType): {
-        name: string;
-        message: string;
-    };
-    static isSnapshotTag(name: string): boolean;
-    static parseSnapshotTag(name: string, message: string): (Omit<SnapshotTagObjectType, "tags"> & {
-        tags: string[];
-    }) | null;
-    static buildBranchName(packageName: string): string;
-    init(data: RepoInitData): Promise<void>;
-    prune(data: RepoPruneData): Promise<void>;
-    fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
-    backup(data: RepoBackupData<GitPackageRepositoryConfigType>): Promise<void>;
-    copy(data: RepoCopyData<GitRepositoryConfigType>): Promise<void>;
-    restore(data: RepoRestoreData<GitPackageRepositoryConfigType>): Promise<void>;
-}

package/Task/ScriptTask.d.ts

@@ -1,38 +0,0 @@
-import { PackageConfigType } from "../Config/PackageConfig";
-import { PreSnapshot } from "../Repository/RepositoryAbstract";
-import { Step } from "../utils/steps";
-import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
-import { JSONSchema7 } from "json-schema";
-type NodeVars = {
-    dtt: {
-        snapshot: PreSnapshot;
-        package: PackageConfigType;
-        snapshotPath: string;
-    };
-};
-export type ScriptTaskConfigType = {
-    env?: Record<string, string | undefined>;
-    backupSteps: Step[];
-    restoreSteps: Step[];
-};
-export declare function scriptTaskCode<V extends Record<string, any>>(cb: (vars: NodeVars & V) => void): string;
-export declare enum ScriptTaskDefinitionEnum {
-    step = "step",
-    processStepConfig = "processStepConfig",
-    nodeStepConfig = "nodeStepConfig",
-    telegramMessageStepConfig = "telegramMessageStepConfig",
-    ntfyStepConfig = "ntfyStepConfig"
-}
-export declare const scriptTaskName = "script";
-export declare const scriptTaskDefinition: JSONSchema7;
-export declare class ScriptTask extends TaskAbstract<ScriptTaskConfigType> {
-    protected verbose?: boolean;
-    backup(data: TaskBackupData): Promise<{
-        snapshotPath: string;
-    }>;
-    prepareRestore(data: TaskPrepareRestoreData): Promise<{
-        snapshotPath: string;
-    }>;
-    restore(data: TaskRestoreData): Promise<void>;
-}
-export {};

package/Task/ScriptTask.js

@@ -1,163 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScriptTask = exports.scriptTaskDefinition = exports.scriptTaskName = exports.ScriptTaskDefinitionEnum = exports.scriptTaskCode = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-const steps_1 = require("../utils/steps");
-const temp_1 = require("../utils/temp");
-const TaskAbstract_1 = require("./TaskAbstract");
-function scriptTaskCode(cb) {
-    return `(${cb.toString()})(...arguments);`;
-}
-exports.scriptTaskCode = scriptTaskCode;
-var ScriptTaskDefinitionEnum;
-(function (ScriptTaskDefinitionEnum) {
-    ScriptTaskDefinitionEnum["step"] = "step";
-    ScriptTaskDefinitionEnum["processStepConfig"] = "processStepConfig";
-    ScriptTaskDefinitionEnum["nodeStepConfig"] = "nodeStepConfig";
-    ScriptTaskDefinitionEnum["telegramMessageStepConfig"] = "telegramMessageStepConfig";
-    ScriptTaskDefinitionEnum["ntfyStepConfig"] = "ntfyStepConfig";
-})(ScriptTaskDefinitionEnum || (exports.ScriptTaskDefinitionEnum = ScriptTaskDefinitionEnum = {}));
-const stepTypes = {
-    process: ScriptTaskDefinitionEnum.processStepConfig,
-    node: ScriptTaskDefinitionEnum.nodeStepConfig,
-    "telegram-message": ScriptTaskDefinitionEnum.telegramMessageStepConfig,
-    ntfy: ScriptTaskDefinitionEnum.ntfyStepConfig,
-};
-exports.scriptTaskName = "script";
-exports.scriptTaskDefinition = {
-    definitions: {
-        step: {
-            type: "object",
-            required: ["type"],
-            properties: {
-                type: { enum: Object.keys(stepTypes) },
-                config: {},
-            },
-            anyOf: Object.keys(stepTypes).map((name) => ({
-                if: {
-                    type: "object",
-                    properties: {
-                        type: { const: name },
-                    },
-                },
-                then: {
-                    type: "object",
-                    properties: {
-                        config: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, stepTypes[name]),
-                    },
-                },
-                else: false,
-            })),
-        },
-        processStepConfig: {
-            type: "object",
-            required: ["command"],
-            properties: {
-                command: { type: "string" },
-                env: {
-                    type: "object",
-                    patternProperties: { ".+": { type: "string" } },
-                },
-                args: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-            },
-        },
-        nodeStepConfig: {
-            type: "object",
-            required: ["code"],
-            properties: {
-                code: {
-                    anyOf: [{ type: "string" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil)],
-                },
-                vars: {
-                    type: "object",
-                    patternProperties: { ".+": {} },
-                },
-                env: {
-                    type: "object",
-                    patternProperties: { ".+": { type: "string" } },
-                },
-            },
-        },
-        telegramMessageStepConfig: {
-            type: "object",
-            required: ["bot", "chatId"],
-            properties: {
-                command: { type: "string" },
-                chatId: { type: "integer" },
-                text: { type: "string" },
-            },
-        },
-        ntfyStepConfig: {
-            type: "object",
-            required: ["token"],
-            properties: {
-                token: { type: "string" },
-                topic: { type: "string" },
-                text: { type: "string" },
-            },
-        },
-    },
-    type: "object",
-    additionalProperties: false,
-    required: ["backupSteps", "restoreSteps"],
-    properties: {
-        env: {
-            type: "object",
-            patternProperties: {
-                ".+": { type: "string" },
-            },
-        },
-        backupSteps: {
-            type: "array",
-            items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, ScriptTaskDefinitionEnum.step),
-        },
-        restoreSteps: {
-            type: "array",
-            items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, ScriptTaskDefinitionEnum.step),
-        },
-    },
-};
-class ScriptTask extends TaskAbstract_1.TaskAbstract {
-    verbose;
-    async backup(data) {
-        const config = this.config;
-        const snapshotPath = data.package.path ??
-            (await (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "backup", "snapshot"));
-        await (0, steps_1.runSteps)(config.backupSteps, {
-            env: config.env,
-            vars: {
-                dtt: {
-                    snapshot: data.snapshot,
-                    snapshotPath: snapshotPath,
-                    package: data.package,
-                },
-            },
-            cwd: snapshotPath,
-            verbose: data.options.verbose,
-            tempDir: () => (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "backup", "nodeStep"),
-        });
-        return { snapshotPath };
-    }
-    async prepareRestore(data) {
-        return {
-            snapshotPath: data.package.restorePath ??
-                (await (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "restore", "snapshot")),
-        };
-    }
-    async restore(data) {
-        const config = this.config;
-        await (0, steps_1.runSteps)(config.restoreSteps, {
-            env: config.env,
-            vars: {
-                dtt: {
-                    snapshot: data.snapshot,
-                    snapshotPath: data.snapshotPath,
-                    package: data.package,
-                },
-            },
-            verbose: data.options.verbose,
-            tempDir: () => (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "restore", "nodeStep"),
-        });
-    }
-}
-exports.ScriptTask = ScriptTask;

package/cli.d.ts

@@ -1,4 +0,0 @@
-import { OptionsMapType } from "./Factory/CommandFactory";
-export declare function buildArgs<TCommand extends keyof OptionsMapType>(input: TCommand, options: OptionsMapType[TCommand]): any[];
-export declare function parseArgs(args: string[]): void;
-export declare function exec<TCommand extends keyof OptionsMapType>(input: TCommand, options: OptionsMapType[TCommand]): Promise<void>;

package/index.d.ts

@@ -1 +0,0 @@
-export {};

package/utils/datatruck/paths.d.ts

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

package/utils/path.d.ts

@@ -1 +0,0 @@
-export declare const rootPath: string;

package/utils/path.js

@@ -1,8 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rootPath = void 0;
-const path_1 = require("path");
-const fromSrc = __filename.endsWith(".ts");
-exports.rootPath = fromSrc
-    ? (0, path_1.normalize)(`${__dirname}/../../`)
-    : (0, path_1.normalize)(`${__dirname}/../`);

package/utils/schema.d.ts

@@ -1,34 +0,0 @@
-import { JSONSchema7 } from "json-schema";
-export declare function omitPropertySchema<T extends {
-    properties: Record<string, any>;
-}, N extends keyof T["properties"]>(object: T, name: N): Omit<T, "properties"> & {
-    properties: Omit<T["properties"], N>;
-};
-type IfSchema<KType extends string, KValue extends string, T extends string, V extends JSONSchema7> = {
-    if: {
-        type: "object";
-        properties: {
-            [k in KType]: {
-                const: T;
-            };
-        };
-    };
-    then: {
-        type: "object";
-        properties: {
-            [k in KValue]: V;
-        };
-    };
-    else: false;
-};
-export declare function createCaseSchema<KType extends string, KValue extends string, V extends {
-    [K in KType]: JSONSchema7;
-}>(keys: {
-    type: KType;
-    value: KValue;
-}, value: V): IfSchema<KType, KValue, string, JSONSchema7>[];
-export declare function createIfSchema<KType extends string, KValue extends string, T extends string, V extends JSONSchema7>(keys: {
-    type: KType;
-    value: KValue;
-}, type: T, value: V): IfSchema<KType, KValue, T, V>;
-export {};

package/utils/schema.js

@@ -1,36 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createIfSchema = exports.createCaseSchema = exports.omitPropertySchema = void 0;
-const object_1 = require("./object");
-function omitPropertySchema(object, name) {
-    return {
-        ...object,
-        properties: (0, object_1.omitProp)(object.properties, name),
-    };
-}
-exports.omitPropertySchema = omitPropertySchema;
-function createCaseSchema(keys, value) {
-    return Object.entries(value).reduce((schemas, [type, value]) => {
-        schemas.push(createIfSchema(keys, type, value));
-        return schemas;
-    }, []);
-}
-exports.createCaseSchema = createCaseSchema;
-function createIfSchema(keys, type, value) {
-    return {
-        if: {
-            type: "object",
-            properties: {
-                [keys.type]: { const: type },
-            },
-        },
-        then: {
-            type: "object",
-            properties: {
-                [keys.value]: value,
-            },
-        },
-        else: false,
-    };
-}
-exports.createIfSchema = createIfSchema;

package/utils/steps.d.ts

@@ -1,43 +0,0 @@
-export type StepEnv = Record<string, string>;
-export type ProcessStepConfig = {
-    command: string;
-    env?: StepEnv;
-    args?: string[];
-};
-export type NodeStepConfig = {
-    env?: StepEnv;
-    vars?: Record<string, any>;
-    code: string | string[];
-};
-export type TelegramMessageStepConfig = {
-    bot: string;
-    chatId: number;
-    text?: string;
-};
-export type NtfyStepConfig = {
-    token: string;
-    topic?: string;
-    text?: string;
-};
-export type Step = {
-    type: "process";
-    config: ProcessStepConfig;
-} | {
-    type: "node";
-    config: NodeStepConfig;
-} | {
-    type: "telegram-message";
-    config: TelegramMessageStepConfig;
-} | {
-    type: "ntfy";
-    config: NtfyStepConfig;
-};
-export type StepOptions = {
-    env?: Record<string, string | undefined>;
-    vars?: Record<string, any>;
-    cwd?: string;
-    tempDir?: () => Promise<string>;
-    onLine?: (p: string) => any;
-    verbose?: boolean;
-};
-export declare function runSteps(input: Step[] | Step, options: StepOptions): Promise<void>;

package/utils/steps.js

@@ -1,97 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.runSteps = void 0;
-const http_1 = require("./http");
-const process_1 = require("./process");
-const string_1 = require("./string");
-const temp_1 = require("./temp");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
-async function runSteps(input, options) {
-    const steps = Array.isArray(input) ? input : [input];
-    const vars = options?.vars || {};
-    for (const step of steps) {
-        if (step.type === "process") {
-            await (0, process_1.exec)(step.config.command, (step.config.args || []).map((v) => (0, string_1.render)(v, vars)), {
-                cwd: options.cwd,
-                env: {
-                    ...process.env,
-                    ...options.env,
-                    ...step.config.env,
-                },
-            }, {
-                log: options.verbose,
-                ...(options.onLine && {
-                    stdout: {
-                        parseLines: "skip-empty",
-                        onData: (line) => options.onLine(line),
-                    },
-                }),
-            });
-        }
-        else if (step.type === "node") {
-            let tempDir;
-            if (options?.tempDir) {
-                tempDir = await options.tempDir();
-            }
-            else {
-                tempDir = await (0, temp_1.mkTmpDir)("node-step");
-            }
-            const scriptPath = (0, path_1.join)(tempDir, "script.js");
-            const nodeVars = {
-                ...step.config.vars,
-                ...vars,
-            };
-            const varKeys = Object.keys(nodeVars);
-            const varJson = JSON.stringify(nodeVars);
-            const code = Array.isArray(step.config.code)
-                ? [...step.config.code].join(";\n")
-                : step.config.code;
-            await (0, promises_1.writeFile)(scriptPath, `(async function({ ${varKeys} }) {\n${code};\n})(${varJson});`);
-            await (0, process_1.exec)("node", [scriptPath], {
-                cwd: options.cwd,
-                env: {
-                    ...process.env,
-                    ...options.env,
-                    ...step.config.env,
-                },
-            }, {
-                log: options.verbose,
-                ...(options.onLine && {
-                    stdout: {
-                        parseLines: "skip-empty",
-                        onData: (line) => options.onLine(line),
-                    },
-                }),
-            });
-        }
-        else if (step.type === "telegram-message") {
-            await (0, http_1.post)(`https://api.telegram.org/bot${step.config.bot}/sendMessage`, JSON.stringify({
-                chat_id: step.config.chatId.toString(),
-                text: (0, string_1.render)(step.config.text ?? `{dtt.text}`, vars),
-                disable_notification: true,
-            }), {
-                headers: {
-                    "Content-Type": "application/json",
-                },
-            });
-        }
-        else if (step.type === "ntfy") {
-            const topic = [step.config.token, step.config.topic]
-                .filter(Boolean)
-                .join("-");
-            if (topic.length < 32)
-                throw new Error(`Topic is less than 32 characters: ${topic}`);
-            await (0, http_1.post)(`https://ntfy.sh/${topic}`, (0, string_1.render)(step.config.text ?? `{dtt.text}`, vars), {
-                headers: {
-                    Title: (0, string_1.render)("{dtt.title}", vars),
-                    Priority: vars.success ? "default" : "high",
-                },
-            });
-        }
-        else {
-            throw new Error(`Invalid step type: ${step.type}`);
-        }
-    }
-}
-exports.runSteps = runSteps;