@datatruck/cli 0.36.8 → 0.38.0

package/lib/utils/cli.js

@@ -3,8 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.logJson = exports.colorizeObject = exports.colorizeValue = exports.waitForStdDrain = exports.confirm = exports.stringifyOptions = exports.parseOptions = exports.renderObject = exports.renderListTaskItem = exports.renderError = exports.renderResult = exports.logExec = exports.renderProgressBar = exports.showCursorCommand = void 0;
-const error_1 = require("./error");
+exports.logJson = exports.colorizeObject = exports.colorizeValue = exports.waitForStdDrain = exports.confirm = 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");
@@ -59,20 +58,15 @@ function renderResult(error, color = true) {
             : "✓";
 }
 exports.renderResult = renderResult;
-function renderError(error, verbose) {
-    if (!error) {
+function renderError(error, index) {
+    if (!error)
         return "";
-    }
-    else if (error instanceof error_1.AppError) {
-        return chalk_1.default.red(verbose ? error.stack ?? error.message : error.message);
-    }
-    else if (error instanceof Error) {
-        return chalk_1.default.red(error.stack ?? error.message);
-    }
-    else {
-        const message = error.split(/\r?\n/).shift() ?? "";
-        return chalk_1.default.red(message.trim());
-    }
+    const message = error instanceof Error
+        ? error.message
+        : (error.split(/\r?\n/).shift() ?? "").trim();
+    return chalk_1.default.red(typeof index === "number" && index !== -1
+        ? `${index + 1}. ${message}`
+        : message);
 }
 exports.renderError = renderError;
 function renderListTaskItem(item, color, config) {
@@ -98,40 +92,6 @@ function renderObject(object, color) {
     return values.join(` `);
 }
 exports.renderObject = renderObject;
-function parseOptions(object, options) {
-    const result = {};
-    for (const key in options) {
-        const isNegative = options[key].option.startsWith("--no");
-        const defaultsValue = isNegative ? true : options[key].defaults;
-        const value = object?.[key] ?? defaultsValue;
-        const parser = options[key].parser;
-        if (typeof value !== "undefined") {
-            result[key] = parser ? parser(value) : value;
-        }
-    }
-    return result;
-}
-exports.parseOptions = parseOptions;
-function stringifyOptions(options, object) {
-    const result = [];
-    for (const key in options) {
-        const fullOpt = options[key].option;
-        const [opt] = fullOpt.split(",");
-        const isNegative = fullOpt.startsWith("--no");
-        const isBool = !fullOpt.includes("<") && !fullOpt.includes("[");
-        const defaultsValue = isNegative ? true : options[key].defaults;
-        const value = object?.[key] ?? defaultsValue;
-        if (isBool) {
-            if (object[key])
-                result.push(opt);
-        }
-        else if (value !== undefined) {
-            result.push(opt, `${value}`);
-        }
-    }
-    return result;
-}
-exports.stringifyOptions = stringifyOptions;
 function confirm(message) {
     const rl = (0, readline_1.createInterface)({
         input: process.stdin,

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

@@ -3,27 +3,30 @@ import { CleanCacheCommand } from "../../commands/CleanCacheCommand";
 import { GlobalOptions } from "../../commands/CommandAbstract";
 import { ConfigCommand } from "../../commands/ConfigCommand";
 import { CopyCommand } from "../../commands/CopyCommand";
+import { ExportCommand } from "../../commands/ExportCommand";
 import { InitCommand } from "../../commands/InitCommand";
 import { PruneCommand } from "../../commands/PruneCommand";
 import { RestoreCommand } from "../../commands/RestoreCommand";
+import { RunCommand } from "../../commands/RunCommand";
 import { SnapshotsCommand } from "../../commands/SnapshotsCommand";
 import { StartServerCommand } from "../../commands/StartServerCommand";
 import { StdStreams } from "../stream";
-export declare const datatruckCommandMap: {
+export declare const datatruckCommands: {
     config: typeof ConfigCommand;
     init: typeof InitCommand;
     snapshots: typeof SnapshotsCommand;
     prune: typeof PruneCommand;
     backup: typeof BackupCommand;
     restore: typeof RestoreCommand;
+    run: typeof RunCommand;
     copy: typeof CopyCommand;
     cleanCache: typeof CleanCacheCommand;
     startServer: typeof StartServerCommand;
+    export: typeof ExportCommand;
 };
-export type DatatruckCommandMap = typeof datatruckCommandMap;
-export type InferDatatruckCommandOptions<T extends keyof DatatruckCommandMap> = InstanceType<DatatruckCommandMap[T]>["inputOptions"];
+export type DatatruckCommandMap = typeof datatruckCommands;
 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<StdStreams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | InitCommand | RestoreCommand | SnapshotsCommand | StartServerCommand;
+export declare function createCommand<T extends keyof DatatruckCommandMap>(name: T, globalOptions: GlobalOptions<true>, options: InstanceType<DatatruckCommandMap[T]>["options"], streams?: Partial<StdStreams>, configPath?: string): BackupCommand | CopyCommand | PruneCommand | CleanCacheCommand | ConfigCommand | ExportCommand | InitCommand | RestoreCommand | RunCommand | SnapshotsCommand | StartServerCommand;
 export declare function createCommands(globalOptions: GlobalOptions<true>): {
-    [K in keyof DatatruckCommandMap as `${K}`]: (options: InferDatatruckCommandOptions<K>) => Promise<InferDatatruckCommandResult<K>>;
+    [K in keyof DatatruckCommandMap as `${K}`]: (options: InstanceType<DatatruckCommandMap[K]>["options"]) => Promise<InferDatatruckCommandResult<K>>;
 };

package/lib/utils/datatruck/command.js

@@ -1,30 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCommands = exports.createCommand = exports.datatruckCommandMap = void 0;
+exports.createCommands = exports.createCommand = exports.datatruckCommands = 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 ExportCommand_1 = require("../../commands/ExportCommand");
 const InitCommand_1 = require("../../commands/InitCommand");
 const PruneCommand_1 = require("../../commands/PruneCommand");
 const RestoreCommand_1 = require("../../commands/RestoreCommand");
+const RunCommand_1 = require("../../commands/RunCommand");
 const SnapshotsCommand_1 = require("../../commands/SnapshotsCommand");
 const StartServerCommand_1 = require("../../commands/StartServerCommand");
 const error_1 = require("../error");
 const stream_1 = require("stream");
-exports.datatruckCommandMap = {
+exports.datatruckCommands = {
     config: ConfigCommand_1.ConfigCommand,
     init: InitCommand_1.InitCommand,
     snapshots: SnapshotsCommand_1.SnapshotsCommand,
     prune: PruneCommand_1.PruneCommand,
     backup: BackupCommand_1.BackupCommand,
     restore: RestoreCommand_1.RestoreCommand,
+    run: RunCommand_1.RunCommand,
     copy: CopyCommand_1.CopyCommand,
     cleanCache: CleanCacheCommand_1.CleanCacheCommand,
     startServer: StartServerCommand_1.StartServerCommand,
+    export: ExportCommand_1.ExportCommand,
 };
 function createCommand(name, globalOptions, options, streams, configPath) {
-    const constructor = exports.datatruckCommandMap[name];
+    const constructor = exports.datatruckCommands[name];
     if (!constructor)
         throw new error_1.AppError(`Invalid command name: ${name}`);
     return new constructor(globalOptions, options, streams, configPath);
@@ -32,7 +36,7 @@ function createCommand(name, globalOptions, options, streams, configPath) {
 exports.createCommand = createCommand;
 function createCommands(globalOptions) {
     const object = {};
-    for (const name in exports.datatruckCommandMap) {
+    for (const name in exports.datatruckCommands) {
         object[name] = async (options) => {
             let stdoutData = "";
             const stdout = new stream_1.Writable({

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

@@ -5,6 +5,7 @@ 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 { Job } from "./job";
 import type { DatatruckRepositoryServerOptions } from "./repository-server";
 export { RepositoryConfig, RepositoryConfigEnabledAction, TaskConfig };
 export type Config = {
@@ -15,6 +16,9 @@ export type Config = {
     repositories: RepositoryConfig[];
     packages: PackageConfig[];
     server?: DatatruckServerOptions;
+    jobs?: {
+        [name: string]: Job;
+    };
     reports?: DatatruckReportConfig[];
     prunePolicy?: DatatruckPolicyConfig;
 };

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

@@ -1,44 +1,13 @@
-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 | CronScheduleObject;
-} & ({
-    name: "backup";
-    options: BackupCommandOptions;
-} | {
-    name: "copy";
-    options: CopyCommandOptions;
-} | {
-    name: "prune";
-    options: Omit<PruneCommandOptions, "confirm">;
-});
+import { JobConfig } from "./job";
+export declare const defaultsLogPath: string;
 export type DatatruckCronServerOptions = {
     enabled?: boolean;
-    actions?: CronAction[];
+    /**
+     * @default '/var/logs/datatruck'
+     */
+    logPath?: string | boolean;
 };
-export declare function createCronServer(options: DatatruckCronServerOptions, config: {
-    log: boolean;
-    verbose: boolean;
-    configPath: string;
-}): {
+export declare function createCronServer(options: JobConfig): Promise<{
     start: () => void;
     stop: () => void;
-};
+}>;

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

@@ -1,89 +1,67 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createCronServer = void 0;
+exports.createCronServer = exports.defaultsLogPath = void 0;
 const ConfigAction_1 = require("../../actions/ConfigAction");
-const async_process_1 = require("../async-process");
 const cli_1 = require("../cli");
 const cron_1 = require("../cron");
 const string_1 = require("../string");
 const watcher_1 = require("../watcher");
-const command_1 = require("./command");
+const job_1 = require("./job");
 const croner_1 = require("croner");
-function createJobs(actions, worker) {
-    const jobs = [];
-    for (const action of actions) {
-        const index = actions.indexOf(action);
-        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)));
+const os_1 = require("os");
+const path_1 = require("path");
+exports.defaultsLogPath = (0, os_1.platform)() === "win32"
+    ? (0, path_1.join)(process.env.APPDATA ?? `${process.env.HOMEDRIVE ?? "C:"}\\ProgramData`, "datatruck\\logs")
+    : "/var/logs/datatruck";
+function createCrons(jobs, options) {
+    const crons = [];
+    for (const name in jobs) {
+        const job = jobs[name];
+        if (job.schedule)
+            crons.push((0, croner_1.Cron)(typeof job.schedule === "string"
+                ? job.schedule
+                : (0, cron_1.formatCronScheduleObject)(job.schedule), {
+                paused: true,
+                context: name,
+                catch: true,
+                protect: true,
+            }, () => (0, job_1.runJob)(job, name, options)));
     }
-    return jobs;
+    return crons;
 }
-function createCronServer(options, config) {
-    const worker = async (action, index) => {
-        let pid = 0;
-        try {
-            const Command = command_1.datatruckCommandMap[action.name];
-            const command = new Command({ config: { packages: [], repositories: [] } }, {});
-            const cliOptions = (0, cli_1.stringifyOptions)(command.optionsConfig(), action.name === "prune"
-                ? ({ ...action.options, confirm: true })
-                : action.options);
-            const [node, bin] = process.argv;
-            const p = new async_process_1.AsyncProcess(node, [
-                process.env.pm_exec_path ?? bin,
-                "-c",
-                config.configPath,
-                action.name,
-                ...cliOptions,
-            ], { $log: config.verbose, $exitCode: false });
-            pid = p.child.pid || 0;
-            if (config.log)
-                (0, cli_1.logJson)("cron-server", `${action.name} started`, { pid });
-            const exitCode = await p.waitForClose();
-            if (config.log)
-                (0, cli_1.logJson)("cron-server", `${action.name} finished`, { pid, exitCode });
-        }
-        catch (error) {
-            if (config.log)
-                (0, cli_1.logJson)("cron-server", `${action.name} failed`, { pid });
-            console.error(error);
-        }
-    };
-    let jobs = createJobs(options.actions || [], worker);
+async function createCronServer(options) {
+    const config = await ConfigAction_1.ConfigAction.fromGlobalOptions({
+        config: options.configPath,
+    });
+    let crons = createCrons(config.jobs || {}, options);
     const watcher = (0, watcher_1.createWatcher)({
-        onRead: () => ConfigAction_1.ConfigAction.findAndParseFile(config.configPath),
+        onRead: () => ConfigAction_1.ConfigAction.findAndParseFile(options.configPath),
         onCheck: (prev, current) => (0, string_1.compareJsons)(prev, current),
         onError: (error) => {
-            if (config.log) {
+            if (options.log) {
                 (0, cli_1.logJson)("cron-server", "job update error");
                 console.error(error);
             }
         },
         onChange: (data) => {
-            if (config.log)
+            if (options.log)
                 (0, cli_1.logJson)("cron-server", "jobs updated");
             handler.stop();
-            const cron = data?.server?.cron;
-            const enabled = cron?.enabled ?? true;
-            jobs = enabled ? createJobs(cron?.actions || [], worker) : [];
+            const enabled = data?.server?.cron?.enabled ?? true;
+            crons = enabled ? createCrons(data?.jobs || {}, options) : [];
             handler.start();
         },
     });
     const handler = {
         start: () => {
-            for (const job of jobs)
-                job.resume();
+            for (const cron of crons)
+                cron.resume();
             watcher.start();
         },
         stop: () => {
             watcher.stop();
-            for (const job of jobs)
-                job.stop();
+            for (const cron of crons)
+                cron.stop();
         },
     };
     return handler;

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

@@ -0,0 +1,41 @@
+import { BackupCommandOptions } from "../../commands/BackupCommand";
+import { CopyCommandOptions } from "../../commands/CopyCommand";
+import { PruneCommandOptions } from "../../commands/PruneCommand";
+export type JobScheduleObject = {
+    minute?: number | {
+        each: number;
+    };
+    hour?: number | {
+        each: number;
+    };
+    day?: number | {
+        each: number;
+    };
+    month?: number | {
+        each: number;
+    };
+    weekDay?: number | {
+        each: number;
+    };
+};
+export type JobAction = {
+    action: "backup";
+    options: BackupCommandOptions;
+} | {
+    action: "copy";
+    options: CopyCommandOptions;
+} | {
+    action: "prune";
+    options: Omit<PruneCommandOptions, "confirm">;
+};
+export type JobSchedule = string | JobScheduleObject;
+export type Job = JobAction & {
+    schedule?: JobSchedule;
+};
+export type JobConfig = {
+    log: boolean;
+    logPath: string | boolean | undefined;
+    verbose: boolean;
+    configPath: string;
+};
+export declare function runJob(job: Job, name: string, config: JobConfig): Promise<void>;

package/lib/utils/datatruck/job.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runJob = void 0;
+const async_process_1 = require("../async-process");
+const cli_1 = require("../cli");
+const fs_1 = require("../fs");
+const options_1 = require("../options");
+const command_1 = require("./command");
+const cron_server_1 = require("./cron-server");
+const fs_2 = require("fs");
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+async function runJob(job, name, config) {
+    let pid = 0;
+    try {
+        const Command = command_1.datatruckCommands[job.action];
+        const command = new Command({ config: { packages: [], repositories: [] } }, {});
+        const cliOptions = (0, options_1.stringifyOptions)(command.optionsConfig, job.action === "prune"
+            ? ({ ...job.options, confirm: true })
+            : job.options);
+        const [node, bin] = process.argv;
+        const baseLogPath = typeof config.logPath === "string"
+            ? config.logPath
+            : config.logPath === true || config.logPath === undefined
+                ? cron_server_1.defaultsLogPath
+                : config.logPath;
+        let stream;
+        let logPath;
+        const dt = new Date().toISOString().replaceAll(":", "-");
+        const argv = [
+            process.env.pm_exec_path ?? bin,
+            "--tty",
+            "false",
+            "--progress",
+            "interval:3000",
+            "-c",
+            config.configPath,
+            job.action,
+            ...cliOptions,
+        ];
+        if (baseLogPath) {
+            const tmpLogPath = (0, path_1.join)(baseLogPath, dt) + ".log";
+            await (0, promises_1.mkdir)(baseLogPath, { recursive: true });
+            stream = (0, fs_2.createWriteStream)(tmpLogPath);
+            stream.write(`+ dtt ${argv.join(" ")}\n`);
+        }
+        const p = new async_process_1.AsyncProcess(node, argv, {
+            $log: config.verbose,
+            $exitCode: false,
+            env: {
+                ...process.env,
+                COLUMNS: "160",
+                NO_COLOR: "1",
+                JOB_NAME: name,
+            },
+        });
+        pid = p.child.pid || 0;
+        if (config.log)
+            (0, cli_1.logJson)("job", `'${name}' started`, { pid });
+        const [exitCode] = await Promise.all([
+            p.waitForClose(),
+            stream && p.stderr.pipe(stream),
+            stream && p.stdout.pipe(stream),
+        ]);
+        if (stream) {
+            const base = (0, path_1.dirname)(stream.path.toString());
+            await (0, fs_1.safeRename)(stream.path.toString(), (logPath = (0, path_1.join)(base, `${dt}-${pid}.log`)));
+        }
+        if (config.log)
+            (0, cli_1.logJson)("job", `'${name}' finished`, {
+                pid,
+                exitCode,
+                ...(logPath && { log: logPath }),
+            });
+    }
+    catch (error) {
+        if (config.log)
+            (0, cli_1.logJson)("job", `'${name}' failed`, { pid });
+        console.error(error);
+    }
+}
+exports.runJob = runJob;

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

@@ -42,7 +42,7 @@ function createReportListTasks(list, options) {
                 else if ((0, reportSteps_1.isReportStep)(report.run)) {
                     await (0, reportSteps_1.runReportSteps)(report.run, {
                         data: {
-                            title: `[${options.hostname}] DTT ${options.action}`,
+                            title: `[${options.hostname}] DTT ${process.env.JOB_NAME ?? options.action}`,
                             message,
                             success,
                         },

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

@@ -13,4 +13,5 @@ export declare function getRepoConstructor(type: keyof typeof repoMap): {
 };
 export declare function createRepo(repository: RepositoryConfig, verbose: boolean | undefined): RepositoryAbstract<any>;
 export declare function createAndInitRepo(repository: RepositoryConfig, verbose: boolean | undefined): Promise<RepositoryAbstract<any>>;
+export declare function initSnapshotPath(path: string, minFreeDiskSpace?: string | number): Promise<void>;
 export {};

package/lib/utils/datatruck/repository.js

@@ -1,10 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createAndInitRepo = exports.createRepo = exports.getRepoConstructor = void 0;
+exports.initSnapshotPath = exports.createAndInitRepo = exports.createRepo = exports.getRepoConstructor = void 0;
 const DatatruckRepository_1 = require("../../repositories/DatatruckRepository");
 const GitRepository_1 = require("../../repositories/GitRepository");
 const ResticRepository_1 = require("../../repositories/ResticRepository");
 const error_1 = require("../error");
+const fs_1 = require("../fs");
 const repoMap = {
     [GitRepository_1.gitRepositoryName]: GitRepository_1.GitRepository,
     [ResticRepository_1.resticRepositoryName]: ResticRepository_1.ResticRepository,
@@ -28,3 +29,9 @@ async function createAndInitRepo(repository, verbose) {
     return repo;
 }
 exports.createAndInitRepo = createAndInitRepo;
+async function initSnapshotPath(path, minFreeDiskSpace) {
+    await (0, fs_1.initEmptyDir)(path);
+    if (minFreeDiskSpace)
+        await (0, fs_1.ensureFreeDiskSpace)([path], minFreeDiskSpace);
+}
+exports.initSnapshotPath = initSnapshotPath;

package/lib/utils/list.d.ts

@@ -63,6 +63,11 @@ export declare class Listr3<T extends Listr3Context> extends Listr<void, "defaul
     getSummaryResult(): List3SummaryResult;
     getResult(): (List3SummaryResult | Listr3TaskResult<T>)[];
     protected release(): void;
+    execAndParse(verbose: boolean | undefined): Promise<{
+        result: (List3SummaryResult | Listr3TaskResult<T>)[];
+        exitCode: number;
+        errors: Error[];
+    }>;
     exec(): Promise<(Listr3TaskResult<T> | List3SummaryResult)[]>;
 }
 export {};

package/lib/utils/list.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Listr3 = exports.List3Logger = void 0;
 const date_1 = require("./date");
+const error_1 = require("./error");
 const exit_1 = require("./exit");
 const stream_1 = require("./stream");
 const listr2_1 = require("listr2");
@@ -135,6 +136,14 @@ class Listr3 extends listr2_1.Listr {
                 task.state$ = listr2_1.ListrTaskState.FAILED;
         this["renderer"].end(new Error("Interrupted."));
     }
+    async execAndParse(verbose) {
+        const result = await this.exec();
+        const exitCode = result.some((item) => item.error) ? 1 : 0;
+        const errors = result
+            .filter((item) => item.error && (verbose || !(item.error instanceof error_1.AppError)))
+            .map(({ error }) => error);
+        return { result, exitCode, errors };
+    }
     async exec() {
         const dispose = (0, exit_1.onExit)(() => {
             this.$options.progressManager?.dispose();

package/lib/utils/math.js

@@ -10,7 +10,7 @@ exports.progressPercent = progressPercent;
 class Counter {
     maxValue;
     value = 0;
-    constructor(maxValue = 4294967295) {
+    constructor(maxValue = 4_294_967_295) {
         this.maxValue = maxValue;
     }
     next() {

package/lib/utils/object.d.ts

@@ -1,5 +1,10 @@
 export declare function merge<T extends Record<string, unknown>>(target: T, ...sources: Record<string, unknown>[]): T;
 export declare function omitProp<T extends Record<string, any>, N extends keyof T>(object: T, name: N): Omit<T, N>;
+export declare function pickProps<T extends Record<string, any>, I extends {
+    [K in keyof T]?: boolean;
+}>(object: T, input: I): {
+    [K in keyof T as K extends keyof I ? [I[K]] extends [true] ? K : never : never]: T[K];
+};
 export declare function getErrorProperties(error: Error): Record<string, string>;
 type GroupByKeyParamType<TItem> = ((item: TItem) => string[] | string) | (keyof TItem)[] | keyof TItem;
 export declare function groupBy<TItem>(items: TItem[], keyOrCb: GroupByKeyParamType<TItem>): Record<string, TItem[]>;

package/lib/utils/object.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.StrictMap = exports.groupBy = exports.getErrorProperties = exports.omitProp = exports.merge = void 0;
+exports.StrictMap = exports.groupBy = exports.getErrorProperties = exports.pickProps = exports.omitProp = exports.merge = void 0;
 function merge(target, ...sources) {
     const isObject = (o) => typeof o === "object" && o !== null;
     for (const source of sources)
@@ -19,6 +19,15 @@ function omitProp(object, name) {
     return result;
 }
 exports.omitProp = omitProp;
+function pickProps(object, input) {
+    const result = {};
+    for (const name in input) {
+        if (input[name])
+            result[name] = object[name];
+    }
+    return result;
+}
+exports.pickProps = pickProps;
 function getErrorProperties(error) {
     const alt = {};
     for (const key of Object.getOwnPropertyNames(error)) {

package/lib/utils/options.d.ts

@@ -0,0 +1,24 @@
+export type OptionsConfigObject = {
+    flag?: string | false;
+    shortFlag?: string;
+    description: string;
+    required?: boolean;
+    defaults?: any;
+    value?: "boolean" | "number" | "string" | "array" | ((value: string) => any);
+};
+export type OptionsConfig = Record<string, OptionsConfigObject>;
+export type InferOptionsValue<O extends OptionsConfigObject> = [
+    O["value"]
+] extends ["number"] ? number : [O["value"]] extends ["boolean"] ? boolean : [O["value"]] extends ["array"] ? string[] : O["value"] extends (value: any) => any ? ReturnType<O["value"]> : string;
+export type InferOptions<T extends OptionsConfig> = {
+    [K in keyof T as [T[K]["required"]] extends [true] ? K : never]: InferOptionsValue<T[K]>;
+} & {
+    [K in keyof T as [T[K]["required"]] extends [true] ? never : K]?: InferOptionsValue<T[K]>;
+};
+export type CommandConfig<T extends OptionsConfig = OptionsConfig> = {
+    name: string;
+    alias?: string;
+    options: T;
+};
+export declare function createCommand<T extends OptionsConfig>(config: CommandConfig<T>, action: (options: InferOptions<T>) => any): import("commander").Command;
+export declare function stringifyOptions(options: OptionsConfig, object: any): string[];