@datatruck/cli 0.32.1 → 0.32.2

package/Config/Config.js

@@ -1,140 +0,0 @@
-"use strict";
-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"],
-    additionalProperties: false,
-    properties: {
-        $schema: { type: "string" },
-        tempDir: { type: "string" },
-        minFreeDiskSpace: { anyOf: [{ type: "integer" }, { type: "string" }] },
-        reports: {
-            type: "array",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                    when: { enum: ["success", "error"] },
-                    format: {
-                        enum: DataFormat_1.dataFormats.filter((f) => !["custom", "tpl"].includes(f)),
-                    },
-                    run: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.scriptTask, ScriptTask_1.ScriptTaskDefinitionEnum.step),
-                },
-            },
-        },
-        repositories: {
-            type: "array",
-            items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.repository),
-        },
-        packages: {
-            type: "array",
-            items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.package),
-        },
-        server: {
-            type: "object",
-            additionalProperties: false,
-            properties: {
-                log: { type: "boolean" },
-                repository: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        enabled: { type: "boolean" },
-                        listen: {
-                            type: "object",
-                            additionalProperties: false,
-                            properties: {
-                                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" },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                cron: {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        enabled: { type: "boolean" },
-                        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,
-                                        }),
-                                    },
-                                ],
-                            },
-                        },
-                    },
-                },
-            },
-        },
-        prunePolicy: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.prunePolicy),
-    },
-};

package/Config/PackageConfig.d.ts

@@ -1,23 +0,0 @@
-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 type PackageConfigType = {
-    name: string;
-    enabled?: boolean;
-    task?: TaskConfigType;
-    path?: string;
-    restorePath?: string;
-    meta?: Record<string, any>;
-    restorePermissions?: {
-        uid: string | number;
-        gid: string | number;
-    };
-    include?: (string | Step)[];
-    exclude?: (string | Step)[];
-    repositoryNames?: string[];
-    prunePolicy?: PrunePolicyConfigType;
-    repositoryConfigs?: PackageRepositoryConfigType[];
-};

package/Config/PackageConfig.js

@@ -1,51 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageConfigDefinition = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-const ScriptTask_1 = require("../Task/ScriptTask");
-exports.packageConfigDefinition = {
-    type: "object",
-    required: ["name"],
-    additionalProperties: false,
-    properties: {
-        name: { type: "string" },
-        enabled: { type: "boolean" },
-        task: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.task),
-        path: { type: "string" },
-        restorePath: { type: "string" },
-        meta: { type: "object" },
-        restorePermissions: {
-            type: "object",
-            required: ["uid", "gid"],
-            additionalProperties: false,
-            properties: {
-                uid: { anyOf: [{ type: "string" }, { type: "integer" }] },
-                gid: { anyOf: [{ type: "string" }, { type: "integer" }] },
-            },
-        },
-        include: {
-            type: "array",
-            items: {
-                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.scriptTask, ScriptTask_1.ScriptTaskDefinitionEnum.step),
-                ],
-            },
-        },
-        repositoryNames: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        repositoryConfigs: {
-            type: "array",
-            items: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.packageRepository),
-        },
-        prunePolicy: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.prunePolicy),
-    },
-};

package/Config/PackageRepositoryConfig.d.ts

@@ -1,17 +0,0 @@
-import { DatatruckPackageRepositoryConfigType, datatruckRepositoryName } from "../Repository/DatatruckRepository";
-import { GitPackageRepositoryConfigType, gitRepositoryName } from "../Repository/GitRepository";
-import { ResticPackageRepositoryConfigType, resticRepositoryName } from "../Repository/ResticRepository";
-import type { JSONSchema7 } from "json-schema";
-export declare const packageRepositoryConfigDefinition: JSONSchema7;
-export type PackageRepositoryConfigType = {
-    names?: string[];
-} & ({
-    type: typeof resticRepositoryName;
-    config: ResticPackageRepositoryConfigType;
-} | {
-    type: typeof datatruckRepositoryName;
-    config: DatatruckPackageRepositoryConfigType;
-} | {
-    type: typeof gitRepositoryName;
-    config: GitPackageRepositoryConfigType;
-});

