@datatruck/cli 0.23.3 → 0.25.0

package/Action/RestoreAction.d.ts

@@ -1,7 +1,6 @@
 import type { ConfigType } from "../Config/Config";
 import { PackageConfigType } from "../Config/PackageConfig";
 import { RepositoryConfigType } from "../Config/RepositoryConfig";
-import { AppError } from "../Error/AppError";
 import { SnapshotResultType } from "../Repository/RepositoryAbstract";
 import { RestoreSessionManager } from "../SessionManager/RestoreSessionManager";
 import { TaskAbstract } from "../Task/TaskAbstract";
@@ -38,7 +37,7 @@ export declare class RestoreAction<TRequired extends boolean = true> {
         error: boolean;
         tmpDirs: string[];
     }>;
-    protected getError(pkg: PackageConfigType): AppError | null;
+    protected getError(pkg: PackageConfigType): Error | undefined;
     exec(session: RestoreSessionManager): Promise<{
         errors: Error[];
     }>;

package/Action/RestoreAction.js

@@ -190,20 +190,16 @@ class RestoreAction {
         };
     }
     getError(pkg) {
-        const taskErrors = this.taskErrors[pkg.name]?.length;
-        const repoErrors = this.repoErrors[pkg.name]?.length;
-        if (taskErrors && repoErrors) {
-            return new AppError_1.AppError("Task and repository failed");
-        }
-        else if (taskErrors && !repoErrors) {
-            return new AppError_1.AppError("Task failed");
-        }
-        else if (!taskErrors && repoErrors) {
-            return new AppError_1.AppError("Repository failed");
-        }
-        else {
-            return null;
-        }
+        const taskErrors = this.taskErrors[pkg.name] || [];
+        const repoErrors = this.repoErrors[pkg.name] || [];
+        const errors = [...taskErrors, ...repoErrors];
+        if (!errors.length)
+            return;
+        return AppError_1.AppError.create(taskErrors.length && repoErrors.length
+            ? "Task and repository failed"
+            : taskErrors.length && !repoErrors.length
+                ? "Task failed"
+                : "Repository failed", errors);
     }
     async exec(session) {
         if (!this.options.snapshotId)

package/Command/BackupCommand.d.ts

@@ -12,5 +12,5 @@ export type BackupCommandOptionsType<TResolved = false> = {
 };
 export declare class BackupCommand extends CommandAbstract<BackupCommandOptionsType<false>, BackupCommandOptionsType<true>> {
     onOptions(): import("../utils/cli").OptionsType<BackupCommandOptionsType<false>, BackupCommandOptionsType<true>>;
-    onExec(): Promise<1 | 0>;
+    onExec(): Promise<0 | 1>;
 }

package/Command/RestoreCommand.d.ts

@@ -12,5 +12,5 @@ export type RestoreCommandOptionsType<TResolved = false> = {
 };
 export declare class RestoreCommand extends CommandAbstract<RestoreCommandOptionsType<false>, RestoreCommandOptionsType<true>> {
     onOptions(): import("../utils/cli").OptionsType<RestoreCommandOptionsType<false>, RestoreCommandOptionsType<true>>;
-    onExec(): Promise<1 | 0>;
+    onExec(): Promise<0 | 1>;
 }

package/Config/PackageConfig.d.ts

@@ -1,14 +1,9 @@
+import { Step } from "../utils/steps";
 import { PackageRepositoryConfigType } from "./PackageRepositoryConfig";
 import { PrunePolicyConfigType } from "./PrunePolicyConfig";
 import type { TaskConfigType } from "./TaskConfig";
 import { JSONSchema7 } from "json-schema";
 export declare const packageConfigDefinition: JSONSchema7;
-export declare const pathsObjectDefinition: JSONSchema7;
-export type PathsObjectType = {
-    type: "spawn";
-    command: string;
-    args?: string[];
-};
 export type PackageConfigType = {
     name: string;
     enabled?: boolean;
@@ -19,8 +14,8 @@ export type PackageConfigType = {
         uid: string | number;
         gid: string | number;
     };
-    include?: (string | PathsObjectType)[];
-    exclude?: (string | PathsObjectType)[];
+    include?: (string | Step)[];
+    exclude?: (string | Step)[];
     repositoryNames?: string[];
     prunePolicy?: PrunePolicyConfigType;
     repositoryConfigs?: PackageRepositoryConfigType[];

package/Config/PackageConfig.js

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.pathsObjectDefinition = exports.packageConfigDefinition = void 0;
+exports.packageConfigDefinition = void 0;
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
+const ScriptTask_1 = require("../Task/ScriptTask");
 exports.packageConfigDefinition = {
     type: "object",
     required: ["name"],
@@ -24,13 +25,19 @@ exports.packageConfigDefinition = {
         include: {
             type: "array",
             items: {
-                anyOf: [{ type: "string" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.pathsObject)],
+                anyOf: [
+                    { type: "string" },
+                    (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, ScriptTask_1.ScriptTaskDefinitionEnum.step),
+                ],
             },
         },
         exclude: {
             type: "array",
             items: {
-                anyOf: [{ type: "string" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.pathsObject)],
+                anyOf: [
+                    { type: "string" },
+                    (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, ScriptTask_1.ScriptTaskDefinitionEnum.step),
+                ],
             },
         },
         repositoryNames: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
@@ -41,29 +48,3 @@ exports.packageConfigDefinition = {
         prunePolicy: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.prunePolicy),
     },
 };
-exports.pathsObjectDefinition = {
-    type: "object",
-    required: ["type"],
-    properties: {
-        type: { type: "string" },
-    },
-    anyOf: [
-        {
-            if: {
-                type: "object",
-                properties: {
-                    type: { const: "spawn" },
-                },
-            },
-            then: {
-                type: "object",
-                required: ["command"],
-                properties: {
-                    command: { type: "string" },
-                    args: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-                },
-            },
-            else: false,
-        },
-    ],
-};

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/JsonSchema/DefinitionEnum.d.ts

@@ -19,7 +19,6 @@ export declare enum DefinitionEnum {
     sqlDumpTask = "sqldump-task",
     stringListUtil = "stringlist-util",
     prunePolicy = "prune-policy",
-    pathsObject = "paths-object",
     compressUtil = "compress-util"
 }
 export declare function makeRef(type: DefinitionEnum, subType?: string): {

package/JsonSchema/DefinitionEnum.js

@@ -23,7 +23,6 @@ var DefinitionEnum;
     DefinitionEnum["sqlDumpTask"] = "sqldump-task";
     DefinitionEnum["stringListUtil"] = "stringlist-util";
     DefinitionEnum["prunePolicy"] = "prune-policy";
-    DefinitionEnum["pathsObject"] = "paths-object";
     DefinitionEnum["compressUtil"] = "compress-util";
 })(DefinitionEnum || (exports.DefinitionEnum = DefinitionEnum = {}));
 function makeRef(type, subType) {

package/JsonSchema/JsonSchema.js

@@ -45,7 +45,6 @@ exports.definitions = {
     [DefinitionEnum_1.DefinitionEnum.postgresqlDumpTask]: PostgresqlDumpTask_1.postgresqlDumpTaskDefinition,
     [DefinitionEnum_1.DefinitionEnum.config]: Config_1.configDefinition,
     [DefinitionEnum_1.DefinitionEnum.prunePolicy]: PrunePolicyConfig_1.prunePolicyConfigDefinition,
-    [DefinitionEnum_1.DefinitionEnum.pathsObject]: PackageConfig_1.pathsObjectDefinition,
     [DefinitionEnum_1.DefinitionEnum.compressUtil]: tar_1.compressDefinition,
 };
 for (const key in exports.definitions) {

package/Repository/DatatruckRepository.js

@@ -159,20 +159,20 @@ class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const sourcePath = data.targetPath ?? pkg.path;
         (0, assert_1.ok)(sourcePath);
         await (0, promises_1.mkdir)(outPath, { recursive: true });
+        const backupPathsOptions = {
+            package: data.package,
+            snapshot: data.snapshot,
+            targetPath: sourcePath,
+            verbose: data.options.verbose,
+        };
         const scanner = await (0, fs_1.createFileScanner)({
             onProgress: data.onProgress,
             glob: {
                 cwd: sourcePath,
                 onlyFiles: false,
-                include: await (0, paths_1.parsePaths)(pkg.include ?? ["**"], {
-                    cwd: sourcePath,
-                    verbose: data.options.verbose,
-                }),
+                include: await (0, paths_1.parseBackupPaths)(pkg.include ?? ["**"], backupPathsOptions),
                 ignore: pkg.exclude
-                    ? await (0, paths_1.parsePaths)(pkg.exclude, {
-                        cwd: sourcePath,
-                        verbose: data.options.verbose,
-                    })
+                    ? await (0, paths_1.parseBackupPaths)(pkg.exclude, backupPathsOptions)
                     : undefined,
             },
         });

package/Repository/GitRepository.js

@@ -166,15 +166,15 @@ class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
         });
         await git.removeAll();
         const createdPaths = [];
-        const include = await (0, paths_1.parsePaths)(pkg.include ?? ["**"], {
-            cwd: sourcePath,
+        const backupPathsOptions = {
+            package: data.package,
+            snapshot: data.snapshot,
+            targetPath: sourcePath,
             verbose: data.options.verbose,
-        });
+        };
+        const include = await (0, paths_1.parseBackupPaths)(pkg.include ?? ["**"], backupPathsOptions);
         const exclude = pkg.exclude
-            ? await (0, paths_1.parsePaths)(pkg.exclude, {
-                cwd: sourcePath,
-                verbose: data.options.verbose,
-            })
+            ? await (0, paths_1.parseBackupPaths)(pkg.exclude, backupPathsOptions)
             : undefined;
         const stream = await (0, fast_glob_1.default)(include, {
             cwd: sourcePath,

package/Repository/ResticRepository.js

@@ -191,11 +191,14 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
         const sourcePath = data.targetPath ?? data.package.path;
         (0, assert_1.ok)(sourcePath);
         let gitignorePath;
+        const backupPathsOptions = {
+            package: data.package,
+            snapshot: data.snapshot,
+            targetPath: sourcePath,
+            verbose: data.options.verbose,
+        };
         if (!pkg.include && pkg.exclude) {
-            const exclude = await (0, paths_1.parsePaths)(pkg.exclude, {
-                cwd: sourcePath,
-                verbose: data.options.verbose,
-            });
+            const exclude = await (0, paths_1.parseBackupPaths)(pkg.exclude, backupPathsOptions);
             await data.onProgress({
                 relative: {
                     description: "Writing excluded paths list",
@@ -207,15 +210,9 @@ class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
             await (0, promises_1.writeFile)(gitignorePath, ignoredContents);
         }
         else if (pkg.include || pkg.exclude) {
-            const include = await (0, paths_1.parsePaths)(pkg.include ?? ["**"], {
-                cwd: sourcePath,
-                verbose: data.options.verbose,
-            });
+            const include = await (0, paths_1.parseBackupPaths)(pkg.include ?? ["**"], backupPathsOptions);
             const exclude = pkg.exclude
-                ? await (0, paths_1.parsePaths)(pkg.exclude, {
-                    cwd: sourcePath,
-                    verbose: data.options.verbose,
-                })
+                ? await (0, paths_1.parseBackupPaths)(pkg.exclude, backupPathsOptions)
                 : undefined;
             const stream = fast_glob_1.default.stream(include, {
                 cwd: sourcePath,

package/Task/ScriptTask.d.ts

@@ -1,41 +1,41 @@
-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[];
     restoreSteps: Step[];
 };
+export declare enum ScriptTaskDefinitionEnum {
+    step = "step",
+    processStepConfig = "processStepConfig",
+    nodeStepConfig = "nodeStepConfig"
+}
 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

@@ -1,20 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScriptTask = exports.scriptTaskDefinition = exports.scriptTaskName = void 0;
+exports.ScriptTask = exports.scriptTaskDefinition = exports.scriptTaskName = exports.ScriptTaskDefinitionEnum = 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";
     ScriptTaskDefinitionEnum["processStepConfig"] = "processStepConfig";
     ScriptTaskDefinitionEnum["nodeStepConfig"] = "nodeStepConfig";
-})(ScriptTaskDefinitionEnum || (ScriptTaskDefinitionEnum = {}));
+})(ScriptTaskDefinitionEnum || (exports.ScriptTaskDefinitionEnum = ScriptTaskDefinitionEnum = {}));
 const stepTypes = {
     process: ScriptTaskDefinitionEnum.processStepConfig,
     node: ScriptTaskDefinitionEnum.nodeStepConfig,
@@ -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

@@ -176,7 +176,7 @@
                 "type": "string"
               },
               {
-                "$ref": "#/definitions/paths-object"
+                "$ref": "#/definitions/script-task_step"
               }
             ]
           }
@@ -189,7 +189,7 @@
                 "type": "string"
               },
               {
-                "$ref": "#/definitions/paths-object"
+                "$ref": "#/definitions/script-task_step"
               }
             ]
           }
