@datatruck/cli 0.30.1 → 0.31.0

package/CHANGELOG.md

@@ -1,5 +1,13 @@
 # @datatruck/cli
 
+## 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,35 @@ 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,
+            });
+            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/cli.js

@@ -59,7 +59,7 @@ function makeCommandAction(command) {
             exitCode = await (0, CommandFactory_1.CommandFactory)(command, {
                 ...globalOptions,
                 config: config.data,
-            }, options).onExec();
+            }, options, {}, globalOptions.config).onExec();
         }
         catch (e) {
             const error = e;