@datatruck/cli 0.23.3 → 0.24.0

package/Factory/CommandFactory.d.ts

@@ -38,5 +38,12 @@ export type LogMapType = {
 };
 export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): CleanCacheCommand;
 export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptionsType<false>, options: OptionsMapType[TCommand]): Promise<number>;
+export declare function createActionInterface(globalOptions: GlobalOptionsType<false>): {
+    [K in keyof OptionsMapType as `${K}`]: (options: OptionsMapType[K]) => Promise<K extends keyof LogMapType ? LogMapType[K] : never>;
+};
+export declare function runAndParse<TCommand extends keyof LogMapType>(type: TCommand, run: () => Promise<any>): Promise<{
+    exitCode: any;
+    log: LogMapType[TCommand];
+}>;
 export declare function makeParseLog<TCommand extends keyof LogMapType>(type: TCommand): () => LogMapType[TCommand];
 export declare function CommandConstructorFactory(type: CommandEnum): typeof CleanCacheCommand;

package/Factory/CommandFactory.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommandConstructorFactory = exports.makeParseLog = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
+exports.CommandConstructorFactory = exports.makeParseLog = exports.runAndParse = exports.createActionInterface = exports.exec = exports.CommandFactory = exports.CommandEnum = void 0;
 const BackupCommand_1 = require("../Command/BackupCommand");
 const BackupSessionsCommand_1 = require("../Command/BackupSessionsCommand");
 const CleanCacheCommand_1 = require("../Command/CleanCacheCommand");
@@ -32,6 +32,44 @@ async function exec(type, globalOptions, options) {
     return await CommandFactory(type, globalOptions, options).onExec();
 }
 exports.exec = exec;