package/Config/PackageRepositoryConfig.js

@@ -1,37 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.packageRepositoryConfigDefinition = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
-const GitRepository_1 = require("../Repository/GitRepository");
-const ResticRepository_1 = require("../Repository/ResticRepository");
-const types = {
-    [ResticRepository_1.resticRepositoryName]: DefinitionEnum_1.DefinitionEnum.resticPackageRepository,
-    [DatatruckRepository_1.datatruckRepositoryName]: DefinitionEnum_1.DefinitionEnum.datatruckPackageRepository,
-    [GitRepository_1.gitRepositoryName]: DefinitionEnum_1.DefinitionEnum.gitPackageRepository,
-};
-exports.packageRepositoryConfigDefinition = {
-    type: "object",
-    additionalProperties: false,
-    required: ["type"],
-    properties: {
-        type: { type: "string" },
-        names: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        config: {},
-    },
-    anyOf: Object.keys(types).map((type) => ({
-        if: {
-            type: "object",
-            properties: {
-                type: { const: type },
-            },
-        },
-        then: {
-            type: "object",
-            properties: {
-                config: (0, DefinitionEnum_1.makeRef)(types[type]),
-            },
-        },
-        else: false,
-    })),
-};

package/Config/PrunePolicyConfig.d.ts

@@ -1,4 +0,0 @@
-import { PruneActionsOptions } from "../Action/PruneAction";
-import { JSONSchema7 } from "json-schema";
-export declare const prunePolicyConfigDefinition: JSONSchema7;
-export type PrunePolicyConfigType = Pick<PruneActionsOptions, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;

package/Config/PrunePolicyConfig.js

@@ -1,28 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.prunePolicyConfigDefinition = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-exports.prunePolicyConfigDefinition = {
-    type: "object",
-    properties: {
-        keepDaily: { type: "integer" },
-        keepHourly: { type: "integer" },
-        keepMinutely: { type: "integer" },
-        keepLast: { type: "integer" },
-        keepMonthly: { type: "integer" },
-        keepWeekly: { type: "integer" },
-        keepYearly: { type: "integer" },
-        groupBy: {
-            type: "array",
-            items: {
-                type: "string",
-                enum: [
-                    "packageName",
-                    "repositoryName",
-                    "repositoryType",
-                ],
-            },
-        },
-        tags: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-    },
-};

package/Config/RepositoryConfig.d.ts

@@ -1,24 +0,0 @@
-import { DatatruckRepositoryConfigType, datatruckRepositoryName } from "../Repository/DatatruckRepository";
-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";
-export type RepositoryConfigType = {
-    name: string;
-    mirrorRepoNames?: string[];
-    enabled?: boolean | {
-        [K in "defaults" | RepositoryConfigEnabledActionType]?: boolean;
-    };
-} & ({
-    type: typeof resticRepositoryName;
-    config: ResticRepositoryConfigType;
-} | {
-    type: typeof datatruckRepositoryName;
-    config: DatatruckRepositoryConfigType;
-} | {
-    type: typeof gitRepositoryName;
-    config: GitRepositoryConfigType;
-});

package/Config/RepositoryConfig.js

@@ -1,62 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.repositoryConfigDefinition = exports.repositoryNames = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
-const GitRepository_1 = require("../Repository/GitRepository");
-const ResticRepository_1 = require("../Repository/ResticRepository");
-const types = {
-    [ResticRepository_1.resticRepositoryName]: DefinitionEnum_1.DefinitionEnum.resticRepository,
-    [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,
-    required: ["type", "name"],
-    properties: {
-        type: { type: "string" },
-        name: { type: "string" },
-        mirrorRepoNames: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        enabled: {
-            anyOf: [
-                {
-                    type: "boolean",
-                },
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        defaults: { type: "boolean" },
-                        backup: { type: "boolean" },
-                        init: { type: "boolean" },
-                        prune: { type: "boolean" },
-                        restore: { type: "boolean" },
-                        snapshots: { type: "boolean" },
-                    },
-                },
-            ],
-        },
-        config: {},
-    },
-    anyOf: Object.keys(types).map((type) => ({
-        if: {
-            type: "object",
-            properties: {
-                type: { const: type },
-            },
-        },
-        then: {
-            type: "object",
-            properties: {
-                config: (0, DefinitionEnum_1.makeRef)(types[type]),
-            },
-        },
-        else: false,
-    })),
-};