@@ -1036,44 +1036,6 @@
         }
       }
     },
-    "paths-object": {
-      "type": "object",
-      "required": [
-        "type"
-      ],
-      "properties": {
-        "type": {
-          "type": "string"
-        }
-      },
-      "anyOf": [
-        {
-          "if": {
-            "type": "object",
-            "properties": {
-              "type": {
-                "const": "spawn"
-              }
-            }
-          },
-          "then": {
-            "type": "object",
-            "required": [
-              "command"
-            ],
-            "properties": {
-              "command": {
-                "type": "string"
-              },
-              "args": {
-                "$ref": "#/definitions/stringlist-util"
-              }
-            }
-          },
-          "else": false
-        }
-      ]
-    },
     "compress-util": {
       "type": "object",
       "additionalProperties": false,
@@ -1194,6 +1156,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.25.0",
   "dependencies": {
     "@supercharge/promise-pool": "^3.1.0",
     "ajv": "^8.12.0",

package/utils/datatruck/config.d.ts

@@ -32,15 +32,15 @@ export declare const pkgPathParams: {
 };
 export declare const pkgIncludeParams: {
     packageName: string;
-    snapshotId: string;
     temp: string;
+    snapshotId: string;
     snapshotDate: string;
     action: string;
 };
 export declare const pkgExcludeParams: {
     packageName: string;
-    snapshotId: string;
     temp: string;
+    snapshotId: string;
     snapshotDate: string;
     action: string;
 };
@@ -53,30 +53,30 @@ export declare const dbNameParams: {
 export declare const params: {
     pkgPath: {
         packageName: string;
-        snapshotId: string;
         temp: string;
+        snapshotId: string;
         snapshotDate: string;
         action: string;
     };
     pkgRestorePath: {
         path: string;
         packageName: string;
-        snapshotId: string;
         temp: string;
+        snapshotId: string;
         snapshotDate: string;
         action: string;
     };
     pkgInclude: {
         packageName: string;
-        snapshotId: string;
         temp: string;
+        snapshotId: string;
         snapshotDate: string;
         action: string;
     };
     pkgExclude: {
         packageName: string;
-        snapshotId: string;
         temp: string;
+        snapshotId: string;
         snapshotDate: string;
         action: string;
     };

package/utils/datatruck/paths.d.ts

@@ -1,5 +1,21 @@
-import { PathsObjectType } from "../../Config/PackageConfig";
-export declare function parsePaths(values: (string | PathsObjectType)[], options: {
+import { PackageConfigType } from "../../Config/PackageConfig";
+import { SnapshotType } 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 type BackupPathsOptions = {
+    package: PackageConfigType;
+    snapshot: SnapshotType;
+    targetPath: string;
+    verbose?: boolean;
+};
+export declare function parseBackupPaths(paths: (string | Step)[], options: BackupPathsOptions): Promise<string[]>;

package/utils/datatruck/paths.js

@@ -1,26 +1,35 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parsePaths = void 0;
-const process_1 = require("../process");
+exports.parseBackupPaths = exports.parsePaths = void 0;
+const steps_1 = require("../steps");
 async function parsePaths(values, options) {
     let paths = [];
     for (const value of values) {
         if (typeof value === "string") {
             paths.push(value);
         }
-        else if (value.type === "spawn") {
-            const spawnResult = await (0, process_1.exec)(value.command, value.args, { cwd: options.cwd }, {
-                log: options.verbose,
-                stderr: { save: true },
-                stdout: { save: true },
+        else {
+            await (0, steps_1.runSteps)(value, {
+                node: { tempDir: options.tempDir },
+                verbose: options.verbose,
+                onLine: (path) => paths.push(path),
             });
-            const spawnFiles = [spawnResult.stderr, spawnResult.stdout].flatMap((text) => text
-                .split(/\r?\n/)
-                .map((v) => v.trim())
-                .filter((v) => !!v.length));
-            paths.push(...spawnFiles);
         }
     }
     return paths;
 }
 exports.parsePaths = parsePaths;
+async function parseBackupPaths(paths, options) {
+    return parsePaths(paths, {
+        cwd: options.targetPath,
+        verbose: options.verbose,
+        vars: {
+            dtt: {
+                package: options.package,
+                snapshot: options.snapshot,
+                targetPath: options.targetPath,
+            },
+        },
+    });
+}
+exports.parseBackupPaths = parseBackupPaths;

package/utils/steps.d.ts

@@ -0,0 +1,32 @@
+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>;
+    };
+    cwd?: string;
+    onLine?: (p: string) => any;
+    verbose?: boolean;
+};
+export declare function runSteps(input: Step[] | Step, options: StepOptions): Promise<void>;

package/utils/steps.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSteps = void 0;
+const fs_1 = require("./fs");
+const process_1 = require("./process");
+const string_1 = require("./string");
+const promises_1 = require("fs/promises");
+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 || {})), {
+                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.node?.tempDir) {
+                tempDir = await options.node.tempDir();
+            }
+            else {
+                tempDir = await (0, fs_1.mkTmpDir)("node-step");
+            }
+            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], {
+                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 {
+            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))