@datatruck/cli 0.30.1 → 0.32.0

package/Action/BackupAction.js

@@ -117,7 +117,7 @@ class BackupAction {
                                         backups: result.filter((r) => !r.error && r.key === "backup")
                                             .length,
                                         copies: result.filter((r) => !r.error && r.key === "copy").length,
-                                    })
+                                    }, color)
                                     : item.key === "report"
                                         ? item.data.type
                                         : "";
@@ -312,14 +312,10 @@ class BackupAction {
                                         return task.skip(`Report send skipped: ${reportIndex}`);
                                     const text = this.dataFormat(result).format(report.format ?? "list");
                                     await (0, steps_1.runSteps)(report.run, {
-                                        verbose: this.options.verbose,
-                                        process: { vars: { DTT_REPORT: text } },
-                                        telegram: { vars: { TEXT: text } },
-                                        node: {
-                                            vars: {
-                                                dtt: { report: text, result },
-                                            },
+                                        vars: {
+                                            dtt: { title: "DTT Backup", text, result, success },
                                         },
+                                        verbose: this.options.verbose,
                                     });
                                 },
                             });

package/Action/ConfigAction.d.ts

@@ -11,6 +11,7 @@ export declare class ConfigAction<TRequired extends boolean = true> {
     static validate(config: ConfigType): void;
     static check(config: ConfigType): void;
     static normalize(config: ConfigType): ConfigType;
+    static parseFile(path: string): Promise<ConfigType>;
     static fromGlobalOptionsWithPath(globalOptions: GlobalOptions<true>): Promise<{
         path: string;
         data: ConfigType;

package/Action/ConfigAction.js

@@ -63,6 +63,12 @@ class ConfigAction {
         });
         return config;
     }
