@datatruck/restic 0.0.1 → 0.0.2

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.2",
   "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>;
-}

package/lib/utils/restic-backup.js

@@ -1,91 +0,0 @@
-import { checkDiskSpace } from "./fs.js";
-import { ResticRepository } from "@datatruck/cli/repositories/ResticRepository.js";
-import { formatBytes } from "@datatruck/cli/utils/bytes.js";
-import { duration } from "@datatruck/cli/utils/date.js";
-import { isLocalDir } from "@datatruck/cli/utils/fs.js";
-import { Restic } from "@datatruck/cli/utils/restic.js";
-export class ResticBackup {
-    options;
-    ntfy;
-    log;
-    processes = [];
-    startTime;
-    restic;
-    constructor(options, ntfy, log) {
-        this.options = options;
-        this.ntfy = ntfy;
-        this.log = log;
-        this.startTime = Date.now();
-        this.restic = new Restic({
-            env: {
-                RESTIC_PASSWORD: options.connection.password,
-                RESTIC_REPOSITORY: options.connection.uri,
-            },
-            log,
-        });
-    }
-    async run(input) {
-        const items = Array.isArray(input) ? input : [input];
-        for (const item of items) {
-            await this.runSingle(item);
-        }
-    }
-    async runSingle(item) {
-        const now = Date.now();
-        let error;
-        const stats = {
-            bytes: 0,
-            files: 0,
-            diffBytes: undefined,
-        };
-        try {
-            if (isLocalDir(this.options.connection.uri) &&
-                !(await this.restic.checkRepository()))
-                await this.restic.exec(["init"]);
-            const targetPath = isLocalDir(this.options.connection.uri)
-                ? this.options.connection.uri
-                : undefined;
-            stats.diffBytes = await checkDiskSpace({
-                minFreeSpace: this.options.minFreeSpace,
-                minFreeSpacePath: targetPath ?? process.cwd(),
-                targetPath,
-                rutine: () => {
-                    const tags = {
-                        ...this.options.tags,
-                        package: item.name,
-                        tags: item.tags,
-                    };
-                    return this.restic.backup({
-                        tags: ResticRepository.createSnapshotTags(tags),
-                        paths: [item.path],
-                        exclude: item.exclude,
-                        onStream(data) {
-                            if (data.message_type === "summary") {
-                                stats.files = data.total_files_processed;
-                                stats.bytes = data.total_bytes_processed;
-                            }
-                        },
-                    });
-                },
-            });
-        }
-        catch (inError) {
-            error = inError;
-        }
-        this.processes.push({ name: item.name, error, stats });
-        await this.ntfy.send(`Backup`, {
-            "- Repository": this.options.name,
-            "- Package": item.name,
-            "- Size": formatBytes(stats.bytes),
-            ...(stats.diffBytes !== undefined && {
-                "- Size change": (stats.diffBytes > 0 ? "+" : "") + formatBytes(stats.diffBytes),
-            }),
-            "- Files": stats.files,
-            "- Duration": duration(Date.now() - now),
-            "- Error": error?.message,
-        }, {
-            priority: error ? "high" : "default",
-            tags: [error ? "red_circle" : "green_circle"],
-        });
-    }
-}