squish-memory 1.0.2 → 1.1.5

package/dist/db/adapter.js

@@ -1,10 +1,54 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
 import { config, getDataDir } from '../config.js';
 import { ensurePostgresSchema, ensureSqliteSchema } from './bootstrap.js';
 import { logger } from '../core/logger.js';
+const SQL_JS_WASM_RELATIVE_PATH = '../vendor/sql.js/sql-wasm.wasm';
+function isBunRuntime() {
+    return typeof globalThis.Bun !== 'undefined';
+}
+function formatInitializationError(label, error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return `${label}: ${message}`;
+}
+function shouldPersistSql(query) {
+    return /^\s*(insert|update|delete|create|alter|drop|replace|pragma|begin|commit|rollback|vacuum|reindex)\b/i.test(query);
+}
+function persistSqlJsDatabase(sqlite, dbPath) {
+    fs.mkdirSync(path.dirname(dbPath), { recursive: true });
+    fs.writeFileSync(dbPath, Buffer.from(sqlite.export()));
+}
+function resolveSqlJsWasmPath() {
+    const currentDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+        path.resolve(currentDir, SQL_JS_WASM_RELATIVE_PATH),
+        path.resolve(currentDir, '../../node_modules/sql.js/dist/sql-wasm.wasm'),
+        path.resolve(process.cwd(), 'node_modules/sql.js/dist/sql-wasm.wasm'),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate)) {
+            return candidate;
+        }
+    }
+    throw new Error(`sql.js wasm asset not found. Looked in: ${candidates.join(', ')}`);
+}
+function wrapSqlJsStatement(stmt, sqlite, dbPath, query) {
+    const persistAfterRun = shouldPersistSql(query);
+    if (persistAfterRun && typeof stmt.run === 'function') {
+        const originalRun = stmt.run.bind(stmt);
+        stmt.run = (...args) => {
+            const result = originalRun(...args);
+            persistSqlJsDatabase(sqlite, dbPath);
+            return result;
+        };
+    }
+    return stmt;
+}
 async function createBunSqliteDb(dbPath) {
     // @ts-ignore - bun:sqlite module not found in types but works at runtime
     const { drizzle } = await import('drizzle-orm/bun-sqlite');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    const schemaModule = await import('./drizzle/schema-sqlite.js');
     // Bun SQLite doesn't need file path for in-memory, but we'll use file path for persistence
     // @ts-ignore - bun:sqlite module not found in types but works at runtime
     const sqlite = new (await import('bun:sqlite')).default(dbPath);
@@ -25,7 +69,7 @@ export async function createDb() {
 async function createPostgresDb() {
     const { Pool } = await import('pg');
     const { drizzle } = await import('drizzle-orm/node-postgres');
-    const schemaModule = await import('../drizzle/schema.js');
+    const schemaModule = await import('./drizzle/schema.js');
     const pool = new Pool({
         connectionString: process.env.DATABASE_URL,
         max: 20,
@@ -35,49 +79,46 @@ async function createPostgresDb() {
 }
 async function createSqliteDb() {
     const dbPath = `${getDataDir()}/squish.db`;
-    // Try bun:sqlite first (Bun's built-in SQLite)
-    try {
-        return await createBunSqliteDb(dbPath);
-    }
-    catch (bunSqliteError) {
-        logger.warn('bun:sqlite failed, trying better-sqlite3', {
-            error: bunSqliteError.message
-        });
-        // Try better-sqlite3 second (best performance)
+    const errors = [];
+    if (isBunRuntime()) {
         try {
-            return await createBetterSqliteDb(dbPath);
+            return await createBunSqliteDb(dbPath);
         }
-        catch (betterSqliteError) {
-            logger.warn('better-sqlite3 failed, trying sql.js fallback', {
-                error: betterSqliteError.message
-            });
-            // Fallback to sql.js (pure JavaScript, no native module)
-            try {
-                return await createSqlJsDb(dbPath);
-            }
-            catch (sqlJsError) {
-                // All failed - this is critical, Squish cannot work without DB
-                logger.error('CRITICAL: SQLite database initialization failed', {
-                    bunSqliteError: bunSqliteError.message,
-                    betterSqliteError: betterSqliteError.message,
-                    sqlJsError: sqlJsError.message
+        catch (error) {
+            errors.push(formatInitializationError('bun:sqlite', error));
+            if (process.env.DEBUG === 'true') {
+                logger.warn('bun:sqlite failed, trying Node-compatible drivers', {
+                    error: error instanceof Error ? error.message : String(error),
                 });
-                throw new Error(`Squish requires SQLite to function. Database initialization failed.\n` +
-                    `Primary error (bun:sqlite): ${bunSqliteError.message}\n` +
-                    `Secondary error (better-sqlite3): ${betterSqliteError.message}\n` +
-                    `Fallback error (sql.js): ${sqlJsError.message}\n\n` +
-                    `Solutions:\n` +
-                    `1. Install build tools: npm install -g windows-build-tools (Windows)\n` +
-                    `2. Or use PostgreSQL instead by setting DATABASE_URL environment variable`);
             }
         }
     }
+    try {
+        return await createBetterSqliteDb(dbPath);
+    }
+    catch (error) {
+        errors.push(formatInitializationError('better-sqlite3', error));
+        if (process.env.DEBUG === 'true') {
+            logger.warn('better-sqlite3 failed, trying sql.js fallback', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+        }
+    }
+    try {
+        return await createSqlJsDb(dbPath);
+    }
+    catch (error) {
+        errors.push(formatInitializationError('sql.js', error));
+    }
+    logger.error('CRITICAL: SQLite database initialization failed', { errors });
+    throw new Error('Squish requires a working local SQLite driver. Initialization failed.\n' +
+        errors.map((entry, index) => `${index + 1}. ${entry}`).join('\n'));
 }
 async function createBetterSqliteDb(dbPath) {
     const DatabaseModule = await import('better-sqlite3');
     const Database = DatabaseModule.default;
     const { drizzle } = await import('drizzle-orm/better-sqlite3');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
+    const schemaModule = await import('./drizzle/schema-sqlite.js');
     const sqlite = new Database(dbPath);
     // Enable foreign keys
     sqlite.pragma('foreign_keys = ON');
@@ -89,73 +130,43 @@ async function createSqlJsDb(dbPath) {
     // @ts-ignore - sql.js has no types but works fine
     const initSqlJs = await import('sql.js');
     const { drizzle } = await import('drizzle-orm/sql-js');
-    const schemaModule = await import('../drizzle/schema-sqlite.js');
-    const fs = await import('fs');
-    const path = await import('path');
-    const SQL = await initSqlJs.default();
+    const schemaModule = await import('./drizzle/schema-sqlite.js');
+    const wasmPath = resolveSqlJsWasmPath();
+    const SQL = await initSqlJs.default({
+        locateFile: (file) => (file.endsWith('.wasm') ? wasmPath : file),
+    });
     let data;
-    // Try to load existing database
     if (fs.existsSync(dbPath)) {
         data = fs.readFileSync(dbPath);
     }
     const sqlite = new SQL.Database(data);
-    // Enable foreign keys
     sqlite.exec('PRAGMA foreign_keys = ON');
-    // Schema bootstrap
     await ensureSqliteSchema(sqlite);
-    // Persist database on changes (sql.js is in-memory by default)
+    persistSqlJsDatabase(sqlite, dbPath);
     const originalExec = sqlite.exec.bind(sqlite);
-    sqlite.exec = function (...args) {
+    sqlite.exec = (...args) => {
+        const [query] = args;
         const result = originalExec(...args);
-        // Save after each exec
-        const data = sqlite.export();
-        fs.writeFileSync(dbPath, Buffer.from(data));
+        if (typeof query === 'string' && shouldPersistSql(query)) {
+            persistSqlJsDatabase(sqlite, dbPath);
+        }
         return result;
     };
-    // Add prepare method for compatibility with drizzle-orm/sql-js
-    sqlite.prepare = (query) => {
-        const stmt = sqlite.prepare(query);
-        const preparedStatement = {};
-        preparedStatement.bind = (bindParams) => {
-            bindParams.forEach((param, index) => {
-                stmt.bind(param, index + 1);
-            });
-            return preparedStatement;
-        };
-        preparedStatement.step = () => {
-            return stmt.step();
-        };
-        preparedStatement.getAsObject = () => {
-            return stmt.getAsObject();
-        };
-        preparedStatement.free = () => {
-            stmt.free();
-        };
-        preparedStatement.run = () => {
-            const result = stmt.step() ? { changes: sqlite.changes() } : { changes: 0 };
-            stmt.reset();
-            return result;
-        };
-        preparedStatement.get = (bindParams = []) => {
-            if (bindParams.length > 0) {
-                preparedStatement.bind(bindParams);
+    if (typeof sqlite.run === 'function') {
+        const originalRun = sqlite.run.bind(sqlite);
+        sqlite.run = (...args) => {
+            const [query] = args;
+            const result = originalRun(...args);
+            if (typeof query === 'string' && shouldPersistSql(query)) {
+                persistSqlJsDatabase(sqlite, dbPath);
             }
-            const row = stmt.step() ? stmt.getAsObject() : undefined;
-            stmt.reset();
-            return row;
-        };
-        preparedStatement.all = (bindParams = []) => {
-            if (bindParams.length > 0) {
-                preparedStatement.bind(bindParams);
-            }
-            const rows = [];
-            while (stmt.step()) {
-                rows.push(stmt.getAsObject());
-            }
-            stmt.reset();
-            return rows;
+            return result;
         };
-        return preparedStatement;
+    }
+    const originalPrepare = sqlite.prepare.bind(sqlite);
+    sqlite.prepare = (query, ...args) => {
+        const stmt = originalPrepare(query, ...args);
+        return wrapSqlJsStatement(stmt, sqlite, dbPath, query);
     };
     logger.info('SQLite initialized with sql.js (pure JavaScript fallback)');
     return drizzle(sqlite, { schema: schemaModule });