@datatruck/cli 0.32.3 → 0.34.0

package/lib/utils/cron.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.formatCronScheduleObject = void 0;
+function formatCronScheduleObject(object) {
+    const keys = [
+        "minute",
+        "hour",
+        "day",
+        "month",
+        "weekDay",
+    ];
+    const result = [];
+    for (const key of keys) {
+        const value = object[key];
+        if (typeof value === "number") {
+            result.push(value.toString());
+        }
+        else if (!!value && typeof value === "object") {
+            result.push(`*/${value.each}`);
+        }
+        else {
+            result.push("*");
+        }
+    }
+    return result.join(" ");
+}
+exports.formatCronScheduleObject = formatCronScheduleObject;

package/lib/utils/datatruck/client.d.ts

@@ -23,7 +23,9 @@ export declare class RemoteFs extends AbstractFs {
     download(source: string, target: string, options?: {
         timeout?: number;
         onProgress?: (progress: BasicProgress) => void;
-    }): Promise<void>;
+    }): Promise<{
+        bytes: number;
+    }>;
 }
 export declare function isRemoteBackend(backend: string): boolean;
 export declare function createFs(backend: string): AbstractFs;

package/lib/utils/datatruck/client.js

@@ -80,7 +80,7 @@ class RemoteFs extends virtual_fs_1.AbstractFs {
         });
     }
     async download(source, target, options = {}) {
-        await (0, http_1.downloadFile)(`${this.url}/download`, target, {
+        return await (0, http_1.downloadFile)(`${this.url}/download`, target, {
             ...options,
             headers: this.headers,
             query: { params: JSON.stringify([source]) },

package/lib/utils/datatruck/command.d.ts

@@ -0,0 +1,29 @@
+import { BackupCommand } from "../../commands/BackupCommand";
+import { CleanCacheCommand } from "../../commands/CleanCacheCommand";
+import { GlobalOptions } from "../../commands/CommandAbstract";
+import { ConfigCommand } from "../../commands/ConfigCommand";
+import { CopyCommand } from "../../commands/CopyCommand";
+import { InitCommand } from "../../commands/InitCommand";
+import { PruneCommand } from "../../commands/PruneCommand";
+import { RestoreCommand } from "../../commands/RestoreCommand";
+import { SnapshotsCommand } from "../../commands/SnapshotsCommand";
+import { StartServerCommand } from "../../commands/StartServerCommand";
+import { Streams } from "../stream";
+export declare const datatruckCommandMap: {
+    config: typeof ConfigCommand;
+    init: typeof InitCommand;
+    snapshots: typeof SnapshotsCommand;
+    prune: typeof PruneCommand;
+    backup: typeof BackupCommand;
+    restore: typeof RestoreCommand;
+    copy: typeof CopyCommand;
+    cleanCache: typeof CleanCacheCommand;
+    startServer: typeof StartServerCommand;
+};
+export type DatatruckCommandMap = typeof datatruckCommandMap;
+export type InferDatatruckCommandOptions<T extends keyof DatatruckCommandMap> = InstanceType<DatatruckCommandMap[T]>["inputOptions"];
+export type InferDatatruckCommandResult<T extends keyof DatatruckCommandMap, R = Awaited<ReturnType<InstanceType<DatatruckCommandMap[T]>["exec"]>>> = "result" extends keyof R ? R["result"] : undefined;
+export declare function createCommand<T extends keyof DatatruckCommandMap>(name: T, globalOptions: GlobalOptions<true>, options: InferDatatruckCommandOptions<T>, streams?: Partial<Streams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | InitCommand | RestoreCommand | SnapshotsCommand | StartServerCommand;
+export declare function createCommands(globalOptions: GlobalOptions<true>): {
+    [K in keyof DatatruckCommandMap as `${K}`]: (options: InferDatatruckCommandOptions<K>) => Promise<InferDatatruckCommandResult<K>>;
+};

package/lib/utils/datatruck/command.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCommands = exports.createCommand = exports.datatruckCommandMap = void 0;
+const BackupCommand_1 = require("../../commands/BackupCommand");
+const CleanCacheCommand_1 = require("../../commands/CleanCacheCommand");
+const ConfigCommand_1 = require("../../commands/ConfigCommand");
+const CopyCommand_1 = require("../../commands/CopyCommand");
+const InitCommand_1 = require("../../commands/InitCommand");
+const PruneCommand_1 = require("../../commands/PruneCommand");
+const RestoreCommand_1 = require("../../commands/RestoreCommand");
+const SnapshotsCommand_1 = require("../../commands/SnapshotsCommand");
+const StartServerCommand_1 = require("../../commands/StartServerCommand");
+const error_1 = require("./error");
+const stream_1 = require("stream");
+exports.datatruckCommandMap = {
+    config: ConfigCommand_1.ConfigCommand,
+    init: InitCommand_1.InitCommand,
+    snapshots: SnapshotsCommand_1.SnapshotsCommand,
+    prune: PruneCommand_1.PruneCommand,
+    backup: BackupCommand_1.BackupCommand,
+    restore: RestoreCommand_1.RestoreCommand,
+    copy: CopyCommand_1.CopyCommand,
+    cleanCache: CleanCacheCommand_1.CleanCacheCommand,
+    startServer: StartServerCommand_1.StartServerCommand,
+};
+function createCommand(name, globalOptions, options, streams, configPath) {
+    const constructor = exports.datatruckCommandMap[name];
+    if (!constructor)
+        throw new error_1.AppError(`Invalid command name: ${name}`);
+    return new constructor(globalOptions, options, streams, configPath);
+}
+exports.createCommand = createCommand;
+function createCommands(globalOptions) {
+    const object = {};
+    for (const name in exports.datatruckCommandMap) {
+        object[name] = async (options) => {
+            let stdoutData = "";
+            const stdout = new stream_1.Writable({
+                write(chunk, encoding, callback) {
+                    stdoutData += chunk.toString();
+                    process.stdout.write(chunk, encoding, callback);
+                },
+            }).on("data", (chunk) => (stdoutData += chunk.toString()));
+            const end = () => !stdout.closed &&
+                new Promise((resolve) => stdout.end().on("close", resolve));
+            try {
+                const command = createCommand(name, { ...globalOptions, outputFormat: "json", verbose: 1 }, options, { stdout });
+                const { exitCode } = await command.exec();
+                if (exitCode !== 0)
+                    throw new Error(`Invalid exit code: ${exitCode}`);
+                await end();
+                return JSON.parse(stdoutData);
+            }
+            finally {
+                await end();
+            }
+        };
+    }
+    return object;
+}
+exports.createCommands = createCommands;

package/lib/{Config/RepositoryConfig.d.ts → utils/datatruck/config-repository-type.d.ts}

@@ -1,11 +1,18 @@
-import { DatatruckRepositoryConfig, datatruckRepositoryName } from "../Repository/DatatruckRepository";
-import { GitRepositoryConfig, gitRepositoryName } from "../Repository/GitRepository";
-import { ResticRepositoryConfig, resticRepositoryName } from "../Repository/ResticRepository";
-export type RepositoryConfigType = RepositoryConfig["type"];
-export type RepositoryConfigEnabledAction = "backup" | "init" | "prune" | "restore" | "snapshots";
-export type RepositoryEnabledObject = {
-    [K in "defaults" | RepositoryConfigEnabledAction]?: boolean;
-};
+import type { DatatruckPackageRepositoryConfig, DatatruckRepositoryConfig, datatruckRepositoryName } from "../../repositories/DatatruckRepository";
+import type { GitPackageRepositoryConfig, GitRepositoryConfig, gitRepositoryName } from "../../repositories/GitRepository";
+import type { ResticPackageRepositoryConfig, ResticRepositoryConfig, resticRepositoryName } from "../../repositories/ResticRepository";
+export type PackageRepositoryConfig = {
+    names?: string[];
+} & ({
+    type: typeof resticRepositoryName;
+    config: ResticPackageRepositoryConfig;
+} | {
+    type: typeof datatruckRepositoryName;
+    config: DatatruckPackageRepositoryConfig;
+} | {
+    type: typeof gitRepositoryName;
+    config: GitPackageRepositoryConfig;
+});
 export type ResticRepositoryConfigItem = {
     type: typeof resticRepositoryName;
     config: ResticRepositoryConfig;
@@ -18,6 +25,10 @@ export type GitRepositoryConfigItem = {
     type: typeof gitRepositoryName;
     config: GitRepositoryConfig;
 };
+export type RepositoryConfigEnabledAction = "backup" | "init" | "prune" | "restore" | "snapshots";
+export type RepositoryEnabledObject = {
+    [K in "defaults" | RepositoryConfigEnabledAction]?: boolean;
+};
 type CommonRepositoryConfig = {
     name: string;
     mirrorRepoNames?: string[];

package/lib/{Config/TaskConfig.d.ts → utils/datatruck/config-task-type.d.ts}

@@ -1,9 +1,9 @@
-import { GitTaskConfig, gitTaskName } from "../Task/GitTask";
-import { MariadbTaskConfig, mariadbTaskName } from "../Task/MariadbTask";
-import { MssqlTaskConfig, mssqlTaskName } from "../Task/MssqlTask";
-import { MysqlDumpTaskConfig, mysqlDumpTaskName } from "../Task/MysqlDumpTask";
-import { PostgresqlDumpTaskConfig, postgresqlDumpTaskName } from "../Task/PostgresqlDumpTask";
-import { ScriptTaskConfig, scriptTaskName } from "../Task/ScriptTask";
+import type { GitTaskConfig, gitTaskName } from "../../tasks/GitTask";
+import type { MariadbTaskConfig, mariadbTaskName } from "../../tasks/MariadbTask";
+import type { MssqlTaskConfig, mssqlTaskName } from "../../tasks/MssqlTask";
+import type { MysqlDumpTaskConfig, mysqlDumpTaskName } from "../../tasks/MysqlDumpTask";
+import type { PostgresqlDumpTaskConfig, postgresqlDumpTaskName } from "../../tasks/PostgresqlDumpTask";
+import type { ScriptTaskConfig, scriptTaskName } from "../../tasks/ScriptTask";
 export type GitTaskConfigItem = {
     name: typeof gitTaskName;
     config: GitTaskConfig;

package/lib/utils/datatruck/config-type.d.ts

@@ -0,0 +1,51 @@
+import type { PruneActionsOptions } from "../../actions/PruneAction";
+import type { DataFormatType } from "../DataFormat";
+import type { ReportStep } from "../reportSteps";
+import type { SpawnStep } from "../spawnSteps";
+import type { PackageRepositoryConfig, RepositoryConfigEnabledAction, RepositoryConfig } from "./config-repository-type";
+import type { TaskConfig } from "./config-task-type";
+import type { DatatruckCronServerOptions } from "./cron-server";
+import type { DatatruckRepositoryServerOptions } from "./repository-server";
+export { RepositoryConfig, RepositoryConfigEnabledAction, TaskConfig };
+export type Config = {
+    $schema?: string;
+    hostname?: string;
+    tempDir?: string;
+    minFreeDiskSpace?: string | number;
+    repositories: RepositoryConfig[];
+    packages: PackageConfig[];
+    server?: DatatruckServerOptions;
+    reports?: DatatruckReportConfig[];
+    prunePolicy?: DatatruckPolicyConfig;
+};
+export type DatatruckServerOptions = {
+    log?: boolean;
+    repository?: DatatruckRepositoryServerOptions;
+    cron?: DatatruckCronServerOptions;
+};
+export type DatatruckReportConfig = {
+    when?: "success" | "error";
+    format?: Exclude<DataFormatType, "custom" | "tpl">;
+    run: SpawnStep | ReportStep;
+};
+export type DatatruckPolicyConfig = Pick<PruneActionsOptions, "keepDaily" | "keepHourly" | "keepMinutely" | "keepLast" | "keepMonthly" | "keepWeekly" | "keepYearly" | "groupBy" | "tags">;
+export type PackageConfigMeta = {
+    [name: string]: any;
+};
+export type PackageConfig = {
+    name: string;
+    enabled?: boolean;
+    task?: TaskConfig;
+    path?: string;
+    restorePath?: string;
+    meta?: PackageConfigMeta;
+    restorePermissions?: {
+        uid: string | number;
+        gid: string | number;
+    };
+    include?: (string | SpawnStep)[];
+    exclude?: (string | SpawnStep)[];
+    repositoryNames?: string[];
+    prunePolicy?: DatatruckPolicyConfig;
+    repositoryConfigs?: PackageRepositoryConfig[];
+};

package/lib/utils/datatruck/config.d.ts

@@ -1,10 +1,19 @@
-import { Config } from "../../Config/Config";
-import type { PackageConfig } from "../../Config/PackageConfig";
-import { RepositoryConfigEnabledAction, RepositoryConfig } from "../../Config/RepositoryConfig";
+import type { Config } from "./config-type";
+import type { PackageConfig, RepositoryConfigEnabledAction, RepositoryConfig } from "./config-type";
 export declare function findRepositoryOrFail(config: Config, repositoryName: string): RepositoryConfig;
 export declare function findPackageOrFail(config: Config, packageName: string): PackageConfig;
+export declare function findPackageRepositoryConfig(pkg: PackageConfig, repo: RepositoryConfig): import("../../repositories/ResticRepository").ResticPackageRepositoryConfig | import("../../repositories/DatatruckRepository").DatatruckPackageRepositoryConfig | import("../../repositories/GitRepository").GitPackageRepositoryConfig | undefined;
+export declare function filterRepository(repositories: RepositoryConfig[], options: {
+    include?: string[];
+    exclude?: string[];
+    action?: RepositoryConfigEnabledAction;
+}): RepositoryConfig[];
+export declare function sortReposByType<T extends {
+    name: string;
+    type: RepositoryConfig["type"];
+}>(repositories: T[], types?: RepositoryConfig["type"][]): T[];
 export declare function ensureSameRepositoryType(a: RepositoryConfig, b: RepositoryConfig): void;
-export declare function filterRepository(repository: RepositoryConfig, action?: RepositoryConfigEnabledAction): boolean;
+export declare function filterRepositoryByEnabled(repository: RepositoryConfig, action?: RepositoryConfigEnabledAction): boolean;
 export declare function filterPackages(config: Config, options: {
     packageNames?: string[];
     packageTaskNames?: string[];
@@ -34,17 +43,17 @@ export declare const pkgPathParams: {
 };
 export declare const pkgIncludeParams: {
     action: string;
-    packageName: string;
     temp: string;
     snapshotId: string;
     snapshotDate: string;
+    packageName: string;
 };
 export declare const pkgExcludeParams: {
     action: string;
-    packageName: string;
     temp: string;
     snapshotId: string;
     snapshotDate: string;
+    packageName: string;
 };
 export declare const pkgRestorePathParams: {
     [name in "temp" | keyof ResolvePackagePathParams]: string;
@@ -55,32 +64,32 @@ export declare const dbNameParams: {
 export declare const params: {
     pkgPath: {
         action: string;
-        packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
+        packageName: string;
     };
     pkgRestorePath: {
         path: string;
         action: string;
-        packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
+        packageName: string;
     };
     pkgInclude: {
         action: string;
-        packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
+        packageName: string;
     };
     pkgExclude: {
         action: string;
-        packageName: string;
         temp: string;
         snapshotId: string;
         snapshotDate: string;
+        packageName: string;
     };
     dbName: {
         snapshotId: string;

package/lib/utils/datatruck/config.js

@@ -1,24 +1,60 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepository = exports.ensureSameRepositoryType = exports.findPackageOrFail = exports.findRepositoryOrFail = void 0;
-const AppError_1 = require("../../Error/AppError");
+exports.params = exports.dbNameParams = exports.pkgRestorePathParams = exports.pkgExcludeParams = exports.pkgIncludeParams = exports.pkgPathParams = exports.resolvePackages = exports.resolvePackage = exports.resolveDatabaseName = exports.resolvePackagePath = exports.filterPackages = exports.filterRepositoryByEnabled = exports.ensureSameRepositoryType = exports.sortReposByType = exports.filterRepository = exports.findPackageRepositoryConfig = exports.findPackageOrFail = exports.findRepositoryOrFail = void 0;
 const string_1 = require("../string");
 const temp_1 = require("../temp");
+const error_1 = require("./error");
 const micromatch_1 = require("micromatch");
 function findRepositoryOrFail(config, repositoryName) {
     const repo = config.repositories.find((v) => v.name === repositoryName);
     if (!repo)
-        throw new AppError_1.AppError(`Repository '${repositoryName}' not found`);
+        throw new error_1.AppError(`Repository '${repositoryName}' not found`);
     return repo;
 }
 exports.findRepositoryOrFail = findRepositoryOrFail;
 function findPackageOrFail(config, packageName) {
     const pkg = config.packages.find((v) => v.name === packageName);
     if (!pkg)
-        throw new AppError_1.AppError(`Package '${packageName}' not found`);
+        throw new error_1.AppError(`Package '${packageName}' not found`);
     return pkg;
 }
 exports.findPackageOrFail = findPackageOrFail;
+function findPackageRepositoryConfig(pkg, repo) {
+    return pkg.repositoryConfigs?.find((config) => config.type === repo.type &&
+        (!config.names || config.names.includes(repo.name)))?.config;
+}
+exports.findPackageRepositoryConfig = findPackageRepositoryConfig;
+function filterRepository(repositories, options) {
+    return repositories.filter((r) => {
+        if (options.include && !options.include.includes(r.name))
+            return false;
+        if (options.exclude && options.exclude.includes(r.name))
+            return false;
+        if (options.action && !filterRepositoryByEnabled(r, options.action))
+            return false;
+        return true;
+    });
+}
+exports.filterRepository = filterRepository;
+function sortReposByType(repositories, types) {
+    const groups = repositories.reduce((group, item) => {
+        if (!group[item.type])
+            group[item.type] = [];
+        group[item.type].push(item);
+        return group;
+    }, {});
+    const result = [];
+    const sortedTypes = [
+        ...new Set([...(types || []), ...Object.keys(groups)]),
+    ];
+    for (const type of sortedTypes) {
+        const group = groups[type];
+        if (group)
+            result.push(...group.sort((a, b) => a.name.localeCompare(b.name)));
+    }
+    return result;
+}
+exports.sortReposByType = sortReposByType;
 function ensureSameRepositoryType(a, b) {
     if (a.type !== b.type) {
         const names = [a.name, b.name].join(" and ");
@@ -27,14 +63,14 @@ function ensureSameRepositoryType(a, b) {
     }
 }
 exports.ensureSameRepositoryType = ensureSameRepositoryType;
-function filterRepository(repository, action) {
+function filterRepositoryByEnabled(repository, action) {
     const enabled = repository.enabled ?? true;
     if (typeof enabled === "boolean")
         return enabled;
     const defaults = enabled["defaults"] ?? true;
     return action ? enabled[action] ?? defaults : true;
 }
-exports.filterRepository = filterRepository;
+exports.filterRepositoryByEnabled = filterRepositoryByEnabled;
 function filterPackages(config, options) {
     const packagePatterns = (0, string_1.makePathPatterns)(options.packageNames);
     const taskNamePatterns = (0, string_1.makePathPatterns)(options.packageTaskNames);
@@ -43,7 +79,7 @@ function filterPackages(config, options) {
         pkg = Object.assign({}, pkg);
         pkg.repositoryNames = (pkg.repositoryNames ?? []).filter((name) => {
             const repo = findRepositoryOrFail(config, name);
-            if (!filterRepository(repo, options?.sourceAction))
+            if (!filterRepositoryByEnabled(repo, options?.sourceAction))
                 return false;
             return ((!options.repositoryNames ||
                 options.repositoryNames.includes(name)) &&

package/lib/utils/datatruck/cron-server.d.ts

@@ -1,14 +1,35 @@
-import { BackupCommandOptions } from "../../Command/BackupCommand";
-import { CopyCommandOptionsType } from "../../Command/CopyCommand";
+import { BackupCommandOptions } from "../../commands/BackupCommand";
+import { CopyCommandOptions } from "../../commands/CopyCommand";
+import { PruneCommandOptions } from "../../commands/PruneCommand";
+export type CronScheduleObject = {
+    minute?: number | {
+        each: number;
+    };
+    hour?: number | {
+        each: number;
+    };
+    day?: number | {
+        each: number;
+    };
+    month?: number | {
+        each: number;
+    };
+    weekDay?: number | {
+        each: number;
+    };
+};
 export type CronAction = {
-    schedule: string;
+    schedule: string | CronScheduleObject;
+} & ({
     name: "backup";
     options: BackupCommandOptions;
 } | {
-    schedule: string;
     name: "copy";
-    options: CopyCommandOptionsType;
-};
+    options: CopyCommandOptions;
+} | {
+    name: "prune";
+    options: PruneCommandOptions;
+});
 export type DatatruckCronServerOptions = {
     enabled?: boolean;
     actions?: CronAction[];

package/lib/utils/datatruck/cron-server.js

@@ -1,28 +1,26 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCronServer = void 0;
-const CommandFactory_1 = require("../../Factory/CommandFactory");
+const ConfigAction_1 = require("../../actions/ConfigAction");
 const cli_1 = require("../cli");
+const cron_1 = require("../cron");
 const process_1 = require("../process");
+const string_1 = require("../string");
+const watcher_1 = require("../watcher");
+const command_1 = require("./command");
 const croner_1 = require("croner");
-function createJobs(actions, currentJobs = [], worker) {
+function createJobs(actions, worker) {
     const jobs = [];
     for (const action of actions) {
         const index = actions.indexOf(action);
-        const context = JSON.stringify({
-            index: actions.indexOf(action),
-            data: action,
-        });
-        const job = currentJobs.at(index);
-        if (!job || job.options.context !== context) {
-            job?.stop();
-            jobs.push((0, croner_1.Cron)(action.schedule, {
-                paused: true,
-                context: JSON.stringify(action),
-                catch: true,
-                protect: true,
-            }, () => worker(action, index)));
-        }
+        jobs.push((0, croner_1.Cron)(typeof action.schedule === "string"
+            ? action.schedule
+            : (0, cron_1.formatCronScheduleObject)(action.schedule), {
+            paused: true,
+            context: index,
+            catch: true,
+            protect: true,
+        }, () => worker(action, index)));
     }
     return jobs;
 }
@@ -31,9 +29,9 @@ function createCronServer(options, config) {
         if (config.log)
             console.info(`> [job] ${index} - ${action.name}`);
         try {
-            const Command = (0, CommandFactory_1.CommandConstructorFactory)(action.name);
+            const Command = command_1.datatruckCommandMap[action.name];
             const command = new Command({ config: { packages: [], repositories: [] } }, {});
-            const cliOptions = (0, cli_1.stringifyOptions)(command.onOptions(), action.options);
+            const cliOptions = (0, cli_1.stringifyOptions)(command.optionsConfig(), action.options);
             const [node, bin] = process.argv;
             await (0, process_1.exec)(node, [bin, "-c", config.configPath, action.name, ...cliOptions], {}, { log: config.verbose });
             if (config.log)
@@ -44,16 +42,36 @@ function createCronServer(options, config) {
                 console.error(`< [job] ${index} - ${action.name}`, error);
         }
     };
-    const jobs = createJobs(options.actions || [], [], worker);
-    return {
+    let jobs = createJobs(options.actions || [], worker);
+    const watcher = (0, watcher_1.createWatcher)({
+        onRead: () => ConfigAction_1.ConfigAction.findAndParseFile(config.configPath),
+        onCheck: (prev, current) => (0, string_1.compareJsons)(prev, current),
+        onError: (error) => {
+            if (config.log)
+                console.error(`< [jobs] update error`, error);
+        },
+        onChange: (data) => {
+            if (config.log)
+                console.info(`[jobs] updated`);
+            handler.stop();
+            const cron = data?.server?.cron;
+            const enabled = cron?.enabled ?? true;
+            jobs = enabled ? createJobs(cron?.actions || [], worker) : [];
+            handler.start();
+        },
+    });
+    const handler = {
         start: () => {
             for (const job of jobs)
                 job.resume();
+            watcher.start();
         },
         stop: () => {
+            watcher.stop();
             for (const job of jobs)
                 job.stop();
         },
     };
+    return handler;
 }
 exports.createCronServer = createCronServer;

package/lib/utils/datatruck/paths.d.ts

@@ -1,6 +1,6 @@
-import { PackageConfig } from "../../Config/PackageConfig";
-import { PreSnapshot } from "../../Repository/RepositoryAbstract";
+import { PreSnapshot } from "../../repositories/RepositoryAbstract";
 import { SpawnStep } from "../spawnSteps";
+import type { PackageConfig } from "./config-type";
 export type ParsePathsOptions = {
     cwd?: string;
     verbose?: boolean;

package/lib/utils/datatruck/report-list.d.ts

@@ -0,0 +1,14 @@
+import { Listr3, Listr3TaskResult, List3SummaryResult } from "../list";
+import { DatatruckReportConfig } from "./config-type";
+export type ReportListTaskContext = {
+    report: {
+        type: string;
+    };
+};
+export declare function createReportListTasks<T extends ReportListTaskContext>(list: Listr3<T>, options: {
+    action: string;
+    hostname: string;
+    reports: DatatruckReportConfig[];
+    onMessage: (result: (List3SummaryResult | Listr3TaskResult<T>)[], report: DatatruckReportConfig) => string;
+    verbose?: boolean;
+}): import("listr2").ListrTask<any, any, any>[];

package/lib/utils/datatruck/report-list.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createReportListTasks = void 0;
+const reportSteps_1 = require("../reportSteps");
+const spawnSteps_1 = require("../spawnSteps");
+function createReportListTasks(list, options) {
+    return options.reports.map((report, index) => {
+        const reportIndex = index + 1;
+        return list.$task({
+            title: {
+                initial: `Send report ${reportIndex}`,
+                started: `Sending report ${reportIndex}`,
+                completed: `Report sent: ${reportIndex}`,
+                failed: `Report send failed: ${reportIndex}`,
+            },
+            key: "report",
+            keyIndex: index,
+            data: { type: report.run.type },
+            exitOnError: false,
+            run: async (task) => {
+                const result = list.getResult().filter((r) => r.key !== "report");
+                const success = result.every((r) => !r.error);
+                const enabled = !report.when ||
+                    (report.when === "success" && success) ||
+                    (report.when === "error" && !success);
+                if (!enabled)
+                    return task.skip(`Report send skipped: ${reportIndex}`);
+                const message = options.onMessage(result, report);
+                if ((0, spawnSteps_1.isSpawnStep)(report.run)) {
+                    await (0, spawnSteps_1.runSpawnSteps)(report.run, {
+                        data: {
+                            dtt: {
+                                message,
+                                result,
+                                success,
+                            },
+                        },
+                        verbose: options.verbose,
+                    });
+                }
+                else if ((0, reportSteps_1.isReportStep)(report.run)) {
+                    await (0, reportSteps_1.runReportSteps)(report.run, {
+                        data: {
+                            title: `[${options.hostname}] DTT ${options.action}`,
+                            message,
+                            success,
+                        },
+                    });
+                }
+                else {
+                    throw new Error(`Invalid step type: ${report.run.type}`);
+                }
+            },
+        });
+    });
+}
+exports.createReportListTasks = createReportListTasks;

package/lib/utils/datatruck/repository-server.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createDatatruckRepositoryServer = exports.headerKey = void 0;
-const ConfigAction_1 = require("../../Action/ConfigAction");
+const ConfigAction_1 = require("../../actions/ConfigAction");
 const http_1 = require("../http");
 const virtual_fs_1 = require("../virtual-fs");
 const fs_1 = require("fs");
@@ -67,7 +67,8 @@ function createDatatruckRepositoryServer(inOptions, config = {}) {
                 return res.end();
             }
             const fileOptions = config.configPath
-                ? (await ConfigAction_1.ConfigAction.parseFile(config.configPath)).server?.repository
+                ? (await ConfigAction_1.ConfigAction.findAndParseFile(config.configPath)).server
+                    ?.repository
                 : undefined;
             const options = fileOptions ?? inOptions;
             const backend = findRepositoryBackend(req, repository, options);