package/Config/TaskConfig.d.ts

@@ -1,27 +0,0 @@
-import { GitTaskConfigType, gitTaskName } from "../Task/GitTask";
-import { MariadbTaskConfigType, mariadbTaskName } from "../Task/MariadbTask";
-import { MssqlTaskConfigType, mssqlTaskName } from "../Task/MssqlTask";
-import { MysqlDumpTaskConfigType, mysqlDumpTaskName } from "../Task/MysqlDumpTask";
-import { PostgresqlDumpTaskConfigType, postgresqlDumpTaskName } from "../Task/PostgresqlDumpTask";
-import { ScriptTaskConfigType, scriptTaskName } from "../Task/ScriptTask";
-import { JSONSchema7 } from "json-schema";
-export declare const taskConfigDefinition: JSONSchema7;
-export type TaskConfigType = {
-    name: typeof gitTaskName;
-    config?: GitTaskConfigType;
-} | {
-    name: typeof mariadbTaskName;
-    config: MariadbTaskConfigType;
-} | {
-    name: typeof mssqlTaskName;
-    config: MssqlTaskConfigType;
-} | {
-    name: typeof mysqlDumpTaskName;
-    config: MysqlDumpTaskConfigType;
-} | {
-    name: typeof postgresqlDumpTaskName;
-    config: PostgresqlDumpTaskConfigType;
-} | {
-    name: typeof scriptTaskName;
-    config: ScriptTaskConfigType;
-};

package/Config/TaskConfig.js

@@ -1,41 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.taskConfigDefinition = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
-const GitTask_1 = require("../Task/GitTask");
-const MariadbTask_1 = require("../Task/MariadbTask");
-const MssqlTask_1 = require("../Task/MssqlTask");
-const MysqlDumpTask_1 = require("../Task/MysqlDumpTask");
-const PostgresqlDumpTask_1 = require("../Task/PostgresqlDumpTask");
-const ScriptTask_1 = require("../Task/ScriptTask");
-const names = {
-    [GitTask_1.gitTaskName]: DefinitionEnum_1.DefinitionEnum.gitTask,
-    [MariadbTask_1.mariadbTaskName]: DefinitionEnum_1.DefinitionEnum.mariadbTask,
-    [MssqlTask_1.mssqlTaskName]: DefinitionEnum_1.DefinitionEnum.mssqlTask,
-    [MysqlDumpTask_1.mysqlDumpTaskName]: DefinitionEnum_1.DefinitionEnum.mysqlDumpTask,
-    [PostgresqlDumpTask_1.postgresqlDumpTaskName]: DefinitionEnum_1.DefinitionEnum.postgresqlDumpTask,
-    [ScriptTask_1.scriptTaskName]: DefinitionEnum_1.DefinitionEnum.scriptTask,
-};
-exports.taskConfigDefinition = {
-    type: "object",
-    required: ["name"],
-    properties: {
-        name: { enum: Object.keys(names) },
-        config: {},
-    },
-    anyOf: Object.keys(names).map((name) => ({
-        if: {
-            type: "object",
-            properties: {
-                name: { const: name },
-            },
-        },
-        then: {
-            type: "object",
-            properties: {
-                config: (0, DefinitionEnum_1.makeRef)(names[name]),
-            },
-        },
-        else: false,
-    })),
-};

package/Factory/RepositoryFactory.d.ts

@@ -1,3 +0,0 @@
-import type { RepositoryConfigType } from "../Config/RepositoryConfig";
-import type { RepositoryAbstract } from "../Repository/RepositoryAbstract";
-export declare function createRepo(repository: RepositoryConfigType): RepositoryAbstract<any>;

package/Factory/TaskFactory.d.ts

@@ -1,3 +0,0 @@
-import { TaskConfigType } from "../Config/TaskConfig";
-import type { TaskAbstract } from "../Task/TaskAbstract";
-export declare function createTask(task: TaskConfigType): TaskAbstract;

