@datatruck/restic 0.0.1 → 0.0.3

package/lib/config.d.ts

@@ -1,3 +1,5 @@
+import { MySQLDumpOptions } from "./utils/mysql.js";
+import { Restic } from "@datatruck/cli/utils/restic.js";
 export type GlobalConfig = {
     config?: string;
     verbose?: boolean;
@@ -8,6 +10,7 @@ export type Config = {
     ntfyToken?: string;
     minFreeSpace?: string;
     verbose?: boolean;
+    prunePolicy?: PrunePolicy;
     tasks?: {
         type: "mysql-dump";
         packages: string[];
@@ -20,26 +23,66 @@ export type Config = {
                 path: string | false;
             }[] | string;
             concurrency?: number;
-            connection: {
-                hostname: string;
-                username: string;
-                password: string;
-                database?: string;
-            };
+            connection: MySQLDumpOptions["connection"];
         };
     }[];
     packages: {
         name: string;
         path: string;
         exclude?: string[];
+        prunePolicy?: PrunePolicy;
     }[];
     repositories: {
         name: string;
         password: string;
         uri: string;
+        prunePolicy?: PrunePolicy;
     }[];
 };
+export type PrunePolicy = {
+    keepMinutely?: number;
+    keepDaily?: number;
+    keepHourly?: number;
+    keepLast?: number;
+    keepMonthly?: number;
+    keepWeekly?: number;
+    keepYearly?: number;
+};
 export declare function defineConfig(config: Config): Config;
 export declare function validateConfig(config: unknown): Promise<void>;
 export declare function readConfigSchemaFile(): Promise<unknown>;
 export declare function parseConfigFile(path?: string): Promise<Config>;
+export declare class ConfigManager {
+    readonly config: Config;
+    constructor(config: Config);
+    filterRepositories(filter: string[] | undefined): {
+        name: string;
+        password: string;
+        uri: string;
+        prunePolicy?: PrunePolicy;
+    }[];
+    filterPackages(filter: string[] | undefined): {
+        name: string;
+        path: string;
+        exclude?: string[];
+        prunePolicy?: PrunePolicy;
+    }[];
+    findRepository(name: string): {
+        name: string;
+        password: string;
+        uri: string;
+        prunePolicy?: PrunePolicy;
+    };
+    findPackage(name: string): {
+        name: string;
+        path: string;
+        exclude?: string[];
+        prunePolicy?: PrunePolicy;
+    };
+    createRestic(repoName: string, verbose: boolean | undefined): readonly [Restic, {
+        name: string;
+        password: string;
+        uri: string;
+        prunePolicy?: PrunePolicy;
+    }];
+}

package/lib/config.js

@@ -1,4 +1,6 @@
 import { parseJSONFile } from "./utils/fs.js";
