@datatruck/cli 0.32.1 → 0.32.2

package/{Repository → lib/Repository}/DatatruckRepository.d.ts

@@ -1,7 +1,6 @@
 import { CompressOptions } from "../utils/tar";
 import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
-import type { JSONSchema7 } from "json-schema";
-export type MetaDataType = {
+export type MetaData = {
     id: string;
     date: string;
     package: string;
@@ -15,7 +14,7 @@ export type MetaDataType = {
         checksum: string;
     }>;
 };
-export type DatatruckRepositoryConfigType = {
+export type DatatruckRepositoryConfig = {
     backend: string;
     compress?: boolean | CompressOptions;
 };
@@ -26,14 +25,12 @@ type PackObject = {
     exclude?: string[];
     onePackByResult?: boolean;
 };
-export type DatatruckPackageRepositoryConfigType = {
+export type DatatruckPackageRepositoryConfig = {
     compress?: boolean | CompressOptions;
     packs?: PackObject[];
 };
 export declare const datatruckRepositoryName = "datatruck";
-export declare const datatruckRepositoryDefinition: JSONSchema7;
-export declare const datatruckPackageRepositoryDefinition: JSONSchema7;
-export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRepositoryConfigType> {
+export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRepositoryConfig> {
     static zipBasenameTpl: string;
     static buildSnapshotName(snapshot: {
         id: string;
@@ -47,14 +44,14 @@ export declare class DatatruckRepository extends RepositoryAbstract<DatatruckRep
         snapshotShortId: string;
         sourcePath: string;
     } | null;
-    static parseMetaData(data: string): Promise<MetaDataType>;
+    static parseMetaData(data: string): Promise<MetaData>;
     getSource(): string;
-    fetchDiskStats(config: DatatruckRepositoryConfigType): Promise<import("../utils/fs").DiskStats>;
+    fetchDiskStats(config: DatatruckRepositoryConfig): Promise<import("../utils/fs").DiskStats>;
     init(data: RepoInitData): Promise<void>;
     prune(data: RepoPruneData): Promise<void>;
     fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
-    backup(data: RepoBackupData<DatatruckPackageRepositoryConfigType>): Promise<void>;
-    copy(data: RepoCopyData<DatatruckRepositoryConfigType>): Promise<void>;
-    restore(data: RepoRestoreData<DatatruckPackageRepositoryConfigType>): Promise<void>;
+    backup(data: RepoBackupData<DatatruckPackageRepositoryConfig>): Promise<void>;
+    copy(data: RepoCopyData<DatatruckRepositoryConfig>): Promise<void>;
+    restore(data: RepoRestoreData<DatatruckPackageRepositoryConfig>): Promise<void>;
 }
 export {};

package/{Repository → lib/Repository}/DatatruckRepository.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DatatruckRepository = exports.datatruckPackageRepositoryDefinition = exports.datatruckRepositoryDefinition = exports.datatruckRepositoryName = void 0;
+exports.DatatruckRepository = exports.datatruckRepositoryName = void 0;
 const AppError_1 = require("../Error/AppError");
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const cli_1 = require("../utils/cli");
 const crypto_1 = require("../utils/crypto");
 const client_1 = require("../utils/datatruck/client");
@@ -18,42 +17,6 @@ const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
 exports.datatruckRepositoryName = "datatruck";
-exports.datatruckRepositoryDefinition = {
-    type: "object",
-    required: ["backend"],
-    additionalProperties: false,
-    properties: {
-        backend: { type: "string" },
-        compress: {
-            anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
-        },
-    },
-};
-exports.datatruckPackageRepositoryDefinition = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        compress: {
-            anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
-        },
-        packs: {
-            type: "array",
-            items: {
-                type: "object",
-                additionalProperties: false,
-                properties: {
-                    name: { type: "string" },
-                    compress: {
-                        anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
-                    },
-                    include: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-                    exclude: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-                    onePackByResult: { type: "boolean" },
-                },
-            },
-        },
-    },
-};
 class DatatruckRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static zipBasenameTpl = `.*.dd.tar.gz`;
     static buildSnapshotName(snapshot, pkg) {

package/lib/Repository/GitRepository.d.ts

@@ -0,0 +1,28 @@
+import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, SnapshotTagEnum, SnapshotTagObject, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
+export type GitRepositoryConfig = {
+    repo: string;
+    branch?: string;
+};
+export type GitPackageRepositoryConfig = {};
+export declare const gitRepositoryName = "git";
+export declare class GitRepository extends RepositoryAbstract<GitRepositoryConfig> {
+    static refPrefix: string;
+    getSource(): string;
+    fetchDiskStats(config: GitRepositoryConfig): Promise<import("../utils/fs").DiskStats | undefined>;
+    static buildSnapshotTagName(tag: Pick<SnapshotTagObject, SnapshotTagEnum.PACKAGE | SnapshotTagEnum.ID>): string;
+    static buildSnapshotTag(tag: SnapshotTagObject): {
+        name: string;
+        message: string;
+    };
+    static isSnapshotTag(name: string): boolean;
+    static parseSnapshotTag(name: string, message: string): (Omit<SnapshotTagObject, "tags"> & {
+        tags: string[];
+    }) | null;
+    static buildBranchName(packageName: string): string;
+    init(data: RepoInitData): Promise<void>;
+    prune(data: RepoPruneData): Promise<void>;
+    fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
+    backup(data: RepoBackupData<GitPackageRepositoryConfig>): Promise<void>;
+    copy(data: RepoCopyData<GitRepositoryConfig>): Promise<void>;
+    restore(data: RepoRestoreData<GitPackageRepositoryConfig>): Promise<void>;
+}

package/{Repository → lib/Repository}/GitRepository.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitRepository = exports.gitPackageRepositoryDefinition = exports.gitRepositoryDefinition = exports.gitRepositoryName = void 0;
+exports.GitRepository = exports.gitRepositoryName = void 0;
 const Git_1 = require("../utils/Git");
 const cli_1 = require("../utils/cli");
 const paths_1 = require("../utils/datatruck/paths");
@@ -16,20 +16,6 @@ const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
 exports.gitRepositoryName = "git";
-exports.gitRepositoryDefinition = {
-    type: "object",
-    additionalProperties: false,
-    required: ["repo"],
-    properties: {
-        repo: { type: "string" },
-        branch: { type: "string" },
-    },
-};
-exports.gitPackageRepositoryDefinition = {
-    type: "object",
-    additionalProperties: false,
-    properties: {},
-};
 class GitRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static refPrefix = "dt";
     getSource() {

package/{Repository → lib/Repository}/RepositoryAbstract.d.ts

@@ -2,8 +2,8 @@ import type { BackupActionOptions } from "../Action/BackupAction";
 import type { InitActionOptions } from "../Action/InitAction";
 import type { RestoreActionOptions } from "../Action/RestoreAction";
 import type { ExtendedSnapshot, SnapshotsActionOptions } from "../Action/SnapshotsAction";
-import type { PackageConfigType } from "../Config/PackageConfig";
-import type { RepositoryConfigType } from "../Config/RepositoryConfig";
+import type { PackageConfig } from "../Config/PackageConfig";
+import type { RepositoryConfig } from "../Config/RepositoryConfig";
 import { type DiskStats } from "../utils/fs";
 import type { Progress } from "../utils/progress";
 export type PreSnapshot = {
@@ -26,14 +26,14 @@ export type RepoFetchSnapshotsData = {
 export type RepoCopyData<TRepositoryConfig> = {
     options: BackupActionOptions;
     snapshot: PreSnapshot;
-    package: PackageConfigType;
+    package: PackageConfig;
     mirrorRepositoryConfig: TRepositoryConfig;
     onProgress: (data: Progress) => void;
 };
 export type RepoBackupData<TPackageConfig> = {
     options: BackupActionOptions;
     snapshot: PreSnapshot;
-    package: Omit<PackageConfigType, "path"> & {
+    package: Omit<PackageConfig, "path"> & {
         path: string;
     };
     packageConfig: TPackageConfig | undefined;
@@ -42,7 +42,7 @@ export type RepoBackupData<TPackageConfig> = {
 export type RepoRestoreData<TPackageConfig> = {
     options: RestoreActionOptions;
     snapshot: PreSnapshot;
-    package: PackageConfigType;
+    package: PackageConfig;
     snapshotPath: string;
     packageConfig: TPackageConfig;
     onProgress: (data: Progress) => void;
@@ -63,7 +63,7 @@ export declare enum SnapshotTagEnum {
     VERSION = "version",
     SIZE = "size"
 }
-export type SnapshotTagObjectType = {
+export type SnapshotTagObject = {
     [SnapshotTagEnum.ID]: string;
     [SnapshotTagEnum.SHORT_ID]: string;
     [SnapshotTagEnum.DATE]: string;
@@ -74,9 +74,9 @@ export type SnapshotTagObjectType = {
     [SnapshotTagEnum.SIZE]: string;
 };
 export declare abstract class RepositoryAbstract<TConfig> {
-    readonly repository: RepositoryConfigType;
+    readonly repository: RepositoryConfig;
     readonly config: TConfig;
-    constructor(repository: RepositoryConfigType);
+    constructor(repository: RepositoryConfig);
     abstract getSource(): string;
     abstract fetchDiskStats(config: TConfig): Promise<DiskStats | undefined>;
     ensureFreeDiskSpace(config: TConfig, minFreeDiskSpace: number | string): Promise<void>;

package/{Repository → lib/Repository}/ResticRepository.d.ts

@@ -1,17 +1,14 @@
-import { RepositoryType } from "../utils/Restic";
-import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, SnapshotTagObjectType, SnapshotTagEnum, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
-import { JSONSchema7 } from "json-schema";
-export type ResticRepositoryConfigType = {
+import { ResticRepositoryUri } from "../utils/Restic";
+import { RepositoryAbstract, RepoBackupData, RepoInitData, RepoRestoreData, RepoFetchSnapshotsData, Snapshot, SnapshotTagObject, SnapshotTagEnum, RepoPruneData, RepoCopyData } from "./RepositoryAbstract";
+export type ResticRepositoryConfig = {
     password: string | {
         path: string;
     };
-    repository: RepositoryType;
+    repository: ResticRepositoryUri;
 };
-export type ResticPackageRepositoryConfigType = {};
+export type ResticPackageRepositoryConfig = {};
 export declare const resticRepositoryName = "restic";
-export declare const resticRepositoryDefinition: JSONSchema7;
-export declare const resticPackageRepositoryDefinition: JSONSchema7;
-export declare class ResticRepository extends RepositoryAbstract<ResticRepositoryConfigType> {
+export declare class ResticRepository extends RepositoryAbstract<ResticRepositoryConfig> {
     static refPrefix: string;
     protected env: {
         RESTIC_PASSWORD?: string;
@@ -28,15 +25,15 @@ export declare class ResticRepository extends RepositoryAbstract<ResticRepositor
         name: SnapshotTagEnum;
         value: string;
     } | null;
-    static parseSnapshotTags(tags: string[]): SnapshotTagObjectType & {
+    static parseSnapshotTags(tags: string[]): SnapshotTagObject & {
         tags: string[];
     };
     getSource(): string;
-    fetchDiskStats(config: ResticRepositoryConfigType): Promise<import("../utils/fs").DiskStats | undefined>;
+    fetchDiskStats(config: ResticRepositoryConfig): Promise<import("../utils/fs").DiskStats | undefined>;
     init(data: RepoInitData): Promise<void>;
     fetchSnapshots(data: RepoFetchSnapshotsData): Promise<Snapshot[]>;
     prune(data: RepoPruneData): Promise<void>;
-    backup(data: RepoBackupData<ResticPackageRepositoryConfigType>): Promise<void>;
-    copy(data: RepoCopyData<ResticRepositoryConfigType>): Promise<void>;
-    restore(data: RepoRestoreData<ResticPackageRepositoryConfigType>): Promise<void>;
+    backup(data: RepoBackupData<ResticPackageRepositoryConfig>): Promise<void>;
+    copy(data: RepoCopyData<ResticRepositoryConfig>): Promise<void>;
+    restore(data: RepoRestoreData<ResticPackageRepositoryConfig>): Promise<void>;
 }

package/{Repository → lib/Repository}/ResticRepository.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ResticRepository = exports.resticPackageRepositoryDefinition = exports.resticRepositoryDefinition = exports.resticRepositoryName = void 0;
+exports.ResticRepository = exports.resticRepositoryName = void 0;
 const AppError_1 = require("../Error/AppError");
 const Restic_1 = require("../utils/Restic");
 const cli_1 = require("../utils/cli");
@@ -18,68 +18,6 @@ const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
 exports.resticRepositoryName = "restic";
-exports.resticRepositoryDefinition = {
-    type: "object",
-    required: ["password", "repository"],
-    additionalProperties: false,
-    properties: {
-        password: {
-            anyOf: [
-                { type: "string" },
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["path"],
-                    properties: {
-                        path: { type: "string" },
-                    },
-                },
-            ],
-        },
-        repository: {
-            type: "object",
-            additionalProperties: false,
-            required: ["backend"],
-            properties: {
-                name: { type: "string" },
-                env: {
-                    type: "object",
-                    patternProperties: {
-                        ".+": { type: "string" },
-                    },
-                },
-                backend: {
-                    enum: ["local", "rest", "sftp", "s3", "azure", "gs", "rclone"],
-                },
-                protocol: {
-                    enum: ["http", "https"],
-                },
-                host: { type: "string" },
-                username: { type: "string" },
-                password: {
-                    anyOf: [
-                        { type: "string" },
-                        {
-                            type: "object",
-                            additionalProperties: false,
-                            required: ["path"],
-                            properties: {
-                                path: { type: "string" },
-                            },
-                        },
-                    ],
-                },
-                port: { type: "integer" },
-                path: { type: "string" },
-            },
-        },
-    },
-};
-exports.resticPackageRepositoryDefinition = {
-    type: "object",
-    additionalProperties: false,
-    properties: {},
-};
 class ResticRepository extends RepositoryAbstract_1.RepositoryAbstract {
     static refPrefix = "dt-";
     env;

package/{Task → lib/Task}/GitTask.d.ts

@@ -1,6 +1,5 @@
 import { TaskBackupData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
-import { JSONSchema7 } from "json-schema";
-export type GitTaskConfigType = {
+export type GitTaskConfig = {
     command?: string;
     /**
      * @default true
@@ -24,8 +23,7 @@ export type GitTaskConfigType = {
     fileCopyConcurrency?: number;
 };
 export declare const gitTaskName = "git";
-export declare const gitTaskDefinition: JSONSchema7;
-export declare class GitTask extends TaskAbstract<GitTaskConfigType> {
+export declare class GitTask extends TaskAbstract<GitTaskConfig> {
     protected verbose?: boolean;
     private get command();
     backup(data: TaskBackupData): Promise<{

package/{Task → lib/Task}/GitTask.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GitTask = exports.gitTaskDefinition = exports.gitTaskName = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
+exports.GitTask = exports.gitTaskName = void 0;
 const cli_1 = require("../utils/cli");
 const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
@@ -15,46 +14,6 @@ const micromatch_1 = require("micromatch");
 const path_1 = require("path");
 const readline_1 = require("readline");
 exports.gitTaskName = "git";
-exports.gitTaskDefinition = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        command: {
-            type: "string",
-        },
-        includeModified: {
-            anyOf: [
-                {
-                    type: "boolean",
-                },
-                (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-            ],
-        },
-        includeUntracked: {
-            anyOf: [
-                {
-                    type: "boolean",
-                },
-                (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-            ],
-        },
-        includeIgnored: {
-            anyOf: [
-                {
-                    type: "boolean",
-                },
-                (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-            ],
-        },
-        includeConfig: {
-            type: "boolean",
-        },
-        fileCopyConcurrency: {
-            type: "integer",
-            minimum: 1,
-        },
-    },
-};
 class GitTask extends TaskAbstract_1.TaskAbstract {
     verbose;
     get command() {

package/{Task → lib/Task}/MariadbTask.d.ts

@@ -1,6 +1,5 @@
 import { TaskBackupData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
-import { JSONSchema7 } from "json-schema";
-export type MariadbTaskConfigType = {
+export type MariadbTaskConfig = {
     command?: string;
     hostname: string;
     username: string;
@@ -24,8 +23,7 @@ export type MariadbTaskConfigType = {
     };
 };
 export declare const mariadbTaskName = "mariadb";
-export declare const mariadbTaskDefinition: JSONSchema7;
-export declare class MariadbTask extends TaskAbstract<MariadbTaskConfigType> {
+export declare class MariadbTask extends TaskAbstract<MariadbTaskConfig> {
     protected verbose?: boolean;
     private get command();
     backup(data: TaskBackupData): Promise<{

package/{Task → lib/Task}/MariadbTask.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MariadbTask = exports.mariadbTaskDefinition = exports.mariadbTaskName = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
+exports.MariadbTask = exports.mariadbTaskName = void 0;
 const cli_1 = require("../utils/cli");
 const fs_1 = require("../utils/fs");
 const math_1 = require("../utils/math");
@@ -15,58 +14,6 @@ const promises_1 = require("fs/promises");
 const os_1 = require("os");
 const path_1 = require("path");
 exports.mariadbTaskName = "mariadb";
-exports.mariadbTaskDefinition = {
-    type: "object",
-    required: ["hostname", "username", "password"],
-    additionalProperties: false,
-    properties: {
-        command: { type: "string" },
-        hostname: { type: "string" },
-        username: { type: "string" },
-        password: {
-            anyOf: [
-                {
-                    type: "string",
-                },
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    required: ["path"],
-                    properties: {
-                        path: { type: "string" },
-                    },
-                },
-            ],
-        },
-        includeTables: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        excludeTables: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        includeDatabases: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        excludeDatabases: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        parallel: {
-            anyOf: [{ type: "integer", minimum: 1 }, { enum: ["auto"] }],
-        },
-        compress: {
-            anyOf: [
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        command: { type: "string" },
-                        args: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-                    },
-                },
-                {
-                    type: "object",
-                    additionalProperties: false,
-                    properties: {
-                        type: { enum: ["gzip", "pigz"] },
-                        args: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-                    },
-                },
-            ],
-        },
-    },
-};
 function normalizeConfig(input) {
     let parallel = input.parallel ?? "auto";
     let cores = (0, os_1.cpus)().length;

package/{Task → lib/Task}/MssqlTask.d.ts

@@ -1,6 +1,5 @@
 import { TaskBackupData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
-import { JSONSchema7 } from "json-schema";
-export type MssqlTaskConfigType = {
+export type MssqlTaskConfig = {
     command?: string;
     hostname?: string;
     username?: string;
@@ -10,8 +9,7 @@ export type MssqlTaskConfigType = {
     excludeDatabases?: string[];
 };
 export declare const mssqlTaskName = "mssql";
-export declare const mssqlTaskDefinition: JSONSchema7;
-export declare class MssqlTask extends TaskAbstract<MssqlTaskConfigType> {
+export declare class MssqlTask extends TaskAbstract<MssqlTaskConfig> {
     static SUFFIX: string;
     protected verbose?: boolean;
     private get command();

package/{Task → lib/Task}/MssqlTask.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MssqlTask = exports.mssqlTaskDefinition = exports.mssqlTaskName = void 0;
+exports.MssqlTask = exports.mssqlTaskName = void 0;
 const AppError_1 = require("../Error/AppError");
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const config_1 = require("../utils/datatruck/config");
 const fs_1 = require("../utils/fs");
 const process_1 = require("../utils/process");
@@ -12,18 +11,6 @@ const promises_1 = require("fs/promises");
 const micromatch_1 = require("micromatch");
 const path_1 = require("path");
 exports.mssqlTaskName = "mssql";
-exports.mssqlTaskDefinition = {
-    type: "object",
-    additionalProperties: false,
-    properties: {
-        command: { type: "string" },
-        hostname: { type: "string" },
-        username: { type: "string" },
-        passwordFile: { type: "string" },
-        includeDatabases: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-        excludeDatabases: (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.stringListUtil),
-    },
-};
 class MssqlTask extends TaskAbstract_1.TaskAbstract {
     static SUFFIX = ".BAK";
     verbose;

package/{Task → lib/Task}/MysqlDumpTask.d.ts

@@ -1,8 +1,8 @@
 import { CompressOptions } from "../utils/tar";
-import { SqlDumpTaskConfigType } from "./SqlDumpTaskAbstract";
+import { SqlDumpTaskConfig } from "./SqlDumpTaskAbstract";
 import { TaskBackupData, TaskPrepareRestoreData, TaskRestoreData, TaskAbstract } from "./TaskAbstract";
 export declare const mysqlDumpTaskName = "mysql-dump";
-export type MysqlDumpTaskConfigType = {
+export type MysqlDumpTaskConfig = {
     /**
      * @default "sql"
      */
@@ -13,9 +13,8 @@ export type MysqlDumpTaskConfigType = {
      */
     concurrency?: number;
     compress?: boolean | CompressOptions;
-} & SqlDumpTaskConfigType;
-export declare const mysqlDumpTaskDefinition: import("json-schema").JSONSchema7;
-export declare class MysqlDumpTask extends TaskAbstract<MysqlDumpTaskConfigType> {
+} & SqlDumpTaskConfig;
+export declare class MysqlDumpTask extends TaskAbstract<MysqlDumpTaskConfig> {
     backup(data: TaskBackupData): Promise<{
         snapshotPath: string;
     }>;

package/{Task → lib/Task}/MysqlDumpTask.js

@@ -1,8 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MysqlDumpTask = exports.mysqlDumpTaskDefinition = exports.mysqlDumpTaskName = void 0;
+exports.MysqlDumpTask = exports.mysqlDumpTaskName = void 0;
 const AppError_1 = require("../Error/AppError");
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
 const async_1 = require("../utils/async");
 const cli_1 = require("../utils/cli");
 const config_1 = require("../utils/datatruck/config");
@@ -12,19 +11,10 @@ const mysql_1 = require("../utils/mysql");
 const string_1 = require("../utils/string");
 const tar_1 = require("../utils/tar");
 const temp_1 = require("../utils/temp");
-const SqlDumpTaskAbstract_1 = require("./SqlDumpTaskAbstract");
 const TaskAbstract_1 = require("./TaskAbstract");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
 exports.mysqlDumpTaskName = "mysql-dump";
-exports.mysqlDumpTaskDefinition = (0, SqlDumpTaskAbstract_1.sqlDumpTaskDefinition)({
-    dataFormat: { enum: ["csv", "sql"] },
-    concurrency: { type: "integer", minimum: 1 },
-    csvSharedPath: { type: "string" },
-    compress: {
-        anyOf: [{ type: "boolean" }, (0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.compressUtil)],
-    },
-});
 const suffix = {
     database: ".database.sql",
     stored: ".stored-programs.sql",

package/{Task → lib/Task}/PostgresqlDumpTask.d.ts

@@ -1,13 +1,11 @@
-import { SqlDumpTaskAbstract, SqlDumpTaskConfigType, TargetDatabaseType } from "./SqlDumpTaskAbstract";
-import { JSONSchema7 } from "json-schema";
+import { SqlDumpTaskAbstract, SqlDumpTaskConfig, TargetDatabase } from "./SqlDumpTaskAbstract";
 export declare const postgresqlDumpTaskName = "postgresql-dump";
-export type PostgresqlDumpTaskConfigType = {} & SqlDumpTaskConfigType;
-export declare const postgresqlDumpTaskDefinition: JSONSchema7;
-export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDumpTaskConfigType> {
+export type PostgresqlDumpTaskConfig = SqlDumpTaskConfig;
+export declare class PostgresqlDumpTask extends SqlDumpTaskAbstract<PostgresqlDumpTaskConfig> {
     buildConnectionArgs(database?: string): Promise<string[]>;
     onDatabaseIsEmpty(name: string): Promise<boolean>;
-    onCreateDatabase(database: TargetDatabaseType): Promise<void>;
-    onExecQuery(query: string): Promise<import("../utils/process").ExecResultType>;
+    onCreateDatabase(database: TargetDatabase): Promise<void>;
+    onExecQuery(query: string): Promise<import("../utils/process").ExecResult>;
     onFetchTableNames(database: string): Promise<string[]>;
     onExportTables(tableNames: string[], output: string, onProgress: (progress: {
         totalBytes: number;

package/{Task → lib/Task}/PostgresqlDumpTask.js

@@ -1,15 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PostgresqlDumpTask = exports.postgresqlDumpTaskDefinition = exports.postgresqlDumpTaskName = void 0;
-const DefinitionEnum_1 = require("../JsonSchema/DefinitionEnum");
+exports.PostgresqlDumpTask = exports.postgresqlDumpTaskName = void 0;
 const process_1 = require("../utils/process");
 const SqlDumpTaskAbstract_1 = require("./SqlDumpTaskAbstract");
 const fs_1 = require("fs");
 const path_1 = require("path");
 exports.postgresqlDumpTaskName = "postgresql-dump";
-exports.postgresqlDumpTaskDefinition = {
-    allOf: [(0, DefinitionEnum_1.makeRef)(DefinitionEnum_1.DefinitionEnum.sqlDumpTask)],
-};
 class PostgresqlDumpTask extends SqlDumpTaskAbstract_1.SqlDumpTaskAbstract {
     async buildConnectionArgs(database) {
         const password = await this.fetchPassword();