swayrouter 1.0.0

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

@@ -0,0 +1,103 @@
+import fs from "node:fs";
+import initSqlJs from "sql.js";
+import { PRAGMA_SQL } from "../schema.js";
+
+let SQL = null;
+
+async function loadSql() {
+  if (SQL) return SQL;
+  SQL = await initSqlJs();
+  return SQL;
+}
+
+export async function createSqlJsAdapter(filePath) {
+  const SQLLib = await loadSql();
+  const buf = fs.existsSync(filePath) ? fs.readFileSync(filePath) : null;
+  const db = new SQLLib.Database(buf);
+  db.exec(PRAGMA_SQL);
+
+  let dirty = false;
+  let saveTimer = null;
+  const SAVE_DEBOUNCE_MS = 100;
+
+  function persist() {
+    const data = db.export();
+    fs.writeFileSync(filePath, Buffer.from(data));
+    dirty = false;
+  }
+
+  function scheduleSave() {
+    dirty = true;
+    if (saveTimer) clearTimeout(saveTimer);
+    saveTimer = setTimeout(() => {
+      saveTimer = null;
+      if (dirty) {
+        try { persist(); } catch (e) { console.error("[sqljs] save failed:", e); }
+      }
+    }, SAVE_DEBOUNCE_MS);
+  }
+
+  function paramsObj(params) {
+    if (!params || (Array.isArray(params) && params.length === 0)) return undefined;
+    return params;
+  }
+
+  function useStatement(sql, params, work) {
+    const stmt = db.prepare(sql);
+    try {
+      stmt.bind(paramsObj(params));
+      return work(stmt);
+    } finally {
+      stmt.free();
+    }
+  }
+
+  function run(sql, params = []) {
+    return useStatement(sql, params, (stmt) => {
+      stmt.step();
+      const changes = db.getRowsModified();
+      const lastInsertRowid = db.exec("SELECT last_insert_rowid() as id")[0]?.values?.[0]?.[0] ?? null;
+      scheduleSave();
+      return { changes, lastInsertRowid };
+    });
+  }
+
+  function get(sql, params = []) {
+    return useStatement(sql, params, (stmt) => stmt.step() ? stmt.getAsObject() : undefined);
+  }
+
+  function all(sql, params = []) {
+    return useStatement(sql, params, (stmt) => {
+      const rows = [];
+      while (stmt.step()) rows.push(stmt.getAsObject());
+      return rows;
+    });
+  }
+
+  function exec(sql) {
+    db.exec(sql);
+    scheduleSave();
+  }
+
+  function transaction(fn) {
+    const sp = `sp_${Math.random().toString(36).slice(2)}`;
+    db.exec(`SAVEPOINT ${sp}`);
+    try {
+      const result = fn();
+      db.exec(`RELEASE ${sp}`);
+      scheduleSave();
+      return result;
+    } catch (e) {
+      try { db.exec(`ROLLBACK TO ${sp}`); db.exec(`RELEASE ${sp}`); } catch {}
+      throw e;
+    }
+  }
+
+  function close() {
+    if (saveTimer) clearTimeout(saveTimer);
+    if (dirty) persist();
+    db.close();
+  }
+
+  return { driver: "sql.js", run, get, all, exec, transaction, close, raw: db };
+}

package/src/lib/db/backup.js

