@datatruck/cli 0.32.1 → 0.32.3

package/{utils → lib/utils}/process.d.ts

@@ -4,7 +4,10 @@
 import { SpawnOptions, ChildProcess, ChildProcessByStdio } from "child_process";
 import { ReadStream, WriteStream } from "fs";
 import { Readable, Writable } from "stream";
-export type ExecLogSettingsType = {
+export type ProcessEnv = {
+    [name: string]: string | undefined;
+};
+export type ExecLogSettings = {
     colorize?: boolean;
     exec?: boolean;
     stdout?: boolean;
@@ -29,7 +32,7 @@ export interface ExecSettingsInterface {
     } | {
         stream: Readable;
     };
-    log?: ExecLogSettingsType | boolean;
+    log?: ExecLogSettings | boolean;
     onSpawn?: (p: ChildProcess) => void | undefined;
     stdout?: {
         save?: boolean;
@@ -42,7 +45,7 @@ export interface ExecSettingsInterface {
         onData?: (data: string) => void;
         toExitCode?: boolean;
     };
-    onExitCodeError?: (data: ExecResultType, error: Error) => Error | false;
+    onExitCodeError?: (data: ExecResult, error: Error) => Error | false;
 }
 export declare function logExecStdout(input: {
     data: string;
@@ -51,7 +54,7 @@ export declare function logExecStdout(input: {
     lineSalt?: boolean;
 }): void;
 export declare function logExecStderr(data: string, colorize?: boolean): void;
-export type ExecResultType = {
+export type ExecResult = {
     stdout: string;
     stderr: string;
     exitCode: number;
@@ -102,5 +105,5 @@ export declare function createProcess<O1 extends boolean, O2 extends boolean>(co
 } : {}) & (O2 extends true ? {
     stderr: string;
 } : {})>;
-export declare function exec(command: string, argv?: string[], options?: SpawnOptions | null, settings?: ExecSettingsInterface): Promise<ExecResultType>;
+export declare function exec(command: string, argv?: string[], options?: SpawnOptions | null, settings?: ExecSettingsInterface): Promise<ExecResult>;
 export {};

package/lib/utils/reportSteps.d.ts

@@ -0,0 +1,26 @@
+export type TelegramStepConfig = {
+    bot: string;
+    chatId: number;
+};
+export type NtfyStepConfig = {
+    token: string;
+    topic?: string;
+};
+export type ReportStep = {
+    type: "telegram";
+    config: TelegramStepConfig;
+} | {
+    type: "ntfy";
+    config: NtfyStepConfig;
+};
+export type ReportStepOptions = {
+    data: {
+        title: string;
+        message: string;
+        success: boolean;
+    };
+};
+export declare function isReportStep(step: {
+    type: string;
+}): step is Pick<ReportStep, "type">;
+export declare function runReportSteps(input: ReportStep[] | ReportStep, options: ReportStepOptions): Promise<void>;

package/lib/utils/reportSteps.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runReportSteps = exports.isReportStep = void 0;
+const http_1 = require("./http");
+function isReportStep(step) {
+    return step.type === "telegram" || step.type === "ntfy";
+}
+exports.isReportStep = isReportStep;
+async function runReportSteps(input, options) {
+    const steps = Array.isArray(input) ? input : [input];
+    for (const step of steps) {
+        if (step.type === "telegram") {
+            await (0, http_1.post)(`https://api.telegram.org/bot${step.config.bot}/sendMessage`, JSON.stringify({
+                chat_id: step.config.chatId.toString(),
+                text: options.data.message,
+                disable_notification: options.data.success ? false : 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}`, options.data.message, {
+                headers: {
+                    Title: options.data.title,
+                    Priority: options.data.success ? "default" : "high",
+                },
+            });
+        }
+        else {
+            throw new Error(`Invalid step type: ${step.type}`);
+        }
+    }
+}
+exports.runReportSteps = runReportSteps;

package/lib/utils/spawnSteps.d.ts

@@ -0,0 +1,36 @@
+import { ProcessEnv } from "./process";
+export type SpawnData = {
+    [name: string]: any;
+};
+export type CommonSpawnStepConfig = {
+    env?: ProcessEnv;
+    data?: SpawnData;
+    args?: (string | number)[];
+};
+export type ProcessStepConfig = CommonSpawnStepConfig & {
+    command: string;
+};
+export type NodeStepConfig = CommonSpawnStepConfig & {
+    code: string | string[];
+};
+export type ProcessStepConfigItem = {
+    type: "process";
+    config: ProcessStepConfig;
+};
+export type NodeStepConfigItem = {
+    type: "node";
+    config: NodeStepConfig;
+};
+export type SpawnStep = ProcessStepConfigItem | NodeStepConfigItem;
+export type SpawnStepOptions<TData extends Record<string, any>> = {
+    env?: ProcessEnv;
+    data?: TData;
+    cwd?: string;
+    tempDir?: () => Promise<string>;
+    onLine?: (p: string) => any;
+    verbose?: boolean;
+};
+export declare function isSpawnStep(step: {
+    type: string;
+}): step is Pick<SpawnStep, "type">;
+export declare function runSpawnSteps<TData extends Record<string, any>>(input: SpawnStep[] | SpawnStep, options: SpawnStepOptions<TData>): Promise<void>;

package/lib/utils/spawnSteps.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runSpawnSteps = exports.isSpawnStep = void 0;
+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 writeNodeScript(options) {
+    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 data = options.data || {};
+    const keys = Object.keys(data);
+    const json = JSON.stringify(data);
+    const code = Array.isArray(options.code)
+        ? [...options.code].join(";\n")
+        : options.code;
+    await (0, promises_1.writeFile)(scriptPath, `(async function({ ${keys} }) {\n${code};\n})(${json});`);
+    return scriptPath;
+}
+function isSpawnStep(step) {
+    return step.type === "process" || step.type === "node";
+}
+exports.isSpawnStep = isSpawnStep;
+async function runSpawnSteps(input, options) {
+    const steps = Array.isArray(input) ? input : [input];
+    for (const step of steps) {
+        if (step.type === "process" || step.type === "node") {
+            const command = step.type === "process" ? step.config.command : "node";
+            const data = {
+                ...step.config.data,
+                ...options.data,
+            };
+            const args = [
+                ...(step.type === "node"
+                    ? [
+                        await writeNodeScript({
+                            code: step.config.code,
+                            tempDir: options.tempDir,
+                            data,
+                        }),
+                    ]
+                    : []),
+                ...(step.config.args || []).map((arg) => (0, string_1.render)(arg.toString(), data)),
+            ];
+            await (0, process_1.exec)(command, args, {
+                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.runSpawnSteps = runSpawnSteps;

package/{utils → lib/utils}/string.d.ts

@@ -1,8 +1,8 @@
 export declare function snakeCase(value: string, char?: string): string;
-export declare function render(subject: string, vars: Record<string, string | undefined>): string;
+export declare function render(subject: string, data: Record<string, string | undefined>): 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 = {
+export type Uri = {
     protocol?: "http" | "https";
     host?: string;
     username?: string;
@@ -10,7 +10,7 @@ export type UriType = {
     port?: number;
     path?: string;
 };
-export declare function formatUri(input: UriType, hidePassword?: boolean): string;
+export declare function formatUri(input: Uri, hidePassword?: boolean): string;
 export declare function makePathPatterns(values: string[] | undefined): string[] | undefined;
 export declare function match(path: string, include?: string[], exclude?: string[]): boolean;
 export declare function endsWith(input: string, patterns: string[]): boolean;

package/{utils → lib/utils}/string.js

@@ -7,7 +7,7 @@ function snakeCase(value, char = "_") {
     return value.replace(/[A-Z]/g, (letter) => `${char}${letter.toLowerCase()}`);
 }
 exports.snakeCase = snakeCase;
-function render(subject, vars) {
+function render(subject, data) {
     return subject.replace(/{([\w\./]*)}/g, function (match, name) {
         if (!name.length) {
             return "{";
@@ -15,7 +15,7 @@ function render(subject, vars) {
         else if (name === "/") {
             return "}";
         }
-        let ref = vars;
+        let ref = data;
         for (const key of name.split(".")) {
             if (!!ref && typeof ref === "object") {
                 ref = ref[key];
@@ -30,7 +30,7 @@ function render(subject, vars) {
             typeof ref !== "boolean")
             throw new Error(`Variable is not valid: ${name}`, {
                 cause: {
-                    vars,
+                    data,
                     value: ref,
                 },
             });

package/{utils → lib/utils}/tar.d.ts

@@ -1,5 +1,4 @@
 import { BasicProgress } from "./progress";
-import type { JSONSchema7 } from "json-schema";
 export type TarEntry = {
     path: string;
     progress: BasicProgress;
@@ -9,15 +8,9 @@ export type CoresOptions = number | {
 };
 export type CompressOptions = {
     level?: number;
-    /**
-     * @default {percent:50}
-     */
     cores?: CoresOptions;
 };
 export type DecompressOptions = {
-    /**
-     * @default {percent:50}
-     */
     cores?: CoresOptions;
 };
 export type CreateTarOptions = {
@@ -39,7 +32,6 @@ export interface ExtractOptions {
     total?: number;
     onEntry?: (entry: TarEntry) => void;
 }
-export declare const compressDefinition: JSONSchema7;
 export type TarVendor = "busybox" | "bsdtar" | "gnu";
 export declare function getTarVendor(cache?: boolean, log?: boolean): Promise<TarVendor | null>;
 export type ListTarOptions = {

package/{utils → lib/utils}/tar.js

@@ -1,29 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractTar = exports.normalizeTarPath = exports.createTar = exports.checkPigzLib = exports.listTar = exports.getTarVendor = exports.compressDefinition = void 0;
+exports.extractTar = exports.normalizeTarPath = exports.createTar = exports.checkPigzLib = exports.listTar = exports.getTarVendor = void 0;
 const cli_1 = require("./cli");
 const fs_1 = require("./fs");
 const math_1 = require("./math");
 const process_1 = require("./process");
 const promises_1 = require("fs/promises");
 const os_1 = require("os");
-exports.compressDefinition = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        level: { type: "integer" },
-        cores: {
-            anyOf: [
-                { type: "integer" },
-                {
-                    type: "object",
-                    required: ["percent"],
-                    properties: { percent: { type: "integer" } },
-                },
-            ],
-        },
-    },
-};
 let tarVendor;
 async function getTarVendor(cache = true, log = false) {
     if (cache && typeof tarVendor !== "undefined")

package/package.json

@@ -1,28 +1,6 @@
 {
   "name": "@datatruck/cli",
-  "version": "0.32.1",
-  "dependencies": {
-    "@supercharge/promise-pool": "^3.1.0",
-    "ajv": "^8.12.0",
-    "async": "^3.2.4",
-    "chalk": "^4.1.2",
-    "commander": "^11.0.0",
-    "croner": "^7.0.4",
-    "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",
-    "tty-table": "^4.2.2",
-    "yaml": "^2.3.2"
-  },
-  "optionalDependencies": {
-    "ts-node": "^10.9.1"
-  },
-  "engine": {
-    "node": ">=16.0.0"
-  },
+  "version": "0.32.3",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {
@@ -38,8 +16,44 @@
     "email": "juanrgm724@gmail.com",
     "url": "https://github.com/juanrgm"
   },
+  "main": "lib/index.js",
   "bin": {
-    "datatruck": "bin.js",
-    "dtt": "bin.js"
+    "datatruck": "lib/bin.js",
+    "dtt": "lib/bin.js"
+  },
+  "files": [
+    "lib",
+    "config.schema.json"
+  ],
+  "dependencies": {
+    "@supercharge/promise-pool": "^3.1.0",
+    "ajv": "^8.12.0",
+    "async": "^3.2.5",
+    "chalk": "^4.1.2",
+    "commander": "^11.1.0",
+    "croner": "^7.0.5",
+    "dayjs": "^1.11.10",
+    "fast-folder-size": "^2.2.0",
+    "fast-glob": "^3.3.2",
+    "listr2": "^8.0.0",
+    "micromatch": "^4.0.5",
+    "mysql2": "^3.6.5",
+    "tty-table": "^4.2.3",
+    "yaml": "^2.3.4"
+  },
+  "devDependencies": {
+    "@types/async": "^3.2.24",
+    "@types/micromatch": "^4.0.6"
+  },
+  "optionalDependencies": {
+    "ts-node": "^10.9.1"
+  },
+  "engine": {
+    "node": ">=20.0.0"
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "clean": "tsc -b tsconfig.build.json --clean",
+    "watch": "tsc -b tsconfig.build.json -w"
   }
 }