zevairouter 1.0.152 → 1.0.154

package/src/lib/db/adapters/sqljsAdapter.js

@@ -10,7 +10,7 @@ async function loadSql() {
   return SQL;
 }
 
-export async function createSqlJsAdapter(filePath) {
+export async function createSqlJsAdapter(filePath, options = {}) {
   const lockPath = `${filePath}.sqljs.lock`;
   let lockFd;
   try {
@@ -42,9 +42,17 @@ export async function createSqlJsAdapter(filePath) {
     releaseLock();
     throw error;
   }
-  const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
-  let db = new SQLLib.Database(buf);
-  db.exec(PRAGMA_SQL);
+  let db;
+  try {
+    options.beforeOpen?.({ filePath });
+    const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
+    db = new SQLLib.Database(buf);
+    db.exec(PRAGMA_SQL);
+  } catch (error) {
+    try { db?.close(); } catch {}
+    releaseLock();
+    throw error;
+  }
   // Schema is created/synced by migrate.js after adapter init
 
   let dirty = false;
@@ -55,6 +63,7 @@ export async function createSqlJsAdapter(filePath) {
     const tempPath = `${filePath}.tmp-${process.pid}`;
     dirty = true;
     try {
+      options.beforePersist?.({ filePath, tempPath });
       fs.writeFileSync(tempPath, Buffer.from(data));
       fs.renameSync(tempPath, filePath);
       dirty = false;
@@ -64,23 +73,54 @@ export async function createSqlJsAdapter(filePath) {
     }
   }
 
+  function restoreSnapshot(snapshot) {
+    let restored;
+    try {
+      restored = new SQLLib.Database(snapshot);
+      restored.exec(PRAGMA_SQL);
+    } catch (error) {
+      try { restored?.close(); } catch {}
+      throw error;
+    }
+
+    const previous = db;
+    db = restored;
+    dirty = false;
+    try { previous.close(); } catch {}
+  }
+
+  function runWithPersistence(operation) {
+    if (transactionDepth > 0) return operation();
+
+    const snapshot = db.export();
+    try {
+      const result = operation();
+      persist();
+      return result;
+    } catch (error) {
+      restoreSnapshot(snapshot);
+      throw error;
+    }
+  }
+
   function paramsObj(params) {
     if (!params || (Array.isArray(params) && params.length === 0)) return undefined;
     return params;
   }
 
   function run(sql, params = []) {
-    const stmt = db.prepare(sql);
-    try {
-      stmt.bind(paramsObj(params));
-      stmt.step();
-      const changes = db.getRowsModified();
-      const lastInsertRowid = db.exec("SELECT last_insert_rowid() as id")[0]?.values?.[0]?.[0] ?? null;
-      if (transactionDepth === 0) persist();
-      return { changes, lastInsertRowid };
-    } finally {
-      stmt.free();
-    }
+    return runWithPersistence(() => {
+      const stmt = db.prepare(sql);
+      try {
+        stmt.bind(paramsObj(params));
+        stmt.step();
+        const changes = db.getRowsModified();
+        const lastInsertRowid = db.exec("SELECT last_insert_rowid() as id")[0]?.values?.[0]?.[0] ?? null;
+        return { changes, lastInsertRowid };
+      } finally {
+        stmt.free();
+      }
+    });
   }
 
   function get(sql, params = []) {
@@ -107,28 +147,32 @@ export async function createSqlJsAdapter(filePath) {
   }
 
   function exec(sql) {
-    db.exec(sql);
-    if (transactionDepth === 0) persist();
+    return runWithPersistence(() => db.exec(sql));
   }
 
   function transaction(fn) {
     const sp = `sp_${Math.random().toString(36).slice(2)}`;
-    const snapshot = transactionDepth === 0 ? db.export() : null;
+    const outermost = transactionDepth === 0;
+    const snapshot = outermost ? db.export() : null;
     db.exec(`SAVEPOINT ${sp}`);
     transactionDepth++;
+    let released = false;
     try {
       const result = fn();
       db.exec(`RELEASE ${sp}`);
+      released = true;
       transactionDepth--;
-      if (transactionDepth === 0) persist();
+      if (outermost) persist();
       return result;
     } catch (e) {
-      transactionDepth--;
-      try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+      // A persist failure happens after RELEASE and after depth was restored.
+      // Only unwind here when the savepoint itself is still active.
+      if (!released) {
+        transactionDepth--;
+        try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+      }
       if (snapshot) {
-        db.close();
-        db = new SQL.Database(snapshot);
-        dirty = false;
+        restoreSnapshot(snapshot);
       }
       throw e;
     }
@@ -138,13 +182,26 @@ export async function createSqlJsAdapter(filePath) {
   function close() {
     if (closed) return;
     closed = true;
+    let closeError = null;
     try {
       if (dirty) persist();
-      db.close();
+    } catch (error) {
+      closeError = error;
     } finally {
-      releaseLock();
+      try { db.close(); } catch (error) { closeError ||= error; }
+      finally { releaseLock(); }
     }
+    if (closeError) throw closeError;
   }
 
-  return { driver: "sql.js", run, get, all, exec, transaction, close, raw: db };
+  return {
+    driver: "sql.js",
+    run,
+    get,
+    all,
+    exec,
+    transaction,
+    close,
+    get raw() { return db; },
+  };
 }

package/src/lib/db/driver.js

@@ -74,19 +74,37 @@ async function initAdapter() {
     state.logged = true;
   }
 
-  const { runMigrationOnce } = await import("./migrate.js");
-  await runMigrationOnce(adapter);
+  try {
+    const { runMigrationOnce } = await import("./migrate.js");
+    await runMigrationOnce(adapter);
 
-  // Reclaim legacy bloat once + keep usageHistory bounded going forward.
-  const { runStartupMaintenanceOnce } = await import("./maintenance.js");
-  runStartupMaintenanceOnce(adapter);
+    // Reclaim legacy bloat once + keep usageHistory bounded going forward.
+    const { runStartupMaintenanceOnce } = await import("./maintenance.js");
+    runStartupMaintenanceOnce(adapter);
 
-  return adapter;
+    return adapter;
+  } catch (error) {
+    try { await adapter.close?.(); } catch (closeError) {
+      console.warn(`[DB] failed to close partially initialized adapter: ${closeError.message}`);
+    }
+    throw error;
+  }
 }
 
 export async function getAdapter() {
   if (state.instance) return state.instance;
-  if (!state.initPromise) state.initPromise = initAdapter().then((a) => { state.instance = a; return a; });
+  if (!state.initPromise) {
+    const pending = initAdapter()
+      .then((adapter) => {
+        state.instance = adapter;
+        return adapter;
+      })
+      .catch((error) => {
+        if (state.initPromise === pending) state.initPromise = null;
+        throw error;
+      });
+    state.initPromise = pending;
+  }
   return state.initPromise;
 }
 
@@ -94,6 +112,8 @@ export async function closeAdapter() {
   if (state.closePromise) return state.closePromise;
   state.closePromise = (async () => {
     try {
+      const { stopStartupMaintenance } = await import("./maintenance.js");
+      stopStartupMaintenance();
       const adapter = state.instance || (state.initPromise ? await state.initPromise : null);
       await adapter?.close?.();
     } finally {

package/src/lib/db/maintenance.js

@@ -70,3 +70,9 @@ export function runStartupMaintenanceOnce(adapter) {
     } catch {}
   }
 }
+
+export function stopStartupMaintenance() {
+  if (!global._usageHistoryPruneTimer) return;
+  clearInterval(global._usageHistoryPruneTimer);
+  global._usageHistoryPruneTimer = null;
+}

package/src/lib/db/repos/requestDetailsRepo.js

@@ -142,12 +142,15 @@ function enqueueDetail(detail, config) {
 }
 
 async function flushToDatabase() {
-  if (isFlushing) return;
-  if (writeBuffer.length === 0) return;
+  if (isFlushing) return false;
+  if (writeBuffer.length === 0) return true;
   isFlushing = true;
+  let config = null;
+  let items = [];
+  let succeeded = false;
   try {
-    const config = await getObservabilityConfig();
-    const items = writeBuffer.splice(0, Math.max(1, config.batchSize));
+    config = await getObservabilityConfig();
+    items = writeBuffer.splice(0, Math.max(1, config.batchSize));
     const db = await getAdapter();
 
     db.transaction(() => {
@@ -166,7 +169,21 @@ async function flushToDatabase() {
         );
       }
     });
+    succeeded = true;
   } catch (e) {
+    if (items.length > 0) {
+      // The transaction did not complete, so put the batch back ahead of newer
+      // arrivals. Keep the same bounded-buffer policy used by enqueueDetail.
+      writeBuffer = [...items, ...writeBuffer];
+      const bufferLimit = getBufferLimit(config?.batchSize || DEFAULT_BATCH_SIZE);
+      if (writeBuffer.length > bufferLimit) {
+        writeBuffer.splice(0, writeBuffer.length - bufferLimit);
+        if (!hasWarnedBufferLimit) {
+          hasWarnedBufferLimit = true;
+          console.warn(`[requestDetailsRepo] Buffer limit reached (${bufferLimit}); dropping oldest observability records`);
+        }
+      }
+    }
     console.error("[requestDetailsRepo] Batch write failed:", e);
   } finally {
     isFlushing = false;
@@ -176,9 +193,13 @@ async function flushToDatabase() {
       flushTimer = setTimeout(() => {
         flushTimer = null;
         flushToDatabase().catch(() => {});
-      }, 0);
+      }, succeeded
+        ? 0
+        : Math.max(250, Math.min(config?.flushIntervalMs || DEFAULT_FLUSH_INTERVAL_MS, DEFAULT_FLUSH_INTERVAL_MS)));
+      flushTimer.unref?.();
     }
   }
+  return succeeded;
 }
 
 export async function saveRequestDetail(detail) {
@@ -216,9 +237,10 @@ export async function getRequestDetails(filter = {}) {
   const cntRow = db.get(`SELECT COUNT(*) as c FROM requestDetails ${where}`, params);
   const totalItems = cntRow ? cntRow.c : 0;
 
-  const page = filter.page || 1;
-  const pageSize = filter.pageSize || 50;
-  const totalPages = Math.ceil(totalItems / pageSize);
+  const requestedPage = Number.isFinite(Number(filter.page)) ? Math.max(1, Math.trunc(Number(filter.page))) : 1;
+  const pageSize = Number.isFinite(Number(filter.pageSize)) ? Math.max(1, Math.trunc(Number(filter.pageSize))) : 50;
+  const totalPages = Math.max(1, Math.ceil(totalItems / pageSize));
+  const page = Math.min(requestedPage, totalPages);
   const offset = (page - 1) * pageSize;
 
   const rows = db.all(
@@ -243,7 +265,11 @@ export async function flushRequestDetails() {
   if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
   while (isFlushing) await new Promise((resolve) => setTimeout(resolve, 10));
   while (writeBuffer.length > 0) {
-    await flushToDatabase();
+    const flushed = await flushToDatabase();
+    if (!flushed) {
+      if (flushTimer) { clearTimeout(flushTimer); flushTimer = null; }
+      throw new Error("Failed to flush request details to the database");
+    }
     while (isFlushing) await new Promise((resolve) => setTimeout(resolve, 10));
   }
 }

package/src/lib/db/repos/settingsRepo.js

@@ -15,6 +15,8 @@ const DEFAULT_SETTINGS = {
   comboStrategy: "fallback",
   comboStickyRoundRobinLimit: 1,
   comboStrategies: {},
+  // Opt-in only: cached completions deliberately trade freshness for cost.
+  responseCacheEnabled: false,
   requireLogin: true,
   tunnelDashboardAccess: true,
   authMode: "password",