+import { Restic } from "@datatruck/cli/utils/restic.js";
+import { match } from "@datatruck/cli/utils/string.js";
 import { Ajv } from "ajv";
 export function defineConfig(config) {
     return config;
@@ -20,3 +22,48 @@ export async function parseConfigFile(path = "datatruck.restic.json") {
     await validateConfig(config);
     return config;
 }
+export class ConfigManager {
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    filterRepositories(filter) {
+        const repositories = this.config.repositories.filter((v) => filter ? match(v.name, filter) : true);
+        if (!repositories.length)
+            throw new Error(filter
+                ? `No repositories found for filter: ${filter.join(", ")}`
+                : `No repositories found`);
+        return repositories;
+    }
+    filterPackages(filter) {
+        const packages = this.config.packages.filter((v) => filter ? match(v.name, filter) : true);
+        if (!packages.length)
+            throw new Error(filter
+                ? `No packages found for filter: ${filter.join(", ")}`
+                : `No packages found`);
+        return packages;
+    }
+    findRepository(name) {
+        const repo = this.config.repositories.find((repo) => repo.name === name);
+        if (!repo)
+            throw new Error(`Repository '${name}' not found`);
+        return repo;
+    }
+    findPackage(name) {
+        const pkg = this.config.packages.find((pkg) => pkg.name === name);
+        if (!pkg)
+            throw new Error(`Package '${name}' not found`);
+        return pkg;
+    }
+    createRestic(repoName, verbose) {
+        const repo = this.findRepository(repoName);
+        const restic = new Restic({
+            log: verbose,
+            env: {
+                RESTIC_REPOSITORY: repo.uri,
+                RESTIC_PASSWORD: repo.password,
+            },
+        });
+        return [restic, repo];
+    }
+}

package/lib/create-bin.d.ts

@@ -0,0 +1,3 @@
+import { Config } from "./config.js";
+import { Command } from "commander";
+export declare function createBin(inConfig?: Config): Command;

package/lib/create-bin.js

@@ -0,0 +1,83 @@
+import { Backup } from "./actions/backup.js";
+import { Copy } from "./actions/copy.js";
+import { Create } from "./actions/create.js";
+import { Init } from "./actions/init.js";
+import { Prune } from "./actions/prune.js";
+import { parseConfigFile } from "./config.js";
+import { parseStringList } from "@datatruck/cli/utils/string.js";
+import { Command } from "commander";
+import { resolve } from "path";
+export function createBin(inConfig) {
+    async function load() {
+        const globalOptions = { ...program.opts() };
+        if (globalOptions.config)
+            globalOptions.config = resolve(globalOptions.config);
+        const config = inConfig ?? (await parseConfigFile(globalOptions.config));
+        globalOptions.verbose = process.env.DEBUG
+            ? true
+            : globalOptions.verbose || config.verbose;
+        return { config, globalOptions };
+    }
+    const program = new Command();
+    program.option("-v, --verbose");
+    if (!inConfig)
+        program.option("-c, --config <path>", "Path to config file", "datatruck.restic.json");
+    program
+        .command("create")
+        .description("Create config file")
+        .option("--cwd <path>", "Current working directory to create config file in", ".")
+        .option("-c,--config <path>", "Output path for config file", "datatruck.restic.json")
+        .option("-f,--force", "Force overwrite if config file already exists")
+        .action(async (options) => {
+        const create = new Create();
+        await create.run(options);
+    });
+    program
+        .command("init")
+        .alias("i")
+        .description("Run init action")
+        .option("-r, --repositories <names>", "Repository names", (v) => parseStringList(v))
+        .action(async (options) => {
+        const { config, globalOptions } = await load();
+        const init = new Init(config, globalOptions);
+        await init.run(options);
+    });
+    program
+        .command("backup")
+        .alias("b")
+        .description("Run backup action")
+        .option("-r, --repositories <names>", "Repository names", (v) => parseStringList(v))
+        .option("-p, --packages <packages>", "Package names", (v) => parseStringList(v))
+        .option("--prune", "Prune after backup")
+        .action(async (options) => {
+        const { config, globalOptions } = await load();
+        const backup = new Backup(config, globalOptions);
+        await backup.run(options);
+    });
+    program
+        .command("copy")
+        .alias("c")
+        .description("Run copy action")
+        .option("-p, --packages <packages>", "Package names", (v) => parseStringList(v))
+        .requiredOption("-s, --source <name>", "Source repository name")
+        .requiredOption("-t, --targets <names>", "Target repository names", (v) => parseStringList(v))
+        .option("--prune", "Prune after copy")
+        .action(async (options) => {
+        const { config, globalOptions } = await load();
+        const copy = new Copy(config, globalOptions);
+        await copy.run(options);
+    });
+    program
+        .command("prune")
+        .alias("p")
+        .description("Run prune action")
+        .option("-r, --repositories <names>", "Repository names", (v) => parseStringList(v))
+        .option("-p, --packages <packages>", "Package names", (v) => parseStringList(v))
+        .option("--prune", "Prune after copy")
+        .action(async (options) => {
+        const { config, globalOptions } = await load();
+        const prune = new Prune(config, globalOptions);
+        await prune.run(options);
+    });
+    return program;
+}

package/lib/index.d.ts

@@ -1,4 +1,6 @@
-export { Backup, type BackupRunOptions } from "./actions/backup.js";
-export { Copy, type CopyRunOptions } from "./actions/copy.js";
+export { Backup, type BackupOptions } from "./actions/backup.js";
+export { Copy, type CopyOptions } from "./actions/copy.js";
 export { Init, type InitOptions } from "./actions/init.js";
-export { type Config, type GlobalConfig, parseConfigFile, defineConfig, validateConfig, } from "./config.js";
+export { Prune, type PruneOptions } from "./actions/prune.js";
+export { type Config, type GlobalConfig, type PrunePolicy, parseConfigFile, defineConfig, validateConfig, } from "./config.js";
+export { createBin } from "./create-bin.js";

package/lib/index.js

@@ -1,4 +1,6 @@
 export { Backup } from "./actions/backup.js";
 export { Copy } from "./actions/copy.js";
 export { Init } from "./actions/init.js";
+export { Prune } from "./actions/prune.js";
 export { parseConfigFile, defineConfig, validateConfig, } from "./config.js";
+export { createBin } from "./create-bin.js";

package/lib/utils/async.d.ts

@@ -0,0 +1,10 @@
+export declare function createRunner(rutine: () => any): {
+    start: <R = any>(cb: (data: {
+        error: Error | undefined;
+        duration: string;
+    }) => Promise<R>) => Promise<R>;
+};
+export declare function safeRun<T>(cb: () => Promise<T>): Promise<{
+    error: Error | undefined;
+    result: T | undefined;
+}>;

package/lib/utils/async.js

@@ -0,0 +1,36 @@
+import { duration } from "@datatruck/cli/utils/date.js";
+export function createRunner(rutine) {
+    return {
+        start: async (cb) => {
+            const now = Date.now();
+            let error;
+            try {
+                await rutine();
+            }
+            catch (inError) {
+                error = inError;
+            }
+            try {
+                return await cb({
+                    duration: duration(Date.now() - now),
+                    error,
+                });
+            }
+            finally {
+                if (error)
+                    console.error(error, "\n");
+            }
+        },
+    };
+}
+export async function safeRun(cb) {
+    try {
+        return {
+            error: undefined,
+            result: await cb(),
+        };
+    }
+    catch (error) {
+        return { error: error, result: undefined };
+    }
+}

package/lib/utils/fs.d.ts

@@ -4,4 +4,13 @@ export declare function checkDiskSpace(options: {
     minFreeSpacePath?: string | undefined;
     targetPath?: string | undefined;
     rutine: () => any;
-}): Promise<number | undefined>;
+}): Promise<{
+    diff: number;
+    size: number;
+} | undefined>;
+export declare function getDiskName(inPath: string): Promise<string>;
+export declare function fetchMultipleDiskStats(paths: string[]): Promise<{
+    name: string;
+    free: number;
+    total: number;
+}[]>;