@@ -0,0 +1,75 @@
+import fs from "node:fs";
+import path from "node:path";
+import { BACKUPS_DIR, ensureDirs } from "./paths.js";
+import { timestampSlug, getAppVersion } from "./version.js";
+
+const KEEP_BACKUPS = 3;
+
+const BACKUP_EXCLUDE_TABLES = ["requestDetails"];
+
+function applyPrivateMode(target, mode) {
+  if (process.platform === "win32") return;
+  try {
+    fs.chmodSync(target, mode);
+  } catch (error) {
+    if (process.env.NODE_ENV === "production") throw error;
+  }
+}
+
+export function makeBackupDir(label) {
+  ensureDirs();
+  const ver = getAppVersion();
+  const slug = `${label}-${ver}-${timestampSlug()}`;
+  const dir = path.join(BACKUPS_DIR, slug);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  applyPrivateMode(dir, 0o700);
+  return dir;
+}
+
+export function backupFile(srcPath, destDir, destName = null) {
+  if (!fs.existsSync(srcPath)) return null;
+  const name = destName || path.basename(srcPath);
+  const dest = path.join(destDir, name);
+  fs.copyFileSync(srcPath, dest, { mode: 0o600 });
+  applyPrivateMode(dest, 0o600);
+  return dest;
+}
+
+export function backupDbLite(adapter, destDir, destName = "data.sqlite") {
+  const dest = path.join(destDir, destName);
+  try { fs.rmSync(dest, { force: true }); } catch {}
+  const escaped = dest.replace(/'/g, "''");
+
+  adapter.exec(`ATTACH DATABASE '${escaped}' AS bak`);
+  try {
+    const excluded = new Set(BACKUP_EXCLUDE_TABLES);
+    const tables = adapter
+      .all(`SELECT name, sql FROM main.sqlite_master WHERE type='table' AND name NOT LIKE 'sqlite_%'`)
+      .filter((t) => !excluded.has(t.name));
+
+    adapter.transaction(() => {
+      for (const t of tables) {
+
+        const createSql = t.sql.replace(/CREATE TABLE\s+/i, "CREATE TABLE bak.");
+        adapter.exec(createSql);
+        adapter.exec(`INSERT INTO bak.${t.name} SELECT * FROM main.${t.name}`);
+      }
+    });
+  } finally {
+    try { adapter.exec("DETACH DATABASE bak"); } catch {}
+  }
+  applyPrivateMode(dest, 0o600);
+  return dest;
+}
+
+export function pruneOldBackups() {
+  if (!fs.existsSync(BACKUPS_DIR)) return;
+  const entries = fs.readdirSync(BACKUPS_DIR, { withFileTypes: true })
+    .filter((e) => e.isDirectory())
+    .map((e) => ({ name: e.name, full: path.join(BACKUPS_DIR, e.name), mtime: fs.statSync(path.join(BACKUPS_DIR, e.name)).mtimeMs }))
+    .sort((a, b) => b.mtime - a.mtime);
+
+  for (const old of entries.slice(KEEP_BACKUPS)) {
+    try { fs.rmSync(old.full, { recursive: true, force: true }); } catch {}
+  }
+}

package/src/lib/db/driver.js

@@ -0,0 +1,110 @@
+import { ensureDirs, DATA_FILE } from "./paths.js";
+
+if (!global._dbAdapter) global._dbAdapter = { instance: null, initPromise: null, logged: false };
+const state = global._dbAdapter;
+
+function rememberAdapter(adapter) {
+  state.instance = adapter;
+  return adapter;
+}
+
+function resetAdapterState() {
+  state.instance = null;
+  state.initPromise = null;
+}
+
+function displayDatabasePath(file) {
+  const normalized = String(file ?? "").replaceAll("/", "\\");
+  const marker = "\\.swayrouter\\";
+  const markerIndex = normalized.toLowerCase().lastIndexOf(marker);
+  if (markerIndex >= 0) return normalized.slice(markerIndex + 1);
+  return normalized.split("\\").at(-1) || "data.sqlite";
+}
+
+async function tryBunSqlite() {
+
+  if (!process.versions.bun) return null;
+  try {
+    const { createBunSqliteAdapter } = await import("./adapters/bunSqliteAdapter.js");
+    return await createBunSqliteAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] bun:sqlite unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function tryBetterSqlite() {
+
+  if (process.versions.bun) return null;
+  try {
+    const { createBetterSqliteAdapter } = await import("./adapters/betterSqliteAdapter.js");
+    return createBetterSqliteAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] better-sqlite3 unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function tryNodeSqlite() {
+
+  if (process.versions.bun) return null;
+  const [maj, min] = process.versions.node.split(".").map(Number);
+  if (maj < 22 || (maj === 22 && min < 5)) return null;
+  try {
+    const { createNodeSqliteAdapter } = await import("./adapters/nodeSqliteAdapter.js");
+    return await createNodeSqliteAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] node:sqlite unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function trySqlJs() {
+  try {
+    const { createSqlJsAdapter } = await import("./adapters/sqljsAdapter.js");
+    return await createSqlJsAdapter(DATA_FILE);
+  } catch (e) {
+    console.warn(`[DB] sql.js unavailable: ${e.message}`);
+    return null;
+  }
+}
+
+async function initAdapter() {
+  ensureDirs();
+
+  let adapter = await tryBunSqlite();
+  if (!adapter) adapter = await tryBetterSqlite();
+  if (!adapter) adapter = await tryNodeSqlite();
+  if (!adapter) adapter = await trySqlJs();
+  if (!adapter) throw new Error("[DB] No SQLite driver available (bun/better/node/sql.js all failed)");
+
+  if (!state.logged) {
+    console.log(`[DB] Driver: ${adapter.driver} | file: ${displayDatabasePath(DATA_FILE)}`);
+    state.logged = true;
+  }
+
+  const { runMigrationOnce } = await import("./migrate.js");
+  await runMigrationOnce(adapter);
+  return adapter;
+}
+
+export async function getAdapter() {
+  if (state.instance) return state.instance;
+  if (!state.initPromise) state.initPromise = initAdapter().then(rememberAdapter);
+  return state.initPromise;
+}
+
+export async function closeAdapter() {
+  const adapter = state.instance || await state.initPromise?.catch(() => null);
+  if (!adapter) return;
+  try {
+    adapter.close?.();
+  } finally {
+    resetAdapterState();
+  }
+}
+
+export function getAdapterSync() {
+  if (!state.instance) throw new Error("[DB] adapter not initialized — await getAdapter() first");
+  return state.instance;
+}

package/src/lib/db/helpers/jsonCol.js

@@ -0,0 +1,18 @@
+function isMissing(value) {
+  return value === null || value === undefined;
+}
+
+export function parseJson(value, fallback = null) {
+  if (isMissing(value)) return fallback;
+  if (typeof value !== "string") return value;
+
+  try {
+    return JSON.parse(value);
+  } catch {
+    return fallback;
+  }
+}
+
+export function stringifyJson(value) {
+  return JSON.stringify(isMissing(value) ? null : value);
+}

package/src/lib/db/helpers/kvStore.js

@@ -0,0 +1,48 @@
+import { getAdapter } from "../driver.js";
+import { parseJson, stringifyJson } from "./jsonCol.js";
+
+const UPSERT_SQL = `INSERT INTO kv(scope, key, value)
+  VALUES(?, ?, ?)
+  ON CONFLICT(scope, key) DO UPDATE SET value = excluded.value`;
+
+function saveValue(db, scope, key, value) {
+  db.run(UPSERT_SQL, [scope, key, stringifyJson(value)]);
+}
+
+export function makeKv(scope) {
+  const read = async () => getAdapter();
+
+  return {
+    async get(key, fallback = null) {
+      const db = await read();
+      const row = db.get(`SELECT value FROM kv WHERE scope = ? AND key = ?`, [scope, key]);
+      return row ? parseJson(row.value, fallback) : fallback;
+    },
+    async getAll() {
+      const db = await read();
+      const rows = db.all(`SELECT key, value FROM kv WHERE scope = ?`, [scope]);
+      const out = {};
+      for (const r of rows) out[r.key] = parseJson(r.value);
+      return out;
+    },
+    async set(key, value) {
+      saveValue(await read(), scope, key, value);
+    },
+    async setMany(obj) {
+      const db = await read();
+      db.transaction(() => {
+        for (const [k, v] of Object.entries(obj)) {
+          saveValue(db, scope, k, v);
+        }
+      });
+    },
+    async remove(key) {
+      const db = await read();
+      db.run(`DELETE FROM kv WHERE scope = ? AND key = ?`, [scope, key]);
+    },
+    async clear() {
+      const db = await read();
+      db.run(`DELETE FROM kv WHERE scope = ?`, [scope]);
+    },
+  };
+}

package/src/lib/db/helpers/metaStore.js

@@ -0,0 +1,32 @@
+import { getAdapter } from "../driver.js";
+
+const META_READ = `SELECT value FROM _meta WHERE key = ?`;
+const META_WRITE = `INSERT INTO _meta(key, value) VALUES(?, ?)
+  ON CONFLICT(key) DO UPDATE SET value = excluded.value`;
+
+function readMeta(adapter, key, fallback) {
+  const row = adapter.get(META_READ, [key]);
+  return row ? row.value : fallback;
+}
+
+function writeMeta(adapter, key, value) {
+  adapter.run(META_WRITE, [key, String(value)]);
+}
+
+export async function getMeta(key, fallback = null) {
+  const db = await getAdapter();
+  return readMeta(db, key, fallback);
+}
+
+export async function setMeta(key, value) {
+  const db = await getAdapter();
+  writeMeta(db, key, value);
+}
+
+export function getMetaSync(adapter, key, fallback = null) {
+  return readMeta(adapter, key, fallback);
+}
+
+export function setMetaSync(adapter, key, value) {
+  writeMeta(adapter, key, value);
+}