package/JsonSchema/DefinitionEnum.d.ts

@@ -1,26 +0,0 @@
-export declare enum DefinitionEnum {
-    config = "config",
-    repository = "repository",
-    package = "package",
-    packageRepository = "package-repository",
-    task = "task",
-    resticRepository = "restic-repository",
-    resticPackageRepository = "restic-package-repository",
-    datatruckRepository = "datatruck-repository",
-    datatruckPackageRepository = "datatruck-package-repository",
-    gitRepository = "git-repository",
-    gitPackageRepository = "git-package-repository",
-    gitTask = "git-task",
-    scriptTask = "script-task",
-    mariadbTask = "mariadb-task",
-    mssqlTask = "mssql-task",
-    mysqlDumpTask = "mysql-dump-task",
-    postgresqlDumpTask = "postgresql-dump-task",
-    sqlDumpTask = "sqldump-task",
-    stringListUtil = "stringlist-util",
-    prunePolicy = "prune-policy",
-    compressUtil = "compress-util"
-}
-export declare function makeRef(type: DefinitionEnum, subType?: string): {
-    $ref: string;
-};

package/JsonSchema/DefinitionEnum.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.makeRef = exports.DefinitionEnum = void 0;
-var DefinitionEnum;
-(function (DefinitionEnum) {
-    DefinitionEnum["config"] = "config";
-    DefinitionEnum["repository"] = "repository";
-    DefinitionEnum["package"] = "package";
-    DefinitionEnum["packageRepository"] = "package-repository";
-    DefinitionEnum["task"] = "task";
-    DefinitionEnum["resticRepository"] = "restic-repository";
-    DefinitionEnum["resticPackageRepository"] = "restic-package-repository";
-    DefinitionEnum["datatruckRepository"] = "datatruck-repository";
-    DefinitionEnum["datatruckPackageRepository"] = "datatruck-package-repository";
-    DefinitionEnum["gitRepository"] = "git-repository";
-    DefinitionEnum["gitPackageRepository"] = "git-package-repository";
-    DefinitionEnum["gitTask"] = "git-task";
-    DefinitionEnum["scriptTask"] = "script-task";
-    DefinitionEnum["mariadbTask"] = "mariadb-task";
-    DefinitionEnum["mssqlTask"] = "mssql-task";
-    DefinitionEnum["mysqlDumpTask"] = "mysql-dump-task";
-    DefinitionEnum["postgresqlDumpTask"] = "postgresql-dump-task";
-    DefinitionEnum["sqlDumpTask"] = "sqldump-task";
-    DefinitionEnum["stringListUtil"] = "stringlist-util";
-    DefinitionEnum["prunePolicy"] = "prune-policy";
-    DefinitionEnum["compressUtil"] = "compress-util";
-})(DefinitionEnum || (exports.DefinitionEnum = DefinitionEnum = {}));
-function makeRef(type, subType) {
-    return {
-        $ref: `#/definitions/${type}` + (subType ? `_${subType}` : ""),
-    };
-}
-exports.makeRef = makeRef;

package/JsonSchema/JsonSchema.d.ts

@@ -1,4 +0,0 @@
-import { DefinitionEnum } from "./DefinitionEnum";
-import { JSONSchema7 } from "json-schema";
-export declare const definitions: Record<DefinitionEnum, JSONSchema7>;
-export declare const schema: JSONSchema7;

package/JsonSchema/JsonSchema.js

