@datatruck/cli 0.32.2 → 0.33.0

package/lib/utils/Restic.js

@@ -6,6 +6,7 @@ const process_1 = require("./process");
 const string_1 = require("./string");
 const promises_1 = require("fs/promises");
 const path_1 = require("path");
+const emptySnapshotTag = "empty-snapshot";
 class Restic {
     options;
     constructor(options) {
@@ -95,6 +96,7 @@ class Restic {
             ...(options.json ? ["--json"] : []),
             ...(options.paths?.flatMap((path) => ["--path", path]) ?? []),
             ...(options.latest ? ["--latest", options.latest.toString()] : []),
+            ...(options.snapshotIds || []),
         ], {
             stdout: { save: true },
         });
@@ -151,9 +153,10 @@ class Restic {
                 error.message.includes("unable to save snapshot: snapshot is empty")) {
                 if (options.createEmptyDir) {
                     const emptyPath = await options.createEmptyDir();
-                    await (0, promises_1.writeFile)(`${emptyPath}/.empty`, "");
+                    await (0, promises_1.writeFile)(`${emptyPath}/.${emptySnapshotTag}`, "");
                     return await this.backup({
                         ...options,
+                        tags: [...(options.tags || []), emptySnapshotTag],
                         cwd: emptyPath,
                         allowEmptySnapshot: false,
                         paths: ["."],
@@ -197,10 +200,14 @@ class Restic {
                     progressTimeout = setTimeout(progressRutine, progressInterval);
             }
         }
+        const snapshots = await this.snapshots({
+            snapshotIds: [options.id],
+            json: true,
+        });
         if (typeof progressInterval === "number")
             progressRutine();
         try {
-            return await this.exec(["restore", "--json", options.id, "--target", options.target], {
+            const result = await this.exec(["restore", "--json", options.id, "--target", options.target], {
                 stderr: {
                     toExitCode: true,
                 },
@@ -214,6 +221,9 @@ class Restic {
                     }),
                 },
             });
+            if (snapshots.at(0)?.tags?.includes(emptySnapshotTag))
+                await (0, promises_1.rm)((0, path_1.join)(options.target, `.${emptySnapshotTag}`));
+            return result;
         }
         finally {
             clearTimeout(progressTimeout);

package/lib/utils/cli.d.ts

@@ -1,11 +1,17 @@
 /// <reference types="node" />
+import { Listr3TaskResultEnd } from "./list";
 export declare const showCursorCommand = "\u001B[?25h";
 export declare function renderProgressBar(progress: number, size?: number, subprogress?: number): string;
 export declare function logExec(command: string, argv?: string[], env?: NodeJS.ProcessEnv, logToStderr?: boolean): void;
 export declare function renderResult(error: Error | null | string | boolean | undefined, color?: boolean): string;
 export declare function renderError(error: Error | null | string | undefined, verbose?: number): string;
+export declare function renderListTaskItem<T extends Record<string, any>>(item: Listr3TaskResultEnd<T>, color: boolean | undefined, config: {
+    [K in Listr3TaskResultEnd<T>["key"]]: (data: Extract<Listr3TaskResultEnd<T>, {
+        key: K;
+    }>["data"]) => string | number | string[] | Record<string, string | number>;
+}): string;
 export declare function renderObject(object: Record<string, any>, color?: boolean): string;
-export type OptionsType<T1, T2 extends {
+export type OptionsConfig<T1, T2 extends {
     [K in keyof T1]: unknown;
 }> = {
     [K in keyof Required<T1>]: {
@@ -18,8 +24,8 @@ export type OptionsType<T1, T2 extends {
 };
 export declare function parseOptions<T1, T2 extends {
     [K in keyof T1]: unknown;
-}>(object: T1, options: OptionsType<T1, T2>): T2;
+}>(object: T1, options: OptionsConfig<T1, T2>): T2;
 export declare function stringifyOptions<T1, T2 extends {
     [K in keyof T1]: unknown;
-}>(options: OptionsType<T1, T2>, object: any): string[];
+}>(options: OptionsConfig<T1, T2>, object: any): string[];
 export declare function confirm(message: string): Promise<unknown>;

package/lib/utils/cli.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.confirm = exports.stringifyOptions = exports.parseOptions = exports.renderObject = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
+exports.confirm = exports.stringifyOptions = exports.parseOptions = exports.renderObject = exports.renderListTaskItem = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
 const chalk_1 = __importDefault(require("chalk"));
 const chalk_2 = require("chalk");
 const readline_1 = require("readline");
@@ -75,6 +75,22 @@ function renderError(error, verbose) {
     return chalk_1.default.red(message.trim());
 }
 exports.renderError = renderError;
+function renderListTaskItem(item, color, config) {
+    const result = config[item.key]?.(item.data);
+    if (typeof result === "string" || typeof result === "number") {
+        return result.toString();
+    }
+    else if (Array.isArray(result)) {
+        return result.join(" ");
+    }
+    else if (typeof result === "object" && !!result) {
+        return renderObject(result, color);
+    }
+    else {
+        return "";
+    }
+}
+exports.renderListTaskItem = renderListTaskItem;
 function renderObject(object, color) {
     const values = [];
     for (const key in object)

package/lib/utils/cron.d.ts

@@ -0,0 +1,11 @@
+export type CronScheduleUnit = number | {
+    each: number;
+};
+export type CronScheduleObject = {
+    minute?: CronScheduleUnit;
+    hour?: CronScheduleUnit;
+    day?: CronScheduleUnit;
+    month?: CronScheduleUnit;
+    weekDay?: CronScheduleUnit;
+};
+export declare function formatCronScheduleObject(object: CronScheduleObject): string;

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/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,50 @@
+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;
+    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[];