@datatruck/cli 0.26.2 → 0.28.0

package/Task/ScriptTask.js

@@ -1,20 +1,25 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ScriptTask = exports.scriptTaskDefinition = exports.scriptTaskName = exports.ScriptTaskDefinitionEnum = void 0;
+exports.ScriptTask = exports.scriptTaskDefinition = exports.scriptTaskName = exports.ScriptTaskDefinitionEnum = exports.scriptTaskCode = void 0;
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-const fs_1 = require("../utils/fs");
 const steps_1 = require("../utils/steps");
+const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
-const assert_1 = require("assert");
+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 || (exports.ScriptTaskDefinitionEnum = ScriptTaskDefinitionEnum = {}));
 const stepTypes = {
     process: ScriptTaskDefinitionEnum.processStepConfig,
     node: ScriptTaskDefinitionEnum.nodeStepConfig,
+    "telegram-message": ScriptTaskDefinitionEnum.telegramMessageStepConfig,
 };
 exports.scriptTaskName = "script";
 exports.scriptTaskDefinition = {
@@ -71,6 +76,15 @@ exports.scriptTaskDefinition = {
                 },
             },
         },
+        telegramMessageStepConfig: {
+            type: "object",
+            required: ["bot", "chatId"],
+            properties: {
+                command: { type: "string" },
+                chatId: { type: "integer" },
+                text: { type: "string" },
+            },
+        },
     },
     type: "object",
     additionalProperties: false,
@@ -94,11 +108,6 @@ exports.scriptTaskDefinition = {
 };
 class ScriptTask extends TaskAbstract_1.TaskAbstract {
     verbose;
-    async onBeforeBackup(data) {
-        return {
-            targetPath: data.package.path ?? (await this.mkTmpDir(`script-task_backup_target`)),
-        };
-    }
     getVars(data) {
         return {
             process: {
@@ -106,51 +115,52 @@ class ScriptTask extends TaskAbstract_1.TaskAbstract {
                 DTT_SNAPSHOT_DATE: data.snapshot.date,
                 DTT_PACKAGE_NAME: data.package.name,
                 DTT_PACKAGE_PATH: data.package.path,
-                DTT_TARGET_PATH: data.targetPath,
+                DTT_SNAPSHOT_PATH: data.snapshotPath,
             },
             node: {
                 dtt: {
                     snapshot: data.snapshot,
                     package: data.package,
-                    targetPath: data.targetPath,
+                    snapshotPath: data.snapshotPath,
                 },
             },
         };
     }
-    async onBackup(data) {
+    async backup(data) {
         const config = this.config;
-        const targetPath = data.targetPath;
-        (0, assert_1.ok)(typeof targetPath === "string");
-        const vars = this.getVars(data);
-        await (0, fs_1.mkdirIfNotExists)(targetPath);
+        const snapshotPath = data.package.path ??
+            (await (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "backup", "snapshot"));
+        const vars = this.getVars({
+            ...data,
+            snapshotPath,
+        });
         await (0, steps_1.runSteps)(config.backupSteps, {
             env: config.env,
+            cwd: snapshotPath,
             verbose: data.options.verbose,
             process: { vars: vars.process },
             node: {
-                tempDir: () => this.mkTmpDir("script-task_backup_node-step"),
+                tempDir: () => (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "backup", "nodeStep"),
                 vars: vars.node,
             },
         });
+        return { snapshotPath };
     }
-    async onBeforeRestore(data) {
+    async prepareRestore(data) {
         return {
-            targetPath: data.package.restorePath ??
-                (await this.mkTmpDir(`script-task_restore_target`)),
+            snapshotPath: data.package.restorePath ??
+                (await (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "restore", "snapshot")),
         };
     }
-    async onRestore(data) {
+    async restore(data) {
         const config = this.config;
-        const targetPath = data.targetPath;
-        (0, assert_1.ok)(typeof targetPath === "string");
-        await (0, fs_1.mkdirIfNotExists)(targetPath);
         const vars = this.getVars(data);
         await (0, steps_1.runSteps)(config.restoreSteps, {
             env: config.env,
             verbose: data.options.verbose,
             process: { vars: vars.process },
             node: {
-                tempDir: () => this.mkTmpDir("script-task_restore_node-step"),
+                tempDir: () => (0, temp_1.mkTmpDir)(exports.scriptTaskName, "task", "restore", "nodeStep"),
                 vars: vars.node,
             },
         });

package/Task/SqlDumpTaskAbstract.d.ts

@@ -1,5 +1,5 @@
 import { exec } from "../utils/process";
-import { BackupDataType, RestoreDataType, TaskAbstract } from "./TaskAbstract";
+import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 import { JSONSchema7, JSONSchema7Definition } from "json-schema";
 export type TargetDatabaseType = {
     name: string;
@@ -37,6 +37,11 @@ export declare abstract class SqlDumpTaskAbstract<TConfig extends SqlDumpTaskCon
     }) => void): Promise<void>;
     abstract onExportStoredPrograms(output: string): Promise<void>;
     abstract onImport(path: string, database: string): Promise<void>;
-    onBackup(data: BackupDataType): Promise<void>;
-    onRestore(data: RestoreDataType): Promise<void>;
+    backup(data: TaskBackupData): Promise<{
+        snapshotPath: string;
+    }>;
+    prepareRestore(data: TaskPrepareRestoreData): Promise<{
+        snapshotPath: string;
+    }>;
+    restore(data: TaskRestoreData): Promise<void>;
 }

package/Task/SqlDumpTaskAbstract.js

@@ -7,6 +7,7 @@ const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
 const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
+const temp_1 = require("../utils/temp");
 const TaskAbstract_1 = require("./TaskAbstract");
 const assert_1 = require("assert");
 const promises_1 = require("fs/promises");
@@ -104,10 +105,13 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
             return result;
         }, []);
     }