@@ -1,65 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.schema = exports.definitions = void 0;
-const Config_1 = require("../Config/Config");
-const PackageConfig_1 = require("../Config/PackageConfig");
-const PackageRepositoryConfig_1 = require("../Config/PackageRepositoryConfig");
-const PrunePolicyConfig_1 = require("../Config/PrunePolicyConfig");
-const RepositoryConfig_1 = require("../Config/RepositoryConfig");
-const TaskConfig_1 = require("../Config/TaskConfig");
-const DatatruckRepository_1 = require("../Repository/DatatruckRepository");
-const GitRepository_1 = require("../Repository/GitRepository");
-const ResticRepository_1 = require("../Repository/ResticRepository");
-const GitTask_1 = require("../Task/GitTask");
-const MariadbTask_1 = require("../Task/MariadbTask");
-const MssqlTask_1 = require("../Task/MssqlTask");
-const MysqlDumpTask_1 = require("../Task/MysqlDumpTask");
-const PostgresqlDumpTask_1 = require("../Task/PostgresqlDumpTask");
-const ScriptTask_1 = require("../Task/ScriptTask");
-const SqlDumpTaskAbstract_1 = require("../Task/SqlDumpTaskAbstract");
-const tar_1 = require("../utils/tar");
-const DefinitionEnum_1 = require("./DefinitionEnum");
-exports.definitions = {
-    [DefinitionEnum_1.DefinitionEnum.stringListUtil]: {
-        type: "array",
-        items: {
-            type: "string",
-        },
-    },
-    [DefinitionEnum_1.DefinitionEnum.repository]: RepositoryConfig_1.repositoryConfigDefinition,
-    [DefinitionEnum_1.DefinitionEnum.package]: PackageConfig_1.packageConfigDefinition,
-    [DefinitionEnum_1.DefinitionEnum.packageRepository]: PackageRepositoryConfig_1.packageRepositoryConfigDefinition,
-    [DefinitionEnum_1.DefinitionEnum.task]: TaskConfig_1.taskConfigDefinition,
-    [DefinitionEnum_1.DefinitionEnum.gitRepository]: GitRepository_1.gitRepositoryDefinition,
-    [DefinitionEnum_1.DefinitionEnum.gitPackageRepository]: GitRepository_1.gitPackageRepositoryDefinition,
-    [DefinitionEnum_1.DefinitionEnum.datatruckRepository]: DatatruckRepository_1.datatruckRepositoryDefinition,
-    [DefinitionEnum_1.DefinitionEnum.datatruckPackageRepository]: DatatruckRepository_1.datatruckPackageRepositoryDefinition,
-    [DefinitionEnum_1.DefinitionEnum.resticRepository]: ResticRepository_1.resticRepositoryDefinition,
-    [DefinitionEnum_1.DefinitionEnum.resticPackageRepository]: ResticRepository_1.resticPackageRepositoryDefinition,
-    [DefinitionEnum_1.DefinitionEnum.gitTask]: GitTask_1.gitTaskDefinition,
-    [DefinitionEnum_1.DefinitionEnum.scriptTask]: ScriptTask_1.scriptTaskDefinition,
-    [DefinitionEnum_1.DefinitionEnum.sqlDumpTask]: (0, SqlDumpTaskAbstract_1.sqlDumpTaskDefinition)(),
-    [DefinitionEnum_1.DefinitionEnum.mariadbTask]: MariadbTask_1.mariadbTaskDefinition,
-    [DefinitionEnum_1.DefinitionEnum.mssqlTask]: MssqlTask_1.mssqlTaskDefinition,
-    [DefinitionEnum_1.DefinitionEnum.mysqlDumpTask]: MysqlDumpTask_1.mysqlDumpTaskDefinition,
-    [DefinitionEnum_1.DefinitionEnum.postgresqlDumpTask]: PostgresqlDumpTask_1.postgresqlDumpTaskDefinition,
-    [DefinitionEnum_1.DefinitionEnum.config]: Config_1.configDefinition,
-    [DefinitionEnum_1.DefinitionEnum.prunePolicy]: PrunePolicyConfig_1.prunePolicyConfigDefinition,
-    [DefinitionEnum_1.DefinitionEnum.compressUtil]: tar_1.compressDefinition,
-};
-for (const key in exports.definitions) {
-    const schemaKey = key;
-    const schema = exports.definitions[schemaKey];
-    for (const defName in schema.definitions || {}) {
-        exports.definitions[`${schemaKey}_${defName}`] =
-            schema.definitions[defName];
-    }
-    exports.definitions[schemaKey] = {
-        ...schema,
-    };
-    delete exports.definitions[schemaKey].definitions;
-}
-exports.schema = {
-    definitions: exports.definitions,
-    ...(0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.config),
-};

package/JsonSchema/backup-def.d.ts

@@ -1,30 +0,0 @@
-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

@@ -1,18 +0,0 @@
-"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" },
-    },
-};