+function createActionInterface(globalOptions) {
+    const object = {};
+    for (const type of Object.values(CommandEnum)) {
+        object[type] = async (options) => {
+            const run = () => exec(type, { ...globalOptions, outputFormat: "json", verbose: 1 }, options);
+            let exitCode;
+            let log;
+            if (["config", "init", "snapshots"].includes(type)) {
+                const parsed = await runAndParse(type, run);
+                exitCode = parsed.exitCode;
+                log = parsed.log;
+            }
+            else {
+                exitCode = await run();
+            }
+            if (exitCode !== 0)
+                throw new Error(`Invalid exit code: ${exitCode}`);
+            return log;
+        };
+    }
+    return object;
+}
+exports.createActionInterface = createActionInterface;
+async function runAndParse(type, run) {
+    const parseLog = makeParseLog(type);
+    try {
+        const exitCode = await run();
+        return { exitCode, log: parseLog() };
+    }
+    catch (error) {
+        try {
+            parseLog();
+        }
+        catch (_) { }
+        throw error;
+    }
+}
+exports.runAndParse = runAndParse;
 function makeParseLog(type) {
     const data = [];
     const consoleLog = console.log;

package/Task/ScriptTask.d.ts

@@ -1,21 +1,6 @@
-import { BackupDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
+import { Step } from "../utils/steps";
+import { BackupDataType, BeforeBackupDataType, BeforeRestoreDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
 import { JSONSchema7 } from "json-schema";
-export type ProcessStepConfig = {
-    command: string;
-    env?: Record<string, string>;
-    args?: string[];
-};
-export type NodeStepConfig = {
-    env?: Record<string, string>;
-    code: string | string[];
-};
-export type Step = {
-    type: "process";
-    config: ProcessStepConfig;
-} | {
-    type: "node";
-    config: NodeStepConfig;
-};
 export type ScriptTaskConfigType = {
     env?: Record<string, string | undefined>;
     backupSteps: Step[];
@@ -25,17 +10,27 @@ export declare const scriptTaskName = "script";
 export declare const scriptTaskDefinition: JSONSchema7;
 export declare class ScriptTask extends TaskAbstract<ScriptTaskConfigType> {
     protected verbose?: boolean;
-    onBeforeBackup(): Promise<{
+    onBeforeBackup(data: BeforeBackupDataType): Promise<{
         targetPath: string;
     }>;
-    protected getVars(data: BackupDataType | RestoreDataType): Record<string, string | undefined>;
-    protected processSteps(input: Step[] | Step, options: {
-        env?: Record<string, string | undefined>;
-        vars: Record<string, string | undefined>;
-        verbose?: boolean;
-    }): Promise<void>;
+    protected getVars(data: BackupDataType | RestoreDataType): {
+        process: {
+            DTT_SNAPSHOT_ID: string;
+            DTT_SNAPSHOT_DATE: string;
+            DTT_PACKAGE_NAME: string;
+            DTT_PACKAGE_PATH: string | undefined;
+            DTT_TARGET_PATH: string | undefined;
+        };
+        node: {
+            dtt: {
+                snapshot: import("../Repository/RepositoryAbstract").SnapshotType;
+                package: import("../Config/PackageConfig").PackageConfigType;
+                targetPath: string | undefined;
+            };
+        };
+    };
     onBackup(data: BackupDataType): Promise<void>;
-    onBeforeRestore(): Promise<{
+    onBeforeRestore(data: BeforeRestoreDataType): Promise<{
         targetPath: string;
     }>;
     onRestore(data: RestoreDataType): Promise<void>;

package/Task/ScriptTask.js

@@ -3,12 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ScriptTask = exports.scriptTaskDefinition = exports.scriptTaskName = void 0;
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const fs_1 = require("../utils/fs");
-const process_1 = require("../utils/process");
-const string_1 = require("../utils/string");
+const steps_1 = require("../utils/steps");
 const TaskAbstract_1 = require("./TaskAbstract");
 const assert_1 = require("assert");
-const promises_1 = require("fs/promises");
-const path_1 = require("path");
 var ScriptTaskDefinitionEnum;
 (function (ScriptTaskDefinitionEnum) {
     ScriptTaskDefinitionEnum["step"] = "step";
@@ -64,6 +61,10 @@ exports.scriptTaskDefinition = {
                 code: {
                     anyOf: [{ type: "string" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil)],
                 },
+                vars: {
+                    type: "object",
+                    patternProperties: { ".+": {} },
+                },
                 env: {
                     type: "object",
                     patternProperties: { ".+": { type: "string" } },
@@ -93,88 +94,65 @@ exports.scriptTaskDefinition = {
 };
 class ScriptTask extends TaskAbstract_1.TaskAbstract {
     verbose;
-    async onBeforeBackup() {
+    async onBeforeBackup(data) {
         return {
-            targetPath: await this.mkTmpDir(ScriptTask.name),
+            targetPath: data.package.path ?? (await this.mkTmpDir(`script-task_backup_target`)),
         };
     }
     getVars(data) {
         return {
-            DTT_SNAPSHOT_ID: data.snapshot.id,
-            DTT_SNAPSHOT_DATE: data.snapshot.date,
-            DTT_PACKAGE_NAME: data.package.name,
-            DTT_PACKAGE_PATH: data.package.path,
-            DTT_TARGET_PATH: data.targetPath,
+            process: {
+                DTT_SNAPSHOT_ID: data.snapshot.id,
+                DTT_SNAPSHOT_DATE: data.snapshot.date,
+                DTT_PACKAGE_NAME: data.package.name,
+                DTT_PACKAGE_PATH: data.package.path,
+                DTT_TARGET_PATH: data.targetPath,
+            },
+            node: {
+                dtt: {
+                    snapshot: data.snapshot,
+                    package: data.package,
+                    targetPath: data.targetPath,
+                },
+            },
         };
     }
-    async processSteps(input, options) {
-        const steps = Array.isArray(input) ? input : [input];
-        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, options.vars)), {
-                    env: {
-                        ...process.env,
-                        ...options.vars,
-                        ...options.env,
-                        ...step.config.env,
-                    },
-                }, {
-                    log: options.verbose,
-                });
-            }
-            else if (step.type === "node") {
-                const tempDir = await this.mkTmpDir("script-task-node-step");
-                const scriptPath = (0, path_1.join)(tempDir, "script.js");
-                await (0, promises_1.writeFile)(scriptPath, Array.isArray(step.config.code)
-                    ? step.config.code.join("\n")
-                    : step.config.code);
-                await (0, process_1.exec)("node", [scriptPath], {
-                    env: {
-                        ...process.env,
-                        ...options.vars,
-                        ...options.env,
-                        ...step.config.env,
-                    },
-                }, {
-                    log: options.verbose,
-                });
-            }
-            else {
-                throw new Error(`Invalid step type: ${step.type}`);
-            }
-        }
-    }
     async onBackup(data) {
-        this.verbose = data.options.verbose;
         const config = this.config;
-        const path = data.package.path;
         const targetPath = data.targetPath;
-        (0, assert_1.ok)(typeof path === "string");
         (0, assert_1.ok)(typeof targetPath === "string");
-        await this.processSteps(config.backupSteps, {
+        const vars = this.getVars(data);
+        await (0, fs_1.mkdirIfNotExists)(targetPath);
+        await (0, steps_1.runSteps)(config.backupSteps, {
             env: config.env,
-            vars: this.getVars(data),
-            verbose: this.verbose,
+            verbose: data.options.verbose,
+            process: { vars: vars.process },
+            node: {
+                tempDir: () => this.mkTmpDir("script-task_backup_node-step"),
+                vars: vars.node,
+            },
         });
     }
-    async onBeforeRestore() {
+    async onBeforeRestore(data) {
         return {
-            targetPath: await this.mkTmpDir(ScriptTask.name),
+            targetPath: data.package.restorePath ??
+                (await this.mkTmpDir(`script-task_restore_target`)),
         };
     }
     async onRestore(data) {
-        this.verbose = data.options.verbose;
         const config = this.config;
-        const restorePath = data.package.restorePath;
         const targetPath = data.targetPath;
-        (0, assert_1.ok)(typeof restorePath === "string");
         (0, assert_1.ok)(typeof targetPath === "string");
-        await (0, fs_1.mkdirIfNotExists)(restorePath);
-        await (0, fs_1.ensureEmptyDir)(restorePath);
-        await this.processSteps(config.restoreSteps, {
+        await (0, fs_1.mkdirIfNotExists)(targetPath);
+        const vars = this.getVars(data);
+        await (0, steps_1.runSteps)(config.restoreSteps, {
             env: config.env,
-            vars: this.getVars(data),
-            verbose: this.verbose,
+            verbose: data.options.verbose,
+            process: { vars: vars.process },
+            node: {
+                tempDir: () => this.mkTmpDir("script-task_restore_node-step"),
+                vars: vars.node,
+            },
         });
     }
 }

package/Task/TaskAbstract.d.ts

@@ -10,6 +10,7 @@ export type BackupDataType = {
     targetPath: string | undefined;
     snapshot: SnapshotType;
 };
+export type BeforeBackupDataType = Omit<BackupDataType, "onProgress" | "targetPath">;
 export type RestoreDataType = {
     onProgress: (data: Progress) => Promise<void>;
     options: RestoreActionOptionsType;
@@ -17,17 +18,17 @@ export type RestoreDataType = {
     targetPath: string | undefined;
     snapshot: SnapshotType;
 };
+export type BeforeRestoreDataType = Omit<RestoreDataType, "onProgress" | "targetPath">;
+export type BeforeReturn = Promise<{
+    targetPath?: string;
+} | undefined | void>;
 export declare abstract class TaskAbstract<TConfig = any> {
     readonly config: TConfig;
     readonly tmpDirs: string[];
     constructor(config: TConfig);
     mkTmpDir(prefix: string, id?: string): Promise<string>;
-    onBeforeBackup(data: Omit<BackupDataType, "onProgress" | "targetPath">): Promise<{
-        targetPath?: string;
-    } | undefined>;
+    onBeforeBackup(data: BeforeBackupDataType): BeforeReturn;
     onBackup(data: BackupDataType): Promise<void>;
-    onBeforeRestore(data: Omit<RestoreDataType, "onProgress" | "targetPath">): Promise<{
-        targetPath?: string;
-    } | undefined>;
+    onBeforeRestore(data: BeforeRestoreDataType): BeforeReturn;
     onRestore(data: RestoreDataType): Promise<void>;
 }

package/Task/TaskAbstract.js

@@ -13,13 +13,9 @@ class TaskAbstract {
         this.tmpDirs.push(dir);
         return dir;
     }
-    async onBeforeBackup(data) {
-        return undefined;
-    }
+    async onBeforeBackup(data) { }
     async onBackup(data) { }
-    async onBeforeRestore(data) {
-        return undefined;
-    }
+    async onBeforeRestore(data) { }
     async onRestore(data) { }
 }
 exports.TaskAbstract = TaskAbstract;

package/config.schema.json

@@ -1194,6 +1194,12 @@
             }
           ]
         },
+        "vars": {
+          "type": "object",
+          "patternProperties": {
+            ".+": {}
+          }
+        },
         "env": {
           "type": "object",
           "patternProperties": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.23.3",
+  "version": "0.24.0",
   "dependencies": {
     "@supercharge/promise-pool": "^3.1.0",
     "ajv": "^8.12.0",

package/utils/steps.d.ts

@@ -0,0 +1,30 @@
+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 Step = {
+    type: "process";
+    config: ProcessStepConfig;
+} | {
+    type: "node";
+    config: NodeStepConfig;
+};
+export type StepOptions = {
+    env?: Record<string, string | undefined>;
+    process?: {
+        vars?: Record<string, string | undefined>;
+    };
+    node?: {
+        vars?: Record<string, any>;
+        tempDir?: () => Promise<string>;
+    };
+    verbose?: boolean;
+};
+export declare function runSteps(input: Step[] | Step, options: StepOptions): Promise<void>;

package/utils/steps.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSteps = void 0;
+const process_1 = require("./process");
+const string_1 = require("./string");
+const crypto_1 = require("crypto");
+const promises_1 = require("fs/promises");
+const os_1 = require("os");
+const path_1 = require("path");
+async function runSteps(input, options) {
+    const steps = Array.isArray(input) ? input : [input];
+    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, options.process?.vars || {})), {
+                env: {
+                    ...process.env,
+                    ...options.env,
+                    ...step.config.env,
+                },
+            }, {
+                log: options.verbose,
+            });
+        }
+        else if (step.type === "node") {
+            let tempDir;
+            if (options.node?.tempDir) {
+                tempDir = await options.node.tempDir();
+            }
+            else {
+                tempDir = (0, path_1.join)((0, os_1.tmpdir)(), (0, crypto_1.randomBytes)(8).toString("hex"));
+                await (0, promises_1.mkdir)(tempDir, { recursive: true });
+            }
+            const scriptPath = (0, path_1.join)(tempDir, "script.js");
+            const vars = Object.entries({
+                ...step.config.vars,
+                ...options.node?.vars,
+            }).reduce((items, [name, value]) => {
+                items.push(`let ${name} = ${JSON.stringify(value)}`);
+                return items;
+            }, []);
+            await (0, promises_1.writeFile)(scriptPath, Array.isArray(step.config.code)
+                ? [...vars, ...step.config.code].join(";\n")
+                : `${vars.join(";\n")}\n${step.config.code}`);
+            await (0, process_1.exec)("node", [scriptPath], {
+                env: {
+                    ...process.env,
+                    ...options.env,
+                    ...step.config.env,
+                },
+            }, {
+                log: options.verbose,
+            });
+        }
+        else {
+            throw new Error(`Invalid step type: ${step.type}`);
+        }
+    }
+}
+exports.runSteps = runSteps;

package/utils/string.d.ts

@@ -1,7 +1,8 @@
 export declare function serialize(message: string, data?: Object): string;
 export declare function snakeCase(value: string, char?: string): string;
 export declare function render(subject: string, vars: Record<string, string | undefined>): string;
-export declare function parseStringList(value: string, validValues?: string[]): string[];
+type NoInfer<T> = [T][T extends any ? 0 : never];
+export declare function parseStringList<T>(value: string | undefined, validValues?: T[], defaultsValues?: NoInfer<T>[] | true): T[];
 export type UriType = {
     protocol?: "http" | "https";
     host?: string;
@@ -20,3 +21,4 @@ export declare function checkMatch(subject: string | undefined, patterns: string
 export declare function formatDateTime(datetime: string): string;
 export declare function splitLines(input: string, satinize?: boolean): string[];
 export declare function undefIfEmpty(input: string): string | undefined;
+export {};

package/utils/string.js

@@ -28,11 +28,12 @@ function render(subject, vars) {
     });
 }
 exports.render = render;
-function parseStringList(value, validValues) {
+function parseStringList(value, validValues, defaultsValues) {
+    const resultFallback = (defaultsValues === true ? validValues : defaultsValues) ?? [];
     const result = value
         ?.split(",")
         .map((v) => v.trim())
-        .filter((v) => !!v.length) ?? null;
+        .filter((v) => !!v.length) ?? resultFallback;
     if (validValues)
         for (const v of result)
             if (!validValues.includes(v))