-    async onBackup(data) {
+    async backup(data) {
         this.verbose = data.options.verbose;
+        const snapshotPath = data.package.path ??
+            (await (0, temp_1.mkTmpDir)("sqldump", "task", "backup", "snapshot"));
+        await (0, fs_1.mkdirIfNotExists)(snapshotPath);
+        await (0, fs_1.ensureEmptyDir)(snapshotPath);
         const config = this.config;
-        const outputPath = data.package.path;
         const allTableNames = await this.onFetchTableNames(this.config.database);
         const tableNames = allTableNames.filter((tableName) => {
             if (config.includeTables && !(0, micromatch_1.isMatch)(tableName, config.includeTables))
@@ -116,18 +120,18 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
                 return false;
             return true;
         });
-        (0, assert_1.ok)(typeof outputPath === "string");
-        if (!(await (0, fs_1.existsDir)(outputPath)))
-            await (0, promises_1.mkdir)(outputPath, { recursive: true });
+        (0, assert_1.ok)(typeof snapshotPath === "string");
+        if (!(await (0, fs_1.existsDir)(snapshotPath)))
+            await (0, promises_1.mkdir)(snapshotPath, { recursive: true });
         if (!this.config.oneFileByTable) {
-            const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ database: this.config.database }));
-            await data.onProgress({
+            const outPath = (0, path_1.join)(snapshotPath, serializeSqlFile({ database: this.config.database }));
+            data.onProgress({
                 relative: {
                     description: "Exporting",
                 },
             });
             await this.onExportTables(tableNames, outPath, async (progress) => {
-                await data.onProgress({
+                data.onProgress({
                     absolute: {
                         description: "Exporting in single file",
                         current: progress.totalBytes,
@@ -139,7 +143,7 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         else {
             let current = 0;
             for (const tableName of tableNames) {
-                await data.onProgress({
+                data.onProgress({
                     relative: {
                         description: "Exporting",
                         payload: tableName,
@@ -150,9 +154,9 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
                         percent: (0, math_1.progressPercent)(tableNames.length, current),
                     },
                 });
-                const outPath = (0, path_1.join)(outputPath, serializeSqlFile({ table: tableName }));
+                const outPath = (0, path_1.join)(snapshotPath, serializeSqlFile({ table: tableName }));
                 await this.onExportTables([tableName], outPath, async (progress) => {
-                    await data.onProgress({
+                    data.onProgress({
                         relative: {
                             description: "Exporting",
                             payload: tableName,
@@ -170,19 +174,27 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
             }
         }
         if (this.config.storedPrograms) {
-            const outPath = (0, path_1.join)(outputPath, "stored-programs.sql");
-            await data.onProgress({
+            const outPath = (0, path_1.join)(snapshotPath, "stored-programs.sql");
+            data.onProgress({
                 relative: {
                     description: "Exporting storaged programs",
                 },
             });
             await this.onExportStoredPrograms(outPath);
         }
+        return {
+            snapshotPath: snapshotPath,
+        };
+    }
+    async prepareRestore(data) {
+        return {
+            snapshotPath: data.package.restorePath ??
+                (await (0, temp_1.mkTmpDir)("sqldump", "task", "restore", "snapshot")),
+        };
     }
-    async onRestore(data) {
-        const restorePath = data.package.restorePath;
+    async restore(data) {
+        const snapshotPath = data.snapshotPath;
         this.verbose = data.options.verbose;
-        (0, assert_1.ok)(typeof restorePath === "string");
         const database = {
             name: (0, config_1.resolveDatabaseName)(this.config.database, {
                 packageName: data.package.name,
@@ -201,7 +213,7 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
                 database: database.name,
             });
         }
-        const items = (await (0, fs_1.readDir)(restorePath))
+        const items = (await (0, fs_1.readDir)(snapshotPath))
             .map(parseSqlFile)
             .filter((v) => !!v);
         // Database check
@@ -219,10 +231,10 @@ class SqlDumpTaskAbstract extends TaskAbstract_1.TaskAbstract {
         }
         await this.onCreateDatabase(database);
         if (this.verbose)
-            (0, cli_1.logExec)("readdir", [restorePath]);
+            (0, cli_1.logExec)("readdir", [snapshotPath]);
         let current = 0;
         for (const item of items) {
-            const path = (0, path_1.join)(restorePath, item.fileName);
+            const path = (0, path_1.join)(snapshotPath, item.fileName);
             data.onProgress({
                 relative: {
                     description: "Importing",

package/Task/TaskAbstract.d.ts

@@ -1,34 +1,33 @@
-import { BackupActionOptionsType } from "../Action/BackupAction";
-import { RestoreActionOptionsType } from "../Action/RestoreAction";
+import { BackupActionOptions } from "../Action/BackupAction";
+import { RestoreActionOptions } from "../Action/RestoreAction";
 import { PackageConfigType } from "../Config/PackageConfig";
-import { SnapshotType } from "../Repository/RepositoryAbstract";
+import { PreSnapshot } from "../Repository/RepositoryAbstract";
 import { Progress } from "../utils/progress";
-export type BackupDataType = {
-    onProgress: (data: Progress) => Promise<void>;
-    options: BackupActionOptionsType;
+type TaskCommonData = {
     package: PackageConfigType;
-    targetPath: string | undefined;
-    snapshot: SnapshotType;
+    snapshot: PreSnapshot;
 };
-export type BeforeBackupDataType = Omit<BackupDataType, "onProgress" | "targetPath">;
-export type RestoreDataType = {
-    onProgress: (data: Progress) => Promise<void>;
-    options: RestoreActionOptionsType;
-    package: PackageConfigType;
-    targetPath: string | undefined;
-    snapshot: SnapshotType;
+export type TaskBackupData = TaskCommonData & {
+    onProgress: (data: Progress) => void;
+    options: BackupActionOptions;
+    snapshotPath?: string;
+};
+export type TaskRestoreData = TaskCommonData & {
+    onProgress: (data: Progress) => void;
+    options: RestoreActionOptions;
+    snapshotPath: string;
+};
+export type TaskPrepareRestoreData = TaskCommonData & {
+    options: RestoreActionOptions;
 };
-export type BeforeRestoreDataType = Omit<RestoreDataType, "onProgress" | "targetPath">;
-export type BeforeReturn = Promise<{
-    targetPath?: string;
-} | undefined | void>;
+export type TaskReturn = Promise<{
+    snapshotPath?: string;
+} | undefined>;
 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: BeforeBackupDataType): BeforeReturn;
-    onBackup(data: BackupDataType): Promise<void>;
-    onBeforeRestore(data: BeforeRestoreDataType): BeforeReturn;
-    onRestore(data: RestoreDataType): Promise<void>;
+    backup(data: TaskBackupData): TaskReturn;
+    prepareRestore(data: TaskPrepareRestoreData): TaskReturn;
+    restore(data: TaskRestoreData): Promise<void>;
 }
+export {};

package/Task/TaskAbstract.js

@@ -1,21 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.TaskAbstract = void 0;
-const fs_1 = require("../utils/fs");
 class TaskAbstract {
     config;
-    tmpDirs = [];
     constructor(config) {
         this.config = config;
     }
-    async mkTmpDir(prefix, id) {
-        const dir = await (0, fs_1.mkTmpDir)(prefix, id);
-        this.tmpDirs.push(dir);
-        return dir;
+    async backup(data) {
+        return;
     }
-    async onBeforeBackup(data) { }
-    async onBackup(data) { }
-    async onBeforeRestore(data) { }
-    async onRestore(data) { }
+    async prepareRestore(data) {
+        return;
+    }
+    async restore(data) { }
 }
 exports.TaskAbstract = TaskAbstract;

package/cli.js

@@ -12,12 +12,20 @@ const cli_1 = require("./utils/cli");
 const fs_1 = require("./utils/fs");
 const process_1 = require("./utils/process");
 const string_1 = require("./utils/string");
+const temp_1 = require("./utils/temp");
 const chalk_1 = require("chalk");
 const commander_1 = require("commander");
 const fs_2 = require("fs");
 const path_1 = require("path");
 function getGlobalOptions() {
-    return program.opts();
+    const result = program.opts();
+    return {
+        ...result,
+        tty: result.tty === "auto" ? "auto" : result.tty === "true",
+        progress: result.progress === "auto" || result.progress === "interval"
+            ? result.progress
+            : result.progress === "true",
+    };
 }
 function makeCommand(command) {
     const programCommand = program.command(command);
@@ -80,17 +88,18 @@ program.description(description);
 program.usage("dtt");
 program.option("-v,--verbose", "Verbose", (_, previous) => previous + 1, 0);
 program.option("-c,--config <path>", "Config path", process.env["DATATRUCK_CONFIG"] ?? (cwd.endsWith(path_1.sep) ? cwd : `${cwd}${path_1.sep}`));
-program.option("--progress <value>", "Progress type (auto, plain, tty)", "auto");
+program.option("--tty <value>", "TTY mode (auto, true, false)", "auto");
+program.option("--progress <value>", "Progress type (auto, true, false, interval)", "auto");
 program.option("--progress-interval <ms>", "Progress interval", Number, 1000);
 program.option("-o,--output-format <format>", "Output format (json, pjson, yaml, table, custom=$, tpl=name)", "table");
+makeCommand(CommandFactory_1.CommandEnum.startServer).alias("start");
 makeCommand(CommandFactory_1.CommandEnum.config).alias("c");
 makeCommand(CommandFactory_1.CommandEnum.init).alias("i");
 makeCommand(CommandFactory_1.CommandEnum.snapshots).alias("s");
 makeCommand(CommandFactory_1.CommandEnum.prune).alias("p");
 makeCommand(CommandFactory_1.CommandEnum.backup).alias("b");
-makeCommand(CommandFactory_1.CommandEnum.backupSessions).alias("bs");
 makeCommand(CommandFactory_1.CommandEnum.restore).alias("r");
-makeCommand(CommandFactory_1.CommandEnum.restoreSessions).alias("rs");
+makeCommand(CommandFactory_1.CommandEnum.copy).alias("cp");
 makeCommand(CommandFactory_1.CommandEnum.cleanCache).alias("cc");
 function buildArgs(input, options) {
     const optionsArray = Object.keys(options).flatMap((name) => [
@@ -112,7 +121,7 @@ function parseArgs(args) {
         }
         if (!verbose)
             try {
-                (0, fs_2.rmSync)((0, fs_1.sessionTmpDir)(), {
+                (0, fs_2.rmSync)((0, temp_1.sessionTmpDir)(), {
                     force: true,
                     recursive: true,
                     maxRetries: 5,

package/config.schema.json

@@ -444,11 +444,11 @@
     "datatruck-repository": {
       "type": "object",
       "required": [
-        "outPath"
+        "backend"
       ],
       "additionalProperties": false,
       "properties": {
-        "outPath": {
+        "backend": {
           "type": "string"
         },
         "compress": {
@@ -902,6 +902,16 @@
         "csvSharedPath": {
           "type": "string"
         },
+        "compress": {
+          "anyOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "$ref": "#/definitions/compress-util"
+            }
+          ]
+        },
         "password": {
           "anyOf": [
             {
@@ -985,6 +995,43 @@
         "tempDir": {
           "type": "string"
         },
+        "minFreeDiskSpace": {
+          "anyOf": [
+            {
+              "type": "integer"
+            },
+            {
+              "type": "string"
+            }
+          ]
+        },
+        "reports": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "when": {
+                "enum": [
+                  "success",
+                  "error"
+                ]
+              },
+              "format": {
+                "enum": [
+                  "json",
+                  "list",
+                  "pjson",
+                  "table",
+                  "yaml"
+                ]
+              },
+              "run": {
+                "$ref": "#/definitions/script-task_step"
+              }
+            }
+          }
+        },
         "repositories": {
           "type": "array",
           "items": {
@@ -996,6 +1043,42 @@
           "items": {
             "$ref": "#/definitions/package"
           }
+        },
+        "server": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "path": {
+              "type": "string"
+            },
+            "users": {
+              "type": "array",
+              "items": {
+                "type": "object",
+                "additionalProperties": false,
+                "properties": {
+                  "name": {
+                    "type": "string"
+                  },
+                  "password": {
+                    "type": "string"
+                  }
+                }
+              }
+            },
+            "listen": {
+              "type": "object",
+              "additionalProperties": false,
+              "properties": {
+                "port": {
+                  "type": "integer"
+                },
+                "address": {
+                  "type": "string"
+                }
+              }
+            }
+          }
         }
       }
     },
@@ -1075,7 +1158,8 @@
         "type": {
           "enum": [
             "process",
-            "node"
+            "node",
+            "telegram-message"
           ]
         },
         "config": {}
@@ -1118,6 +1202,25 @@
             }
           },
           "else": false
+        },
+        {
+          "if": {
+            "type": "object",
+            "properties": {
+              "type": {
+                "const": "telegram-message"
+              }
+            }
+          },
+          "then": {
+            "type": "object",
+            "properties": {
+              "config": {
+                "$ref": "#/definitions/script-task_telegramMessageStepConfig"
+              }
+            }
+          },
+          "else": false
         }
       ]
     },
@@ -1174,6 +1277,24 @@
           }
         }
       }
+    },
+    "script-task_telegramMessageStepConfig": {
+      "type": "object",
+      "required": [
+        "bot",
+        "chatId"
+      ],
+      "properties": {
+        "command": {
+          "type": "string"
+        },
+        "chatId": {
+          "type": "integer"
+        },
+        "text": {
+          "type": "string"
+        }
+      }
     }
   },
   "$ref": "#/definitions/config"

package/package.json

@@ -1,21 +1,20 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.26.2",
+  "version": "0.28.0",
   "dependencies": {
     "@supercharge/promise-pool": "^3.1.0",
     "ajv": "^8.12.0",
     "async": "^3.2.4",
+    "bytes": "^3.1.2",
     "chalk": "^4.1.2",
-    "cli-table3": "^0.6.3",
     "commander": "^11.0.0",
     "dayjs": "^1.11.10",
     "fast-folder-size": "^2.2.0",
     "fast-glob": "^3.3.1",
+    "listr2": "^7.0.1",
     "micromatch": "^4.0.5",
     "mysql2": "^3.6.1",
-    "pretty-bytes": "^5.6.0",
-    "sqlite": "^5.0.1",
-    "sqlite3": "^5.1.6"
+    "tty-table": "^4.2.2"
   },
   "optionalDependencies": {
     "ts-node": "^10.9.1",

package/utils/DataFormat.d.ts

@@ -1,25 +1,36 @@
-export type FormatType = "json" | "pjson" | "table" | "yaml" | "custom" | "tpl";
-export declare class DataFormat<TItem extends Record<string, unknown>> {
+import { Streams } from "./stream";
+import { Header } from "tty-table";
+export type FormatType = "json" | "list" | "pjson" | "table" | "yaml" | "custom" | "tpl";
+export declare const dataFormats: FormatType[];
+export declare class DataFormat {
     readonly options: {
-        items: TItem[];
-        json?: (item: TItem) => any;
-        table: {
-            labels: string[];
-            handler: (item: TItem) => (string | number | null | undefined)[];
+        streams?: Partial<Streams>;
+        json: any;
+        list?: () => string[];
+        table?: {
+            headers: Header[];
+            rows: () => (string | number | null | undefined)[][];
         };
     };
+    protected streams: Streams;
     constructor(options: {
-        items: TItem[];
-        json?: (item: TItem) => any;
-        table: {
-            labels: string[];
-            handler: (item: TItem) => (string | number | null | undefined)[];
+        streams?: Partial<Streams>;
+        json: any;
+        list?: () => string[];
+        table?: {
+            headers: Header[];
+            rows: () => (string | number | null | undefined)[][];
         };
     });
+    protected getJson(): any;
     protected formatToJson(): string;
     protected formatToPrettyJson(): string;
     protected formatToYaml(): any;
     protected formatToTable(): string;
+    protected formatToList(): string;
+    log(format: FormatType, options?: {
+        tpl?: Record<string, () => string>;
+    }): void;
     format(format: FormatType, options?: {
         tpl?: Record<string, () => string>;
     }): any;