squish-memory 1.2.0 → 1.2.1

package/dist/db/adapter.js

@@ -1,175 +0,0 @@
-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');
-    // 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);
-    // Enable foreign keys
-    sqlite.exec('PRAGMA foreign_keys = ON');
-    await ensureSqliteSchema(sqlite);
-    logger.info('SQLite initialized with bun:sqlite');
-    return drizzle(sqlite, { schema: schemaModule });
-}
-export async function createDb() {
-    if (config.isTeamMode) {
-        return createPostgresDb();
-    }
-    else {
-        return createSqliteDb();
-    }
-}
-async function createPostgresDb() {
-    const { Pool } = await import('pg');
-    const { drizzle } = await import('drizzle-orm/node-postgres');
-    const schemaModule = await import('./drizzle/schema.js');
-    const pool = new Pool({
-        connectionString: process.env.DATABASE_URL,
-        max: 20,
-    });
-    await ensurePostgresSchema(pool);
-    return drizzle(pool, { schema: schemaModule });
-}
-async function createSqliteDb() {
-    const dbPath = `${getDataDir()}/squish.db`;
-    const errors = [];
-    if (isBunRuntime()) {
-        try {
-            return await createBunSqliteDb(dbPath);
-        }
-        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),
-                });
-            }
-        }
-    }
-    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 sqlite = new Database(dbPath);
-    // Enable foreign keys
-    sqlite.pragma('foreign_keys = ON');
-    await ensureSqliteSchema(sqlite);
-    logger.info('SQLite initialized with better-sqlite3');
-    return drizzle(sqlite, { schema: schemaModule });
-}
-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 wasmPath = resolveSqlJsWasmPath();
-    const SQL = await initSqlJs.default({
-        locateFile: (file) => (file.endsWith('.wasm') ? wasmPath : file),
-    });
-    let data;
-    if (fs.existsSync(dbPath)) {
-        data = fs.readFileSync(dbPath);
-    }
-    const sqlite = new SQL.Database(data);
-    sqlite.exec('PRAGMA foreign_keys = ON');
-    await ensureSqliteSchema(sqlite);
-    persistSqlJsDatabase(sqlite, dbPath);
-    const originalExec = sqlite.exec.bind(sqlite);
-    sqlite.exec = (...args) => {
-        const [query] = args;
-        const result = originalExec(...args);
-        if (typeof query === 'string' && shouldPersistSql(query)) {
-            persistSqlJsDatabase(sqlite, dbPath);
-        }
-        return result;
-    };
-    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);
-            }
-            return result;
-        };
-    }
-    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 });
-}
-export default createDb;
-//# sourceMappingURL=adapter.js.map

package/dist/db/bootstrap.d.ts

@@ -1,11 +0,0 @@
-import type { Database } from 'better-sqlite3';
-import type { Pool } from 'pg';
-/**
- * Ensure the data directory exists (.squish folder in project root)
- */
-export declare function ensureDataDirectory(): Promise<void>;
-export declare function ensureSqliteSchema(sqlite: Database): Promise<void>;
-export declare function getSchemaVersion(sqlite: Database): Promise<string | null>;
-export declare function runMigrationsForVersion(sqlite: Database, targetVersion: string): Promise<void>;
-export declare function ensurePostgresSchema(pool: Pool): Promise<void>;
-//# sourceMappingURL=bootstrap.d.ts.map