package/lib/utils/fs.js

@@ -1,5 +1,8 @@
 import { ensureFreeDiskSpace, fastFolderSizeAsync, fetchDiskStats, } from "@datatruck/cli/utils/fs.js";
-import { readFile } from "fs/promises";
+import { execSync } from "child_process";
+import { mkdir, readFile, stat } from "fs/promises";
+import { platform } from "os";
+import { parse, resolve } from "path";
 export async function parseJSONFile(path) {
     const buffer = await readFile(path);
     return JSON.parse(buffer.toString());
@@ -19,5 +22,39 @@ export async function checkDiskSpace(options) {
     const prev = await fastFolderSizeAsync(options.targetPath);
     await options.rutine();
     const next = await fastFolderSizeAsync(options.targetPath);
-    return next - prev;
+    return {
+        diff: next - prev,
+        size: next,
+    };
+}
+export async function getDiskName(inPath) {
+    const path = resolve(inPath);
+    if (platform() === "win32") {
+        return parse(path).root[0];
+    }
+    else {
+        return execSync(`df "${path}"`).toString().split("\n")[1].split(/\s+/)[0];
+    }
+}
+export async function fetchMultipleDiskStats(paths) {
+    for (const path of paths) {
+        await mkdir(path, { recursive: true });
+    }
+    const devices = {};
+    for (const inPath of paths) {
+        const path = resolve(inPath);
+        const info = await stat(path);
+        if (!devices[info.dev])
+            devices[info.dev] = path;
+    }
+    const result = [];
+    for (const dev in devices) {
+        const path = devices[dev];
+        const stats = await fetchDiskStats(path);
+        result.push({
+            name: await getDiskName(path),
+            ...stats,
+        });
+    }
+    return result;
 }

package/lib/utils/mysql.d.ts

@@ -1,5 +1,5 @@
 import { Ntfy } from "./ntfy.js";
-import { createMysqlCli } from "@datatruck/cli/utils/mysql.js";
+import { createMysqlCli, MysqlCliOptions } from "@datatruck/cli/utils/mysql.js";
 export type MySQLDumpItem = {
     name: string;
     database: string;
@@ -13,13 +13,7 @@ export type MySQLDumpOptions = {
     verbose?: boolean;
     minFreeSpace?: string;
     concurrency?: number;
-    connection: MySQLDumpConnection;
-};
-export type MySQLDumpConnection = {
-    hostname: string;
-    password: string;
-    username: string;
-    port?: number;
+    connection: Omit<MysqlCliOptions, "verbose">;
 };
 export type MySQLDumpStats = {
     bytes: number;

package/lib/utils/mysql.js

@@ -158,15 +158,12 @@ export class MySQLDump {
             error,
             stats,
         });
-        await this.ntfy.send(`SQL dump`, {
-            "- Package": item.name,
-            "- Size": formatBytes(stats.bytes),
-            "- Files": stats.files,
-            "- Duration": duration(Date.now() - now),
-            "- Error": error?.message,
-        }, {
-            priority: error ? "high" : "default",
-            tags: [error ? "red_circle" : "green_circle"],
-        });
+        await this.ntfy.send("SQL dump", {
+            Package: item.name,
+            Size: formatBytes(stats.bytes),
+            Files: stats.files,
+            Duration: duration(Date.now() - now),
+            Error: error?.message,
+        }, error);
     }
 }