+    static async parseFile(path) {
+        const config = await (0, fs_1.parseFile)(path, "config");
+        ConfigAction.validate(config);
+        ConfigAction.check(config);
+        return ConfigAction.normalize(config);
+    }
     static async fromGlobalOptionsWithPath(globalOptions) {
         if (typeof globalOptions.config !== "string")
             return {
@@ -81,13 +87,8 @@ class ConfigAction {
     }
     async exec() {
         const path = await (0, fs_1.findFile)(this.options.path, "datatruck.config", fs_1.parseFileExtensions, "Config path not found");
-        const config = await (0, fs_1.parseFile)(path, "config");
-        ConfigAction.validate(config);
-        ConfigAction.check(config);
-        return {
-            path,
-            data: ConfigAction.normalize(config),
-        };
+        const data = await ConfigAction.parseFile(path);
+        return { path, data };
     }
 }
 exports.ConfigAction = ConfigAction;

package/Action/CopyAction.js

@@ -40,7 +40,7 @@ class CopyAction {
                             errors: item.data.errors,
                             copied: items.filter((i) => i.key === "copy" && !i.error && !i.data.skipped).length,
                             skipped: items.filter((i) => i.key === "copy" && !i.error && i.data.skipped).length,
-                        })
+                        }, color)
                         : "";
         };
         return new DataFormat_1.DataFormat({

package/Action/RestoreAction.js

@@ -114,7 +114,7 @@ class RestoreAction {
                                 errors: item.data.errors,
                                 restores: result.filter((r) => !r.error && r.key === "restore")
                                     .length,
-                            })
+                            }, color)
                             : "";
         };
         return new DataFormat_1.DataFormat({

package/CHANGELOG.md

@@ -1,5 +1,27 @@
 # @datatruck/cli
 
+## 0.32.0
+
+### Minor Changes
+
+- [`7d755ba`](https://github.com/swordev/datatruck/commit/7d755bac0edf7aea719446f6bfcee5bea0fe9a90) Thanks [@juanrgm](https://github.com/juanrgm)! - Reload repository server config
+
+- [`9dba106`](https://github.com/swordev/datatruck/commit/9dba106865da2d4327282d65deecee5a03e49b49) Thanks [@juanrgm](https://github.com/juanrgm)! - Update to Node.js 20
+
+- [`113ee82`](https://github.com/swordev/datatruck/commit/113ee8258951028d54b798eaaa813982222c20e8) Thanks [@juanrgm](https://github.com/juanrgm)! - Add `ntfy` step
+
+### Patch Changes
+
+- [`c24eea2`](https://github.com/swordev/datatruck/commit/c24eea21b41d78451d5eabd65923daa26dcad78a) Thanks [@juanrgm](https://github.com/juanrgm)! - Simplify step configs
+
+## 0.31.0
+
+### Minor Changes
+
+- [`c98324e`](https://github.com/swordev/datatruck/commit/c98324ebbb5b43113f1bb6d9a07bd905b5883729) Thanks [@juanrgm](https://github.com/juanrgm)! - Add cron server
+
+- [`9b40aad`](https://github.com/swordev/datatruck/commit/9b40aadc3ba57db15f14ae08c342b7170d61aa5d) Thanks [@juanrgm](https://github.com/juanrgm)! - Add multiple backends to the datatruck repository
+
 ## 0.30.1
 
 ### Patch Changes

package/Command/BackupCommand.d.ts

@@ -15,5 +15,5 @@ export type BackupCommandOptions<TResolved = false> = {
 export type BackupCommandResult = Unwrap<BackupAction["exec"]>;
 export declare class BackupCommand extends CommandAbstract<BackupCommandOptions<false>, BackupCommandOptions<true>> {
     onOptions(): import("../utils/cli").OptionsType<BackupCommandOptions<false>, BackupCommandOptions<true>>;
-    onExec(): Promise<0 | 1>;
+    onExec(): Promise<1 | 0>;
 }

package/Command/CleanCacheCommand.d.ts

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

package/Command/CommandAbstract.d.ts

@@ -16,9 +16,10 @@ export type CommandConstructor<TUnresolvedOptions, TOptions extends SimilarObjec
 };
 export declare abstract class CommandAbstract<TUnresolvedOptions, TOptions extends SimilarObject<TUnresolvedOptions>> {
     readonly globalOptions: GlobalOptions<true>;
+    readonly configPath?: string | undefined;
     readonly options: TOptions;
     readonly streams: Streams;
-    constructor(globalOptions: GlobalOptions<true>, options: TUnresolvedOptions, streams?: Partial<Streams>);
+    constructor(globalOptions: GlobalOptions<true>, options: TUnresolvedOptions, streams?: Partial<Streams>, configPath?: string | undefined);
     abstract onOptions(): OptionsType<TUnresolvedOptions, TOptions>;
     protected returnsOptions(options: OptionsType<TUnresolvedOptions, TOptions>): OptionsType<TUnresolvedOptions, TOptions>;
     abstract onExec(): Promise<number>;

package/Command/CommandAbstract.js

@@ -5,10 +5,12 @@ const cli_1 = require("../utils/cli");
 const stream_1 = require("../utils/stream");
 class CommandAbstract {
     globalOptions;
+    configPath;
     options;
     streams;
-    constructor(globalOptions, options, streams = {}) {
+    constructor(globalOptions, options, streams = {}, configPath) {
         this.globalOptions = globalOptions;
+        this.configPath = configPath;
         this.options = (0, cli_1.parseOptions)(options, this.onOptions());
         this.streams = (0, stream_1.createStreams)(streams);
     }

package/Command/CopyCommand.d.ts

@@ -12,5 +12,5 @@ export type CopyCommandOptionsType<TResolved = false> = {
 export type CopyCommandResult = Unwrap<CopyAction["exec"]>;
 export declare class CopyCommand extends CommandAbstract<CopyCommandOptionsType<false>, CopyCommandOptionsType<true>> {
     onOptions(): import("../utils/cli").OptionsType<CopyCommandOptionsType<false>, CopyCommandOptionsType<true>>;
-    onExec(): Promise<0 | 1>;
+    onExec(): Promise<1 | 0>;
 }

package/Command/RestoreCommand.d.ts

@@ -13,5 +13,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<0 | 1>;
+    onExec(): Promise<1 | 0>;
 }

package/Command/StartServerCommand.js

@@ -2,7 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.StartServerCommand = void 0;
 const ConfigAction_1 = require("../Action/ConfigAction");
-const server_1 = require("../utils/datatruck/server");
+const cron_server_1 = require("../utils/datatruck/cron-server");
+const repository_server_1 = require("../utils/datatruck/repository-server");
 const CommandAbstract_1 = require("./CommandAbstract");
 class StartServerCommand extends CommandAbstract_1.CommandAbstract {
     onOptions() {
@@ -10,14 +11,36 @@ class StartServerCommand extends CommandAbstract_1.CommandAbstract {
     }
     async onExec() {
         const config = await ConfigAction_1.ConfigAction.fromGlobalOptions(this.globalOptions);
-        const server = (0, server_1.createDatatruckServer)(config.server || {});
-        const port = config.server?.listen?.port ?? 8888;
-        const address = config.server?.listen?.address ?? "127.0.0.1";
-        console.info(`Listening on http://${address}:${port}`);
-        await new Promise((resolve, reject) => {
+        const verbose = !!this.globalOptions.verbose;
+        const log = config.server?.log ?? true;
+        const repositoryOptions = config.server?.repository || {};
+        if (repositoryOptions.enabled ?? true) {
+            const server = (0, repository_server_1.createDatatruckRepositoryServer)(repositoryOptions, {
+                log,
+                configPath: this.configPath,
+            });
+            const port = repositoryOptions.listen?.port ?? 8888;
+            const address = repositoryOptions.listen?.address ?? "127.0.0.1";
+            console.info(`Listening datatruck repository on http://${address}:${port}`);
+            server.on("error", (error) => {
+                console.error(`SERVER ERROR`, error);
+                process.exit(1);
+            });
             server.listen(port, address);
-            server.on("error", reject);
-        });
+        }
+        const cronOptions = config.server?.cron || {};
+        if (cronOptions.enabled ?? true) {
+            if (typeof this.configPath !== "string")
+                throw new Error(`Config path is required by cron server`);
+            const server = (0, cron_server_1.createCronServer)(cronOptions, {
+                verbose,
+                log,
+                configPath: this.configPath,
+            });
+            server.start();
+            console.info(`Cron server started`);
+        }
+        await new Promise(() => setInterval(() => { }, 60000));
         return 0;
     }
 }

package/Config/Config.d.ts

@@ -1,5 +1,6 @@
 import { FormatType } from "../utils/DataFormat";
-import { DatatruckServerOptions } from "../utils/datatruck/server";
+import { DatatruckCronServerOptions } from "../utils/datatruck/cron-server";
+import { DatatruckRepositoryServerOptions } from "../utils/datatruck/repository-server";
 import { Step } from "../utils/steps";
 import { PackageConfigType } from "./PackageConfig";
 import { PrunePolicyConfigType } from "./PrunePolicyConfig";
@@ -14,6 +15,11 @@ export type ConfigType = {
     reports?: ReportConfig[];
     prunePolicy?: PrunePolicyConfigType;
 };
+export type DatatruckServerOptions = {
+    log?: boolean;
+    repository?: DatatruckRepositoryServerOptions;
+    cron?: DatatruckCronServerOptions;
+};
 export type ReportConfig = {
     when?: "success" | "error";
     format?: Exclude<FormatType, "custom" | "tpl">;

package/Config/Config.js

@@ -2,8 +2,11 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.configDefinition = void 0;
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
+const backup_def_1 = require("../JsonSchema/backup-def");
+const copy_def_1 = require("../JsonSchema/copy-def");
 const ScriptTask_1 = require("../Task/ScriptTask");
 const DataFormat_1 = require("../utils/DataFormat");
+const schema_1 = require("../utils/schema");
 exports.configDefinition = {
     type: "object",
     required: ["repositories", "packages"],
@@ -38,46 +41,96 @@ exports.configDefinition = {
             type: "object",
             additionalProperties: false,
             properties: {
-                path: { type: "string" },
                 log: { type: "boolean" },
-                users: {
-                    type: "array",
-                    items: {
-                        type: "object",
-                        additionalProperties: false,
-                        properties: {
-                            name: { type: "string" },
-                            password: { type: "string" },
-                        },
-                    },
-                },
-                listen: {
+                repository: {
                     type: "object",
                     additionalProperties: false,
                     properties: {
-                        port: { type: "integer" },
-                        address: { type: "string" },
-                    },
-                },
-                trustProxy: {
-                    anyOf: [
-                        { type: "boolean" },
-                        {
+                        enabled: { type: "boolean" },
+                        listen: {
                             type: "object",
                             additionalProperties: false,
-                            required: ["remoteAddressHeader"],
                             properties: {
-                                remoteAddressHeader: { type: "string" },
+                                port: { type: "integer" },
+                                address: { type: "string" },
                             },
                         },
-                    ],
+                        trustProxy: {
+                            anyOf: [
+                                { type: "boolean" },
+                                {
+                                    type: "object",
+                                    additionalProperties: false,
+                                    required: ["remoteAddressHeader"],
+                                    properties: {
+                                        remoteAddressHeader: { type: "string" },
+                                    },
+                                },
+                            ],
+                        },
+                        allowlist: {
+                            type: "object",
+                            additionalProperties: false,
+                            properties: {
+                                enabled: { type: "boolean" },
+                                remoteAddresses: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
+                            },
+                        },
+                        backends: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                additionalProperties: false,
+                                required: ["name", "path"],
+                                properties: {
+                                    name: { type: "string" },
+                                    path: { type: "string" },
+                                    users: {
+                                        type: "array",
+                                        items: {
+                                            type: "object",
+                                            additionalProperties: false,
+                                            required: ["name", "password"],
+                                            properties: {
+                                                enabled: { type: "boolean" },
+                                                name: { type: "string" },
+                                                password: { type: "string" },
+                                            },
+                                        },
+                                    },
+                                },
+                            },
+                        },
+                    },
                 },
-                allowlist: {
+                cron: {
                     type: "object",
                     additionalProperties: false,
                     properties: {
                         enabled: { type: "boolean" },
-                        remoteAddresses: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
+                        actions: {
+                            type: "array",
+                            items: {
+                                allOf: [
+                                    {
+                                        type: "object",
+                                        required: ["schedule"],
+                                        properties: {
+                                            schedule: { type: "string" },
+                                        },
+                                    },
+                                    {
+                                        anyOf: (0, schema_1.createCaseSchema)({
+                                            type: "type",
+                                            value: "options",
+                                        }, {
+                                            backup: (0, schema_1.omitPropertySchema)(backup_def_1.backupCommandOptionDef, "dryRun"),
+                                            copy: copy_def_1.copyCommandOptionsDef,
+                                        }),
+                                    },
+                                ],
+                            },
+                        },
                     },
                 },
             },

package/Config/RepositoryConfig.d.ts

@@ -2,6 +2,7 @@ import { DatatruckRepositoryConfigType, datatruckRepositoryName } from "../Repos
 import { GitRepositoryConfigType, gitRepositoryName } from "../Repository/GitRepository";
 import { ResticRepositoryConfigType, resticRepositoryName } from "../Repository/ResticRepository";
 import type { JSONSchema7 } from "json-schema";
+export declare const repositoryNames: ("git" | "restic" | "datatruck")[];
 export declare const repositoryConfigDefinition: JSONSchema7;
 export type RepositoryConfigTypeType = RepositoryConfigType["type"];
 export type RepositoryConfigEnabledActionType = "backup" | "init" | "prune" | "restore" | "snapshots";

package/Config/RepositoryConfig.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.repositoryConfigDefinition = void 0;
+exports.repositoryConfigDefinition = exports.repositoryNames = void 0;
 const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
 const GitRepository_1 = require("../Repository/GitRepository");
@@ -10,6 +10,11 @@ const types = {
     [DatatruckRepository_1.datatruckRepositoryName]: DefinitionEnum_1.DefinitionEnum.datatruckRepository,
     [GitRepository_1.gitRepositoryName]: DefinitionEnum_1.DefinitionEnum.gitRepository,
 };
+exports.repositoryNames = [
+    ResticRepository_1.resticRepositoryName,
+    DatatruckRepository_1.datatruckRepositoryName,
+    GitRepository_1.gitRepositoryName,
+];
 exports.repositoryConfigDefinition = {
     type: "object",
     additionalProperties: false,

package/Factory/CommandFactory.d.ts

@@ -37,7 +37,7 @@ export type LogMapType = {
     [CommandEnum.snapshots]: SnapshotsCommandResult;
     [CommandEnum.backup]: BackupCommandResult;
 };
-export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): StartServerCommand;
+export declare function CommandFactory<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>, configPath?: string): StartServerCommand;
 export declare function exec<TCommand extends keyof OptionsMapType>(type: TCommand, globalOptions: GlobalOptions<true>, options: OptionsMapType[TCommand], streams?: Partial<Streams>): Promise<number>;
 export declare function createActionInterface(globalOptions: GlobalOptions<true>): {
     [K in keyof OptionsMapType as `${K}`]: (options: OptionsMapType[K]) => Promise<K extends keyof LogMapType ? LogMapType[K] : never>;

package/Factory/CommandFactory.js

@@ -24,9 +24,9 @@ var CommandEnum;
     CommandEnum["cleanCache"] = "clean-cache";
     CommandEnum["startServer"] = "start-server";
 })(CommandEnum || (exports.CommandEnum = CommandEnum = {}));
-function CommandFactory(type, globalOptions, options, streams) {
+function CommandFactory(type, globalOptions, options, streams, configPath) {
     const constructor = CommandConstructorFactory(type);
-    return new constructor(globalOptions, options, streams);
+    return new constructor(globalOptions, options, streams, configPath);
 }
 exports.CommandFactory = CommandFactory;
 async function exec(type, globalOptions, options, streams) {

package/JsonSchema/backup-def.d.ts

@@ -0,0 +1,30 @@
+export declare const backupCommandOptionDef: {
+    type: "object";
+    additionalProperties: false;
+    properties: {
+        package: {
+            type: "string";
+        };
+        packageTask: {
+            type: "string";
+        };
+        repository: {
+            type: "string";
+        };
+        repositoryType: {
+            enum: ("git" | "restic" | "datatruck")[];
+        };
+        tag: {
+            type: "string";
+        };
+        dryRun: {
+            type: "boolean";
+        };
+        date: {
+            type: "string";
+        };
+        prune: {
+            type: "boolean";
+        };
+    };
+};

package/JsonSchema/backup-def.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.backupCommandOptionDef = void 0;
+const RepositoryConfig_1 = require("../Config/RepositoryConfig");
+exports.backupCommandOptionDef = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        package: { type: "string" },
+        packageTask: { type: "string" },
+        repository: { type: "string" },
+        repositoryType: { enum: RepositoryConfig_1.repositoryNames },
+        tag: { type: "string" },
+        dryRun: { type: "boolean" },
+        date: { type: "string" },
+        prune: { type: "boolean" },
+    },
+};

package/JsonSchema/copy-def.d.ts

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

package/JsonSchema/copy-def.js

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

package/Task/ScriptTask.d.ts

@@ -20,22 +20,13 @@ export declare enum ScriptTaskDefinitionEnum {
     step = "step",
     processStepConfig = "processStepConfig",
     nodeStepConfig = "nodeStepConfig",
-    telegramMessageStepConfig = "telegramMessageStepConfig"
+    telegramMessageStepConfig = "telegramMessageStepConfig",
+    ntfyStepConfig = "ntfyStepConfig"
 }
 export declare const scriptTaskName = "script";
 export declare const scriptTaskDefinition: JSONSchema7;
 export declare class ScriptTask extends TaskAbstract<ScriptTaskConfigType> {
     protected verbose?: boolean;
-    protected getVars(data: TaskBackupData | TaskRestoreData): {
-        process: {
-            DTT_SNAPSHOT_ID: string;
-            DTT_SNAPSHOT_DATE: string;
-            DTT_PACKAGE_NAME: string;
-            DTT_PACKAGE_PATH: string | undefined;
-            DTT_SNAPSHOT_PATH: string | undefined;
-        };
-        node: NodeVars;
-    };
     backup(data: TaskBackupData): Promise<{
         snapshotPath: string;
     }>;