@fudrouter/fsrouter 0.6.99 → 0.6.101

package/dist/lib/db/driver.js

@@ -79,6 +79,14 @@ export async function getAdapter() {
   return state.initPromise;
 }
 
+// Force re-open the underlying connection (used after an explicit close, e.g.
+// during raw DB restore). Without this, getAdapter() would return the stale
+// closed instance and every subsequent query throws "connection is not open".
+export function resetAdapter() {
+  state.instance = null;
+  state.initPromise = null;
+}
+
 export function getAdapterSync() {
   if (!state.instance) throw new Error("[DB] adapter not initialized — await getAdapter() first");
   return state.instance;

package/dist/routes/db/route.js

@@ -1,4 +1,4 @@
-import { getAdapter } from "../../lib/db/driver.js";
+import { getAdapter, resetAdapter } from "../../lib/db/driver.js";
 import { exportDb, importDb } from "../../lib/db/index.js";
 import { DATA_DIR } from "../../lib/dataDir.js";
 import path from "path";
@@ -55,117 +55,158 @@ export async function GET(req, res) {
         return res.status(500).json({ error: "Failed to generate backup: " + error.message });
     }
 }
-// POST /api/db - Restore database & secrets
+// ─── SSE helpers for streaming restore progress ───────────────────────────────
+function sseInit(res) {
+    res.writeHead(200, {
+        "Content-Type": "text/event-stream",
+        "Cache-Control": "no-cache, no-transform",
+        "Connection": "keep-alive",
+        "X-Accel-Buffering": "no"
+    });
+}
+function sseSend(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+}
+// POST /api/db - Restore database & secrets (streaming progress)
 export async function POST_handler(req, res) {
-    try {
-        const body = req.body;
-        if (!body || body.signature !== "FUDROUTER_BACKUP") {
-            return res.status(400).json({ error: "Invalid backup file signature." });
-        }
-        // Prefer logical import: raw SQLite replacement can lose rows when WAL/driver
-        // state differs between machines. Keep raw-file restore below for old backups.
-        if (body.database) {
-            await importDb(body.database);
-            // Flush WAL into the main DB file BEFORE we remove -wal/-shm below,
-            // otherwise the just-imported rows live only in the WAL and get deleted.
-            const db = await getAdapter();
-            if (db && typeof db.checkpoint === "function") {
-                try {
-                    db.checkpoint();
+    // Switch to SSE immediately so the client sees progress from the start.
+    sseInit(res);
+    const log = (msg, level = "info") => sseSend(res, "log", { message: msg, level, ts: new Date().toISOString() });
+    const progress = (percent, label) => {
+        sseSend(res, "progress", { percent, label });
+        log(label);
+    };
+    // Run restore asynchronously; don't await the whole thing on the request.
+    (async () => {
+        try {
+            const body = req.body;
+            progress(5, "Memvalidasi file backup...");
+            if (!body || body.signature !== "FUDROUTER_BACKUP") {
+                sseSend(res, "error", { message: "Invalid backup file signature." });
+                return res.end();
+            }
+            // Prefer logical import: raw SQLite replacement can lose rows when WAL/driver
+            // state differs between machines. Keep raw-file restore below for old backups.
+            const hasLogical = !!body.database;
+            if (hasLogical) {
+                progress(15, "Mengimpor data logical (provider, connections, proxy, api keys, combos)...");
+                // Import on the live connection — do NOT close it first, or getAdapter()
+                // would keep returning the stale closed instance and every query throws
+                // "The database connection is not open".
+                await importDb(body.database);
+                progress(40, "Flush WAL ke file database utama (checkpoint)...");
+                const db = await getAdapter();
+                if (db && typeof db.checkpoint === "function") {
+                    try {
+                        db.checkpoint();
+                    }
+                    catch (e) {
+                        log(`checkpoint gagal: ${e.message}`, "warn");
+                    }
                 }
-                catch (e) {
-                    console.warn("[Restore] checkpoint failed:", e.message);
+                if (db && typeof db.exec === "function") {
+                    try {
+                        db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+                    }
+                    catch { /* ignore */ }
                 }
             }
-            if (db && typeof db.exec === "function") {
-                try {
-                    db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+            else {
+                progress(15, "Menutup koneksi database aktif (raw restore)...");
+                const db = await getAdapter();
+                if (db && typeof db.close === "function") {
+                    try {
+                        db.close();
+                    }
+                    catch { /* ignore */ }
                 }
-                catch { /* ignore */ }
+                // Reset cached instance so the next getAdapter() re-opens a fresh connection.
+                resetAdapter();
             }
-        }
-        else {
-            const db = await getAdapter();
-            if (db && typeof db.close === "function")
-                db.close();
-        }
-        // 2. Remove active -wal and -shm files to prevent corruption/mismatch.
-        // On Windows these files can be locked by the OS/AV/SQLite even after
-        // db.close() (EBUSY). Use a retry + rename fallback so restore never
-        // hard-fails on a transient lock.
-        const walFile = path.join(DATA_DIR, "db", "data.sqlite-wal");
-        const shmFile = path.join(DATA_DIR, "db", "data.sqlite-shm");
-        const safeUnlink = (file) => {
-            if (!fs.existsSync(file))
-                return;
-            // Give the DB a moment to fully release the file handle.
-            const attempts = process.platform === "win32" ? 12 : 3;
-            for (let i = 0; i < attempts; i++) {
-                try {
-                    fs.unlinkSync(file);
+            // 2. Remove active -wal and -shm files to prevent corruption/mismatch.
+            progress(50, "Membersihkan file WAL/SHM lock...");
+            const walFile = path.join(DATA_DIR, "db", "data.sqlite-wal");
+            const shmFile = path.join(DATA_DIR, "db", "data.sqlite-shm");
+            const safeUnlink = (file) => {
+                if (!fs.existsSync(file))
                     return;
-                }
-                catch (e) {
-                    if (e.code === "EBUSY" || e.code === "EPERM" || e.code === "ETXTBSY") {
-                        // Fallback: rename out of the way (atomic on NTFS) then retry unlink.
-                        try {
-                            const tmp = `${file}.old-${Date.now()}`;
-                            fs.renameSync(file, tmp);
+                const attempts = process.platform === "win32" ? 12 : 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        fs.unlinkSync(file);
+                        return;
+                    }
+                    catch (e) {
+                        if (e.code === "EBUSY" || e.code === "EPERM" || e.code === "ETXTBSY") {
                             try {
-                                fs.unlinkSync(tmp);
+                                const tmp = `${file}.old-${Date.now()}`;
+                                fs.renameSync(file, tmp);
+                                try {
+                                    fs.unlinkSync(tmp);
+                                }
+                                catch { /* ignore */ }
+                                return;
                             }
-                            catch { /* ignore */ }
-                            return;
-                        }
-                        catch {
-                            // Wait and retry — the lock may be released shortly.
-                            try {
-                                Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+                            catch {
+                                try {
+                                    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, 250);
+                                }
+                                catch { /* noop */ }
+                                continue;
                             }
-                            catch { /* noop */ }
-                            continue;
                         }
+                        throw e;
                     }
-                    throw e;
                 }
-            }
-            // Last resort: leave the file; SQLite rebuilds -wal/-shm on next open.
-            console.warn(`[Restore] Could not remove ${file} (locked) — continuing.`);
-        };
-        safeUnlink(walFile);
-        safeUnlink(shmFile);
-        // 3. Restore secrets/raw DB only for legacy backups. Do not overwrite the
-        // logical import with a stale/incompatible SQLite file.
-        const filesToRestore = [
-            { key: "db/data.sqlite", path: path.join(DATA_DIR, "db", "data.sqlite") },
-            { key: "machine-id", path: path.join(DATA_DIR, "machine-id") },
-            { key: "jwt-secret", path: path.join(DATA_DIR, "jwt-secret") },
-            { key: "auth/cli-secret", path: path.join(DATA_DIR, "auth", "cli-secret") }
-        ];
-        for (const item of filesToRestore) {
-            if (body.database && item.key === "db/data.sqlite")
-                continue;
-            const b64Data = body.files?.[item.key];
-            if (b64Data) {
-                // Ensure directory exists
-                const dir = path.dirname(item.path);
-                if (!fs.existsSync(dir)) {
-                    fs.mkdirSync(dir, { recursive: true });
+                log(`Tidak bisa menghapus ${file} (terkunci) — melanjutkan.`, "warn");
+            };
+            safeUnlink(walFile);
+            safeUnlink(shmFile);
+            // 3. Restore secrets/raw DB only for legacy backups. Do not overwrite the
+            // logical import with a stale/incompatible SQLite file.
+            const filesToRestore = [
+                { key: "db/data.sqlite", path: path.join(DATA_DIR, "db", "data.sqlite") },
+                { key: "machine-id", path: path.join(DATA_DIR, "machine-id") },
+                { key: "jwt-secret", path: path.join(DATA_DIR, "jwt-secret") },
+                { key: "auth/cli-secret", path: path.join(DATA_DIR, "auth", "cli-secret") }
+            ];
+            let idx = 0;
+            const total = filesToRestore.length;
+            for (const item of filesToRestore) {
+                if (hasLogical && item.key === "db/data.sqlite") {
+                    idx++;
+                    continue; // logical import already applied the DB
+                }
+                const b64Data = body.files?.[item.key];
+                const pct = 60 + Math.round((idx / total) * 35);
+                if (b64Data) {
+                    progress(pct, `Menimpa file: ${item.key} ...`);
+                    const dir = path.dirname(item.path);
+                    if (!fs.existsSync(dir))
+                        fs.mkdirSync(dir, { recursive: true });
+                    fs.writeFileSync(item.path, Buffer.from(b64Data, "base64"));
+                    log(`✓ Di-timpa: ${item.key}`, "info");
                 }
-                // Write file
-                fs.writeFileSync(item.path, Buffer.from(b64Data, "base64"));
-                console.log(`[Restore] Restored: ${item.key}`);
+                else {
+                    log(`Lewati (tidak ada di backup): ${item.key}`, "warn");
+                }
+                idx++;
             }
+            progress(100, "Restore selesai. Server akan merestart...");
+            sseSend(res, "done", { success: true, message: "Restore berhasil. Server merestart..." });
+            // 4. Shut down process so PM2 restarts it (applies restored data cleanly)
+            setTimeout(() => {
+                try {
+                    process.exit(0);
+                }
+                catch { /* ignore */ }
+            }, 1200);
         }
-        // 4. Send success response and shut down process so PM2 restarts it
-        res.json({ success: true, message: "Restore successful. Server is restarting..." });
-        console.log("[Restore] Successful. Exiting process for restart...");
-        setTimeout(() => {
-            process.exit(0);
-        }, 1500);
-    }
-    catch (error) {
-        console.error("Restore error:", error);
-        return res.status(500).json({ error: "Failed to restore backup: " + error.message });
-    }
+        catch (error) {
+            console.error("Restore error:", error);
+            sseSend(res, "error", { message: "Restore gagal: " + (error?.message || error) });
+            res.end();
+        }
+    })();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fudrouter/fsrouter",
-  "version": "0.6.99",
+  "version": "0.6.101",
   "private": false,
   "type": "module",
   "description": "9Router v2 — Express Backend (API, SSE, DB, Auth, MITM)",