@archlast/server 0.0.1

package/dist/services/admin/backup.service.js

@@ -0,0 +1,709 @@
+"use strict";
+/**
+ * Admin Backup Service
+ *
+ * Business logic for data backup, restore, import, and export operations.
+ * Handles snapshot files (JSON) and provides data management capabilities.
+ *
+ * @module services/admin/backup
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BackupError = void 0;
+exports.createAdminBackupService = createAdminBackupService;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const logger_js_1 = require("../../logging/logger.js");
+// ============================================================================
+// Constants
+// ============================================================================
+const SNAPSHOT_VERSION = "2.1";
+const SNAPSHOT_DIR = "snapshots";
+// Storage collections
+const STORAGE_OBJECTS_COLLECTION = "_storage_objects";
+const STORAGE_NAMES_COLLECTION = "_storage_names";
+// ============================================================================
+// Error
+// ============================================================================
+class BackupError extends Error {
+    statusCode;
+    constructor(message, statusCode = 400) {
+        super(message);
+        this.statusCode = statusCode;
+        this.name = "BackupError";
+    }
+}
+exports.BackupError = BackupError;
+// ============================================================================
+// Service Factory
+// ============================================================================
+function createAdminBackupService() {
+    /**
+     * Get the snapshots directory path
+     */
+    function getSnapshotsDir() {
+        const snapshotsDir = path.join(process.cwd(), "data", SNAPSHOT_DIR);
+        if (!fs.existsSync(snapshotsDir)) {
+            fs.mkdirSync(snapshotsDir, { recursive: true });
+        }
+        return snapshotsDir;
+    }
+    /**
+     * Generate a snapshot filename
+     */
+    function generateSnapshotName(customName) {
+        if (customName) {
+            return customName.replace(/[^a-zA-Z0-9_-]/g, "_");
+        }
+        const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+        return `snapshot-${timestamp}`;
+    }
+    /**
+     * Get all collection names from the deployment handler
+     */
+    function getCollections(deploymentHandler) {
+        if (!deploymentHandler || typeof deploymentHandler.getSchema !== "function") {
+            return [];
+        }
+        try {
+            const schema = deploymentHandler.getSchema();
+            if (schema?.tables) {
+                return Object.keys(schema.tables);
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.log({
+                level: "warn",
+                kind: "backup",
+                message: "Failed to get schema from deploymentHandler",
+                context: { error: error.message },
+            });
+        }
+        return [];
+    }
+    /**
+     * Check if a collection is a system collection that should be excluded from backups
+     * Note: Storage collections are handled separately
+     *
+     * System collections include:
+     * - Platform system tables (logs, cache, etc.)
+     * - Better-Auth tables (user authentication, sessions, API keys, etc.)
+     * - OTP/MFA tables (two-factor authentication)
+     * - Settings tables (system configuration)
+     */
+    function isSystemCollection(collection) {
+        const systemCollections = [
+            // Platform system tables
+            "_logs",
+            "_storage_staging",
+            "_cache",
+            "_system_settings",
+            "_storage_objects",
+            "_storage_names",
+            // Better-Auth core tables
+            "auth_users",
+            "auth_accounts",
+            "auth_sessions",
+            "auth_tenants",
+            "auth_memberships",
+            "auth_invites",
+            // Better-Auth plugin tables
+            "better_auth_verification",
+            "better_auth_organization",
+            "better_auth_member",
+            "better_auth_invitation",
+            "apikey",
+            // Extended auth tables
+            "auth_admin_api_keys",
+            "auth_audit_logs",
+            "auth_security_events",
+            "auth_email_verification_tokens",
+            "auth_password_reset_tokens",
+            // OTP/MFA tables
+            "auth_otp",
+            "auth_mfa",
+        ];
+        return systemCollections.includes(collection);
+    }
+    /**
+     * Export storage data (metadata collections and files)
+     */
+    async function exportStorageData(db, storageManager) {
+        try {
+            // Export _storage_objects collection
+            const objectsRecords = await db.query(STORAGE_OBJECTS_COLLECTION).findMany();
+            const objectsCollection = {
+                records: objectsRecords,
+                count: objectsRecords.length,
+            };
+            // Export _storage_names collection
+            const namesRecords = await db.query(STORAGE_NAMES_COLLECTION).findMany();
+            const namesCollection = {
+                records: namesRecords,
+                count: namesRecords.length,
+            };
+            // Export actual files from FS backend
+            const files = [];
+            const storageRoot = process.env.STORAGE_ROOT || "./storage";
+            const objectsDir = path.join(storageRoot, "objects");
+            let totalSize = 0;
+            if (fs.existsSync(objectsDir)) {
+                for (const obj of objectsRecords) {
+                    const prefix = obj.objectId?.slice(0, 2);
+                    if (!prefix)
+                        continue;
+                    const filePath = path.join(objectsDir, prefix, obj.objectId);
+                    try {
+                        if (fs.existsSync(filePath)) {
+                            const fileData = await fs.promises.readFile(filePath);
+                            files.push({
+                                id: obj.objectId,
+                                data: fileData.toString("base64"),
+                            });
+                            totalSize += fileData.length;
+                        }
+                    }
+                    catch (error) {
+                        logger_js_1.logger.log({
+                            level: "warn",
+                            kind: "backup",
+                            message: `Failed to read storage file: ${obj.objectId}`,
+                            context: { error: error.message },
+                        });
+                    }
+                }
+            }
+            logger_js_1.logger.log({
+                level: "info",
+                kind: "backup",
+                message: `Storage export: ${objectsCollection.count} objects, ${namesCollection.count} names, ${files.length} files (${(totalSize / 1024).toFixed(2)} KB)`,
+            });
+            return {
+                objectsCollection,
+                namesCollection,
+                files,
+                summary: {
+                    objectsCount: objectsCollection.count,
+                    totalSize,
+                    filesCount: files.length,
+                },
+            };
+        }
+        catch (error) {
+            logger_js_1.logger.log({
+                level: "warn",
+                kind: "backup",
+                message: "Failed to export storage data",
+                context: { error: error.message },
+            });
+            return null;
+        }
+    }
+    /**
+     * Import storage data (metadata collections and files)
+     */
+    async function importStorageData(db, storageData, options) {
+        const { restoreFiles = true, storageRoot = process.env.STORAGE_ROOT || "./storage" } = options || {};
+        let filesRestored = 0;
+        let metadataRestored = false;
+        try {
+            // Step 1: Restore metadata collections
+            await db.runInTransaction(async (tx) => {
+                // Clear and restore _storage_objects collection
+                await tx.deleteMany(STORAGE_OBJECTS_COLLECTION, {});
+                for (const record of storageData.objectsCollection.records) {
+                    const { _id, ...recordData } = record;
+                    await tx.insert(STORAGE_OBJECTS_COLLECTION, recordData);
+                }
+                // Clear and restore _storage_names collection
+                await tx.deleteMany(STORAGE_NAMES_COLLECTION, {});
+                for (const record of storageData.namesCollection.records) {
+                    const { _id, ...recordData } = record;
+                    await tx.insert(STORAGE_NAMES_COLLECTION, recordData);
+                }
+            });
+            metadataRestored = true;
+            logger_js_1.logger.log({
+                level: "info",
+                kind: "backup",
+                message: `Storage metadata restored: ${storageData.objectsCollection.count} objects, ${storageData.namesCollection.count} names`,
+            });
+            // Step 2: Restore actual files
+            if (restoreFiles && storageData.files.length > 0) {
+                const objectsDir = path.join(storageRoot, "objects");
+                for (const file of storageData.files) {
+                    const prefix = file.id.slice(0, 2);
+                    const dirPath = path.join(objectsDir, prefix);
+                    try {
+                        await fs.promises.mkdir(dirPath, { recursive: true });
+                        const filePath = path.join(dirPath, file.id);
+                        const fileData = Buffer.from(file.data, "base64");
+                        await fs.promises.writeFile(filePath, fileData);
+                        filesRestored++;
+                    }
+                    catch (error) {
+                        logger_js_1.logger.log({
+                            level: "warn",
+                            kind: "backup",
+                            message: `Failed to restore storage file: ${file.id}`,
+                            context: { error: error.message },
+                        });
+                    }
+                }
+                logger_js_1.logger.log({
+                    level: "info",
+                    kind: "backup",
+                    message: `Storage files restored: ${filesRestored}/${storageData.files.length} files`,
+                });
+            }
+            return { filesRestored, metadataRestored };
+        }
+        catch (error) {
+            logger_js_1.logger.log({
+                level: "error",
+                kind: "backup",
+                message: "Failed to import storage data",
+                context: { error: error.message },
+            });
+            return { filesRestored, metadataRestored };
+        }
+    }
+    /**
+     * Create a snapshot of all database data
+     */
+    async function createSnapshot(options) {
+        const { db, deploymentHandler, storageManager } = options;
+        const snapshotName = generateSnapshotName(options.snapshotName);
+        try {
+            // Get collections from deployment handler
+            const allCollections = getCollections(deploymentHandler);
+            if (allCollections.length === 0) {
+                logger_js_1.logger.log({
+                    level: "warn",
+                    kind: "backup",
+                    message: "No collections found in schema",
+                });
+            }
+            // Filter out system collections (storage is handled separately)
+            const collections = allCollections.filter((c) => !isSystemCollection(c));
+            const snapshotData = {
+                version: SNAPSHOT_VERSION,
+                createdAt: new Date().toISOString(),
+                snapshotName: options.snapshotName || snapshotName,
+                collections: {},
+            };
+            let totalRecords = 0;
+            // Export each collection
+            for (const collection of collections) {
+                try {
+                    const records = await db.query(collection).findMany();
+                    snapshotData.collections[collection] = {
+                        records,
+                        count: records.length,
+                    };
+                    totalRecords += records.length;
+                    logger_js_1.logger.log({
+                        level: "info",
+                        kind: "backup",
+                        message: `Exported collection: ${collection} (${records.length} records)`,
+                    });
+                }
+                catch (error) {
+                    logger_js_1.logger.log({
+                        level: "warn",
+                        kind: "backup",
+                        message: `Failed to export collection: ${collection}`,
+                        context: { error: error.message },
+                    });
+                }
+            }
+            // Export storage data (metadata + files)
+            let storageObjectsCount = 0;
+            let storageSize = 0;
+            if (storageManager) {
+                const storageData = await exportStorageData(db, storageManager);
+                if (storageData) {
+                    snapshotData.storage = storageData;
+                    storageObjectsCount = storageData.summary.objectsCount;
+                    storageSize = storageData.summary.totalSize;
+                }
+            }
+            // Write snapshot to file
+            const snapshotsDir = getSnapshotsDir();
+            const filename = `${snapshotName}.json`;
+            const filePath = path.join(snapshotsDir, filename);
+            await fs.promises.writeFile(filePath, JSON.stringify(snapshotData, null, 2), "utf-8");
+            const stats = await fs.promises.stat(filePath);
+            logger_js_1.logger.log({
+                level: "info",
+                kind: "backup",
+                message: `Snapshot created: ${filename}`,
+                context: {
+                    recordCount: totalRecords,
+                    collections: collections.length,
+                    storageObjects: storageObjectsCount,
+                    storageSize: (storageSize / 1024).toFixed(2) + " KB",
+                    fileSize: (stats.size / 1024).toFixed(2) + " KB",
+                },
+            });
+            return {
+                success: true,
+                snapshotFile: filename,
+                recordCount: totalRecords,
+                collections,
+                storageObjects: storageObjectsCount,
+                storageSize,
+            };
+        }
+        catch (error) {
+            const message = error.message;
+            logger_js_1.logger.log({
+                level: "error",
+                kind: "backup",
+                message: `Failed to create snapshot: ${message}`,
+                context: { error: message },
+            });
+            return {
+                success: false,
+                snapshotFile: "",
+                recordCount: 0,
+                collections: [],
+                error: message,
+            };
+        }
+    }
+    /**
+     * List all available snapshots
+     */
+    async function listSnapshots(options) {
+        const { snapshotsDir } = options;
+        try {
+            const files = await fs.promises.readdir(snapshotsDir);
+            const snapshotFiles = files.filter((f) => f.endsWith(".json"));
+            const snapshots = [];
+            let totalSize = 0;
+            for (const file of snapshotFiles) {
+                try {
+                    const filePath = path.join(snapshotsDir, file);
+                    const stats = await fs.promises.stat(filePath);
+                    const content = await fs.promises.readFile(filePath, "utf-8");
+                    const data = JSON.parse(content);
+                    const recordCount = Object.values(data.collections || {}).reduce((sum, col) => sum + (col?.count || 0), 0);
+                    snapshots.push({
+                        filename: file,
+                        name: data.snapshotName || file.replace(".json", ""),
+                        createdAt: data.createdAt,
+                        size: stats.size,
+                        recordCount,
+                        collections: Object.keys(data.collections || {}),
+                        storageObjects: data.storage?.summary?.objectsCount,
+                        storageSize: data.storage?.summary?.totalSize,
+                    });
+                    totalSize += stats.size;
+                }
+                catch {
+                    continue;
+                }
+            }
+            snapshots.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+            return { snapshots, totalSize };
+        }
+        catch (error) {
+            logger_js_1.logger.log({
+                level: "error",
+                kind: "backup",
+                message: `Failed to list snapshots: ${error.message}`,
+            });
+            return { snapshots: [], totalSize: 0 };
+        }
+    }
+    /**
+     * Download a snapshot file's content
+     */
+    async function downloadSnapshot(options) {
+        const { snapshotFile, snapshotsDir } = options;
+        try {
+            const filePath = path.join(snapshotsDir, snapshotFile);
+            if (!fs.existsSync(filePath)) {
+                logger_js_1.logger.log({
+                    level: "warn",
+                    kind: "backup",
+                    message: `Snapshot file not found: ${snapshotFile}`,
+                });
+                return null;
+            }
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            return JSON.parse(content);
+        }
+        catch (error) {
+            logger_js_1.logger.log({
+                level: "error",
+                kind: "backup",
+                message: `Failed to read snapshot: ${error.message}`,
+            });
+            return null;
+        }
+    }
+    /**
+     * Restore data from a snapshot file
+     */
+    async function restoreSnapshot(options) {
+        const { db, snapshotFile, storageManager } = options;
+        try {
+            const snapshotsDir = getSnapshotsDir();
+            const filePath = path.join(snapshotsDir, snapshotFile);
+            if (!fs.existsSync(filePath)) {
+                return {
+                    success: false,
+                    recordsImported: 0,
+                    collections: [],
+                    error: `Snapshot file not found: ${snapshotFile}`,
+                };
+            }
+            const content = await fs.promises.readFile(filePath, "utf-8");
+            const data = JSON.parse(content);
+            // Support versions 1.0, 2.0, and 2.1
+            if (data.version !== "1.0" && data.version !== "2.0" && data.version !== "2.1") {
+                return {
+                    success: false,
+                    recordsImported: 0,
+                    collections: [],
+                    error: `Unsupported snapshot version: ${data.version}`,
+                };
+            }
+            const collections = Object.keys(data.collections || {});
+            let totalImported = 0;
+            let storageRestored = 0;
+            let storageMetadataRestored = false;
+            // Restore storage first if available
+            if (data.storage && storageManager) {
+                const storageResult = await importStorageData(db, data.storage);
+                storageRestored = storageResult.filesRestored;
+                storageMetadataRestored = storageResult.metadataRestored;
+            }
+            // Restore collections
+            await db.runInTransaction(async (tx) => {
+                for (const collection of collections) {
+                    const collectionData = data.collections[collection];
+                    if (!collectionData || !Array.isArray(collectionData.records)) {
+                        continue;
+                    }
+                    try {
+                        await tx.deleteMany(collection, {});
+                        for (const record of collectionData.records) {
+                            const { _id, _collection, ...recordData } = record;
+                            await tx.insert(collection, recordData);
+                        }
+                        totalImported += collectionData.count;
+                        logger_js_1.logger.log({
+                            level: "info",
+                            kind: "backup",
+                            message: `Restored collection: ${collection} (${collectionData.count} records)`,
+                        });
+                    }
+                    catch (error) {
+                        logger_js_1.logger.log({
+                            level: "warn",
+                            kind: "backup",
+                            message: `Failed to restore collection: ${collection}`,
+                            context: { error: error.message },
+                        });
+                    }
+                }
+            });
+            logger_js_1.logger.log({
+                level: "info",
+                kind: "backup",
+                message: `Snapshot restored: ${snapshotFile}`,
+                context: {
+                    recordsImported: totalImported,
+                    collections: collections.length,
+                    storageRestored,
+                    storageMetadataRestored,
+                },
+            });
+            db.clearCache();
+            return {
+                success: true,
+                recordsImported: totalImported,
+                collections,
+                storageRestored,
+                storageMetadataRestored,
+            };
+        }
+        catch (error) {
+            const message = error.message;
+            logger_js_1.logger.log({
+                level: "error",
+                kind: "backup",
+                message: `Failed to restore snapshot: ${message}`,
+                context: { error: message },
+            });
+            return {
+                success: false,
+                recordsImported: 0,
+                collections: [],
+                error: message,
+            };
+        }
+    }
+    /**
+     * Import data from an external snapshot
+     */
+    async function importData(options) {
+        const { db, data, strategy = "merge", storageManager } = options;
+        try {
+            if (!data.collections || typeof data.collections !== "object") {
+                return {
+                    success: false,
+                    recordsImported: 0,
+                    collections: [],
+                    error: "Invalid snapshot data: missing collections",
+                };
+            }
+            const collections = Object.keys(data.collections);
+            let totalImported = 0;
+            let storageRestored = 0;
+            let storageMetadataRestored = false;
+            // Restore storage first if available
+            if (data.storage && storageManager) {
+                const storageResult = await importStorageData(db, data.storage);
+                storageRestored = storageResult.filesRestored;
+                storageMetadataRestored = storageResult.metadataRestored;
+            }
+            for (const collection of collections) {
+                const collectionData = data.collections[collection];
+                if (!collectionData || !Array.isArray(collectionData.records)) {
+                    continue;
+                }
+                try {
+                    if (strategy === "replace") {
+                        await db.deleteMany(collection, {});
+                    }
+                    for (const record of collectionData.records) {
+                        const { _id, _collection, ...recordData } = record;
+                        await db.insert(collection, recordData);
+                    }
+                    totalImported += collectionData.count;
+                    logger_js_1.logger.log({
+                        level: "info",
+                        kind: "backup",
+                        message: `Imported collection: ${collection} (${collectionData.count} records)`,
+                    });
+                }
+                catch (error) {
+                    logger_js_1.logger.log({
+                        level: "warn",
+                        kind: "backup",
+                        message: `Failed to import collection: ${collection}`,
+                        context: { error: error.message },
+                    });
+                }
+            }
+            db.clearCache();
+            logger_js_1.logger.log({
+                level: "info",
+                kind: "backup",
+                message: `Data imported successfully`,
+                context: {
+                    recordsImported: totalImported,
+                    strategy,
+                    storageRestored,
+                    storageMetadataRestored,
+                },
+            });
+            return {
+                success: true,
+                recordsImported: totalImported,
+                collections,
+                storageRestored,
+                storageMetadataRestored,
+            };
+        }
+        catch (error) {
+            const message = error.message;
+            logger_js_1.logger.log({
+                level: "error",
+                kind: "backup",
+                message: `Failed to import data: ${message}`,
+                context: { error: message },
+            });
+            return {
+                success: false,
+                recordsImported: 0,
+                collections: [],
+                error: message,
+            };
+        }
+    }
+    /**
+     * Delete a snapshot file
+     */
+    async function deleteSnapshot(options) {
+        const { snapshotFile, snapshotsDir } = options;
+        try {
+            const filePath = path.join(snapshotsDir, snapshotFile);
+            if (!fs.existsSync(filePath)) {
+                return {
+                    success: false,
+                    error: `Snapshot file not found: ${snapshotFile}`,
+                };
+            }
+            await fs.promises.unlink(filePath);
+            logger_js_1.logger.log({
+                level: "info",
+                kind: "backup",
+                message: `Snapshot deleted: ${snapshotFile}`,
+            });
+            return { success: true };
+        }
+        catch (error) {
+            const message = error.message;
+            return {
+                success: false,
+                error: message,
+            };
+        }
+    }
+    return {
+        createSnapshot,
+        listSnapshots,
+        restoreSnapshot,
+        importData,
+        deleteSnapshot,
+        downloadSnapshot,
+    };
+}
+//# sourceMappingURL=backup.service.js.map