package/lib/utils/ntfy.d.ts

@@ -1,4 +1,11 @@
 import { Agent } from "undici";
+interface MessageObject {
+    [key: string]: string | number | undefined | ({
+        key: string;
+        value: string | number;
+        level?: number;
+    } | false)[];
+}
 export declare class Ntfy {
     readonly options: {
         token?: string;
@@ -11,8 +18,9 @@ export declare class Ntfy {
         titlePrefix?: string;
         delay?: number;
     });
-    send(inTitle: string, message: any[] | string | Record<string, any>, options?: {
-        priority?: "default" | "high";
-        tags?: string[];
-    }): Promise<void>;
+    private formatTitle;
+    private formatMessage;
+    private formatMessageObject;
+    send(inTitle: string, message: MessageObject, error?: Error | boolean): Promise<void>;
 }
+export {};

package/lib/utils/ntfy.js

@@ -1,5 +1,7 @@
+import { unstyle } from "./string.js";
 import { setTimeout } from "timers/promises";
 import { Agent, fetch } from "undici";
+import { styleText } from "util";
 export class Ntfy {
     options;
     agent;
@@ -11,32 +13,50 @@ export class Ntfy {
             connections: 1,
         });
     }
-    async send(inTitle, message, options = {}) {
-        const title = this.options.titlePrefix
-            ? `${this.options.titlePrefix}${inTitle}`
-            : inTitle;
-        const body = Array.isArray(message)
-            ? message
-                .filter((v) => typeof v === "string" || typeof v === "number")
-                .join("\n")
-            : typeof message === "object" && !!message
-                ? Object.entries(message)
-                    .filter(([, value]) => value !== undefined)
-                    .map(([name, value]) => `${name}: ${value}`)
-                    .join("\n")
-                : message;
+    formatTitle(title) {
+        const text = styleText("cyan", title);
+        const prefix = this.options.titlePrefix;
+        return prefix ? `[${styleText("magenta", prefix)}] ${text}` : text;
+    }
+    formatMessage(name, value, level = 0) {
+        const pad = "  ".repeat(level);
+        return `${pad}- ${name}: ${styleText("gray", value.toString())}`;
+    }
+    formatMessageObject(object, level = 0) {
+        return Object.entries(object)
+            .filter(([, value]) => value !== undefined)
+            .map(([name, value]) => {
+            if (Array.isArray(value)) {
+                return value
+                    .filter((item) => item !== false)
+                    .map((item) => this.formatMessage(item.key, item.value.toString(), item.level))
+                    .join("\n");
+            }
+            else {
+                return this.formatMessage(name, value.toString(), level);
+            }
+        })
+            .join("\n");
+    }
+    async send(inTitle, message, error) {
+        const title = this.formatTitle(inTitle);
+        const body = this.formatMessageObject(message);
         const lines = [title, body].filter((v) => v.length);
         if (lines.length)
             console.info([...lines, ""].join("\n"));
+        const options = {
+            priority: error ? "high" : "default",
+            tags: [error ? "red_circle" : "green_circle"],
+        };
         try {
             if (this.options.token)
                 await fetch(`https://ntfy.sh/${this.options.token}`, {
                     dispatcher: this.agent,
                     method: "POST",
-                    body,
+                    body: unstyle(body),
                     headers: {
                         Markdown: "yes",
-                        Title: title,
+                        Title: unstyle(title),
                         Priority: options.priority ?? "default",
                         ...(options.tags && {
                             Tags: options.tags?.join(","),

package/lib/utils/string.d.ts

@@ -0,0 +1 @@
+export declare function unstyle(str: string): string;

package/lib/utils/string.js

@@ -0,0 +1,3 @@
+export function unstyle(str) {
+    return str.replace(/\x1B\[[0-9;]*m/g, "");
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@datatruck/restic",
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Tool for creating and managing backups",
   "homepage": "https://github.com/swordev/datatruck#readme",
   "bugs": {
@@ -34,7 +34,7 @@
     "ajv": "^8.17.1",
     "commander": "^14.0.2",
     "undici": "^7.18.2",
-    "@datatruck/cli": "0.41.5"
+    "@datatruck/cli": "0.41.6"
   },
   "engine": {
     "node": ">=20.0.0"

package/lib/utils/restic-backup.d.ts

@@ -1,49 +0,0 @@
-import { Ntfy } from "./ntfy.js";
-import { Restic } from "@datatruck/cli/utils/restic.js";
-export type CommonResticBackupTags = {
-    id: string;
-    shortId: string;
-    hostname: string;
-    date: string;
-    vendor: string;
-    version: string;
-};
-export type ResticBackupTags = CommonResticBackupTags & {
-    package: string;
-    tags?: string[];
-};
-export type ResticBackupPackage = {
-    name: string;
-    tags?: string[];
-    path: string;
-    exclude?: string[];
-};
-export type ResticBackupStats = {
-    files: number;
-    bytes: number;
-    diffBytes: number | undefined;
-};
-export type ResticOptions = {
-    name: string;
-    tags: CommonResticBackupTags;
-    minFreeSpace?: string;
-    connection: {
-        password: string;
-        uri: string;
-    };
-};
-export declare class ResticBackup {
-    readonly options: ResticOptions;
-    protected ntfy: Ntfy;
-    protected log: boolean | undefined;
-    readonly processes: {
-        name: string;
-        error?: Error;
-        stats: ResticBackupStats;
-    }[];
-    protected startTime: number;
-    readonly restic: Restic;
-    constructor(options: ResticOptions, ntfy: Ntfy, log: boolean | undefined);
-    run(input: ResticBackupPackage | ResticBackupPackage[]): Promise<void>;
-    protected runSingle(item: ResticBackupPackage): Promise<void>;
-}