sqlew 3.2.5 → 3.6.0

package/dist/database.js

@@ -1,163 +1,67 @@
 /**
  * Database connection and initialization module
- * Handles SQLite database setup with configurable path
+ * Handles database setup with Knex.js and DatabaseAdapter pattern
  */
-import Database from 'better-sqlite3';
-import { mkdirSync, existsSync } from 'fs';
-import { dirname, resolve, isAbsolute } from 'path';
-import { initializeSchema, isSchemaInitialized, verifySchemaIntegrity } from './schema.js';
-import { DEFAULT_DB_PATH, DB_BUSY_TIMEOUT } from './constants.js';
-import { performAutoCleanup } from './utils/cleanup.js';
-import { runAllMigrations, needsAnyMigrations } from './migrations/index.js';
-let dbInstance = null;
+import knexConfig from './knexfile.js';
+import { createDatabaseAdapter } from './adapters/index.js';
+// Global adapter instance
+let adapterInstance = null;
 /**
- * Initialize database connection
- * Creates database file and folder if they don't exist
- * Initializes schema on first run
- *
- * @param dbPath - Optional database path (defaults to .sqlew/sqlew.db)
- * @returns SQLite database instance
+ * Initialize database with adapter pattern
  */
-export function initializeDatabase(dbPath) {
-    // If already initialized, return existing instance
-    if (dbInstance) {
-        return dbInstance;
-    }
-    try {
-        // Use provided path or default
-        const finalPath = dbPath || DEFAULT_DB_PATH;
-        // Convert to absolute path if relative
-        const absolutePath = isAbsolute(finalPath)
-            ? finalPath
-            : resolve(process.cwd(), finalPath);
-        // Create directory if it doesn't exist
-        const dbDir = dirname(absolutePath);
-        if (!existsSync(dbDir)) {
-            mkdirSync(dbDir, { recursive: true });
-            console.log(`✓ Created database directory: ${dbDir}`);
-        }
-        // Open database connection
-        const db = new Database(absolutePath, {
-            verbose: process.env.DEBUG_SQL ? console.log : undefined,
-        });
-        // Configure database
-        db.pragma('journal_mode = WAL'); // Write-Ahead Logging for better concurrency
-        db.pragma('foreign_keys = ON'); // Enforce foreign key constraints
-        db.pragma('synchronous = NORMAL'); // Balance between safety and performance
-        db.pragma(`busy_timeout = ${DB_BUSY_TIMEOUT}`); // Set busy timeout
-        console.log(`✓ Connected to database: ${absolutePath}`);
-        // Check if database has existing schema
-        const schemaExists = isSchemaInitialized(db);
-        if (schemaExists) {
-            // Run all pending migrations using orchestrator
-            // This handles upgrades from any version (v1.0.0, v1.1.x, v2.0.0, v2.1.x) to latest
-            if (needsAnyMigrations(db)) {
-                const migrationResults = runAllMigrations(db);
-                // Check if any migration failed
-                const failed = migrationResults.find(r => !r.success);
-                if (failed) {
-                    console.error('\n❌ ERROR: Migration failed!');
-                    console.error(failed.message);
-                    db.close();
-                    process.exit(1);
-                }
-                // After table prefix migration, run schema initialization to create views/triggers
-                // (tables already exist, CREATE TABLE IF NOT EXISTS will skip them)
-                const hadPrefixMigration = migrationResults.some(r => r.message.toLowerCase().includes('table prefix') ||
-                    r.message.toLowerCase().includes('prefix'));
-                if (hadPrefixMigration) {
-                    console.log('\n→ Creating views and triggers for new schema...');
-                    initializeSchema(db);
-                }
-            }
-            // Validate existing schema integrity (after migrations)
-            console.log('→ Validating existing database schema...');
-            const validation = verifySchemaIntegrity(db);
-            if (!validation.valid) {
-                // Schema is invalid - display error and exit
-                console.error('\n❌ ERROR: Database schema validation failed!');
-                console.error('\nThe existing database file has an incompatible schema.');
-                console.error(`Database location: ${absolutePath}`);
-                if (validation.missing.length > 0) {
-                    console.error('\n📋 Missing components:');
-                    validation.missing.forEach(item => console.error(`  - ${item}`));
-                }
-                if (validation.errors.length > 0) {
-                    console.error('\n⚠️  Validation errors:');
-                    validation.errors.forEach(error => console.error(`  - ${error}`));
-                }
-                console.error('\n💡 Possible solutions:');
-                console.error('  1. Backup and delete the existing database file to start fresh');
-                console.error('  2. Use a different database path with --db-path option');
-                console.error('  3. Restore from a backup if available\n');
-                // Close database and exit
-                db.close();
-                process.exit(1);
-            }
-            console.log('✓ Database schema validation passed');
-        }
-        else {
-            // Initialize new schema
-            console.log('→ Initializing database schema...');
-            initializeSchema(db);
-        }
-        // Store instance
-        dbInstance = db;
-        // Perform initial cleanup
-        try {
-            const cleanupResult = performAutoCleanup(db);
-            if (cleanupResult.messagesDeleted > 0 || cleanupResult.fileChangesDeleted > 0) {
-                console.log(`✓ Cleanup: ${cleanupResult.messagesDeleted} messages, ${cleanupResult.fileChangesDeleted} file changes deleted`);
-            }
-        }
-        catch (error) {
-            console.warn('⚠️  Initial cleanup failed:', error instanceof Error ? error.message : String(error));
-        }
-        return db;
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        throw new Error(`Failed to initialize database: ${message}`);
+export async function initializeDatabase(config) {
+    if (adapterInstance) {
+        return adapterInstance;
     }
+    const dbType = config?.databaseType || 'sqlite';
+    const adapter = createDatabaseAdapter(dbType);
+    // Determine if running from compiled code (dist/) or source (src/)
+    const isCompiledCode = import.meta.url.includes('/dist/');
+    const environment = isCompiledCode ? 'production' : 'development';
+    // Use config from knexfile or provided config
+    const baseConfig = knexConfig[environment] || knexConfig.development;
+    const knexConnConfig = config?.connection
+        ? { ...baseConfig, connection: config.connection }
+        : baseConfig;
+    await adapter.connect(knexConnConfig);
+    // Run migrations if needed
+    const knex = adapter.getKnex();
+    await knex.migrate.latest();
+    console.log(`✓ Database initialized with Knex adapter (${environment})`);
+    adapterInstance = adapter;
+    return adapter;
 }
 /**
- * Close database connection
+ * Get current database adapter
  */
-export function closeDatabase() {
-    if (dbInstance) {
-        dbInstance.close();
-        dbInstance = null;
-        console.log('✓ Database connection closed');
+export function getAdapter() {
+    if (!adapterInstance) {
+        throw new Error('Database not initialized. Call initializeDatabase() first.');
     }
+    return adapterInstance;
 }
 /**
- * Get current database instance
- * Throws error if not initialized
- *
- * @returns Current database instance
+ * Close database connection
  */
-export function getDatabase() {
-    if (!dbInstance) {
-        throw new Error('Database not initialized. Call initializeDatabase() first.');
+export async function closeDatabase() {
+    if (adapterInstance) {
+        await adapterInstance.disconnect();
+        adapterInstance = null;
+        console.log('✓ Database connection closed');
     }
-    return dbInstance;
 }
 // ============================================================================
-// Helper Functions for Master Table Management
+// Helper Functions for Master Table Management (Async)
 // ============================================================================
 /**
  * Get or create agent by name
- * Uses INSERT OR IGNORE for idempotent operation
- *
- * @param db - Database instance
- * @param name - Agent name
- * @returns Agent ID
  */
-export function getOrCreateAgent(db, name) {
-    // Try to insert
-    db.prepare('INSERT OR IGNORE INTO m_agents (name) VALUES (?)').run(name);
+export async function getOrCreateAgent(adapter, name, trx) {
+    const knex = trx || adapter.getKnex();
+    // Try to insert (will be ignored if exists)
+    await knex('m_agents').insert({ name }).onConflict('name').ignore();
     // Get the ID
-    const result = db.prepare('SELECT id FROM m_agents WHERE name = ?').get(name);
+    const result = await knex('m_agents').where({ name }).first('id');
     if (!result) {
         throw new Error(`Failed to get or create agent: ${name}`);
     }
@@ -165,14 +69,11 @@ export function getOrCreateAgent(db, name) {
 }
 /**
  * Get or create context key by name
- *
- * @param db - Database instance
- * @param key - Context key name
- * @returns Context key ID
  */
-export function getOrCreateContextKey(db, key) {
-    db.prepare('INSERT OR IGNORE INTO m_context_keys (key) VALUES (?)').run(key);
-    const result = db.prepare('SELECT id FROM m_context_keys WHERE key = ?').get(key);
+export async function getOrCreateContextKey(adapter, key, trx) {
+    const knex = trx || adapter.getKnex();
+    await knex('m_context_keys').insert({ key }).onConflict('key').ignore();
+    const result = await knex('m_context_keys').where({ key }).first('id');
     if (!result) {
         throw new Error(`Failed to get or create context key: ${key}`);
     }
@@ -180,14 +81,11 @@ export function getOrCreateContextKey(db, key) {
 }
 /**
  * Get or create file by path
- *
- * @param db - Database instance
- * @param path - File path
- * @returns File ID
  */
-export function getOrCreateFile(db, path) {
-    db.prepare('INSERT OR IGNORE INTO m_files (path) VALUES (?)').run(path);
-    const result = db.prepare('SELECT id FROM m_files WHERE path = ?').get(path);
+export async function getOrCreateFile(adapter, path, trx) {
+    const knex = trx || adapter.getKnex();
+    await knex('m_files').insert({ path }).onConflict('path').ignore();
+    const result = await knex('m_files').where({ path }).first('id');
     if (!result) {
         throw new Error(`Failed to get or create file: ${path}`);
     }
@@ -195,14 +93,11 @@ export function getOrCreateFile(db, path) {
 }
 /**
  * Get or create tag by name
- *
- * @param db - Database instance
- * @param name - Tag name
- * @returns Tag ID
  */
-export function getOrCreateTag(db, name) {
-    db.prepare('INSERT OR IGNORE INTO m_tags (name) VALUES (?)').run(name);
-    const result = db.prepare('SELECT id FROM m_tags WHERE name = ?').get(name);
+export async function getOrCreateTag(adapter, name, trx) {
+    const knex = trx || adapter.getKnex();
+    await knex('m_tags').insert({ name }).onConflict('name').ignore();
+    const result = await knex('m_tags').where({ name }).first('id');
     if (!result) {
         throw new Error(`Failed to get or create tag: ${name}`);
     }
@@ -210,14 +105,11 @@ export function getOrCreateTag(db, name) {
 }
 /**
  * Get or create scope by name
- *
- * @param db - Database instance
- * @param name - Scope name
- * @returns Scope ID
  */
-export function getOrCreateScope(db, name) {
-    db.prepare('INSERT OR IGNORE INTO m_scopes (name) VALUES (?)').run(name);
-    const result = db.prepare('SELECT id FROM m_scopes WHERE name = ?').get(name);
+export async function getOrCreateScope(adapter, name, trx) {
+    const knex = trx || adapter.getKnex();
+    await knex('m_scopes').insert({ name }).onConflict('name').ignore();
+    const result = await knex('m_scopes').where({ name }).first('id');
     if (!result) {
         throw new Error(`Failed to get or create scope: ${name}`);
     }
@@ -225,17 +117,11 @@ export function getOrCreateScope(db, name) {
 }
 /**
  * Get or create category ID
- * Uses INSERT to create if doesn't exist
- *
- * @param db - Database instance
- * @param category - Category name
- * @returns Category ID
  */
-export function getOrCreateCategoryId(db, category) {
-    // Use INSERT OR IGNORE for idempotent operation
-    db.prepare('INSERT OR IGNORE INTO m_constraint_categories (name) VALUES (?)').run(category);
-    // Get the ID
-    const result = db.prepare('SELECT id FROM m_constraint_categories WHERE name = ?').get(category);
+export async function getOrCreateCategoryId(adapter, category, trx) {
+    const knex = trx || adapter.getKnex();
+    await knex('m_constraint_categories').insert({ name: category }).onConflict('name').ignore();
+    const result = await knex('m_constraint_categories').where({ name: category }).first('id');
     if (!result) {
         throw new Error(`Failed to get or create category: ${category}`);
     }
@@ -243,77 +129,56 @@ export function getOrCreateCategoryId(db, category) {
 }
 /**
  * Get layer ID by name
- * Does not auto-create (layers are predefined)
- *
- * @param db - Database instance
- * @param name - Layer name
- * @returns Layer ID or null if not found
  */
-export function getLayerId(db, name) {
-    const result = db.prepare('SELECT id FROM m_layers WHERE name = ?').get(name);
+export async function getLayerId(adapter, name, trx) {
+    const knex = trx || adapter.getKnex();
+    const result = await knex('m_layers').where({ name }).first('id');
     return result ? result.id : null;
 }
 /**
  * Get constraint category ID by name
- * Does not auto-create (categories are predefined)
- *
- * @param db - Database instance
- * @param name - Category name
- * @returns Category ID or null if not found
  */
-export function getCategoryId(db, name) {
-    const result = db.prepare('SELECT id FROM m_constraint_categories WHERE name = ?').get(name);
+export async function getCategoryId(adapter, name, trx) {
+    const knex = trx || adapter.getKnex();
+    const result = await knex('m_constraint_categories').where({ name }).first('id');
     return result ? result.id : null;
 }
 // ============================================================================
-// Configuration Management
+// Configuration Management (Async)
 // ============================================================================
 /**
  * Get configuration value from m_config table
- *
- * @param db - Database instance
- * @param key - Config key
- * @returns Config value as string or null if not found
  */
-export function getConfigValue(db, key) {
-    const result = db.prepare('SELECT value FROM m_config WHERE key = ?').get(key);
+export async function getConfigValue(adapter, key) {
+    const knex = adapter.getKnex();
+    const result = await knex('m_config').where({ key }).first('value');
     return result ? result.value : null;
 }
 /**
  * Set configuration value in m_config table
- *
- * @param db - Database instance
- * @param key - Config key
- * @param value - Config value (will be converted to string)
  */
-export function setConfigValue(db, key, value) {
+export async function setConfigValue(adapter, key, value) {
+    const knex = adapter.getKnex();
     const stringValue = String(value);
-    db.prepare('INSERT OR REPLACE INTO m_config (key, value) VALUES (?, ?)').run(key, stringValue);
+    await knex('m_config')
+        .insert({ key, value: stringValue })
+        .onConflict('key')
+        .merge({ value: stringValue });
 }
 /**
  * Get configuration value as boolean
- *
- * @param db - Database instance
- * @param key - Config key
- * @param defaultValue - Default value if key not found
- * @returns Boolean value
  */
-export function getConfigBool(db, key, defaultValue = false) {
-    const value = getConfigValue(db, key);
+export async function getConfigBool(adapter, key, defaultValue = false) {
+    const value = await getConfigValue(adapter, key);
     if (value === null)
         return defaultValue;
     return value === '1' || value.toLowerCase() === 'true';
 }
 /**
  * Get configuration value as integer
- *
- * @param db - Database instance
- * @param key - Config key
- * @param defaultValue - Default value if key not found
- * @returns Integer value
  */
-export function getConfigInt(db, key, defaultValue = 0) {
-    const value = getConfigValue(db, key);
+export async function getConfigInt(adapter, key, defaultValue = 0) {
+    const value = await getConfigValue(adapter, key);
     if (value === null)
         return defaultValue;
     const parsed = parseInt(value, 10);
@@ -321,12 +186,10 @@ export function getConfigInt(db, key, defaultValue = 0) {
 }
 /**
  * Get all configuration as an object
- *
- * @param db - Database instance
- * @returns Object with all m_config key-value pairs
  */
-export function getAllConfig(db) {
-    const rows = db.prepare('SELECT key, value FROM m_config').all();
+export async function getAllConfig(adapter) {
+    const knex = adapter.getKnex();
+    const rows = await knex('m_config').select('key', 'value');
     const config = {};
     for (const row of rows) {
         config[row.key] = row.value;
@@ -334,35 +197,10 @@ export function getAllConfig(db) {
     return config;
 }
 // ============================================================================
-// Transaction Helpers
-// ============================================================================
-/**
- * Execute a function within a transaction
- * Automatically handles commit/rollback
- *
- * @param db - Database instance
- * @param fn - Function to execute in transaction
- * @returns Result from function
- */
-export function transaction(db, fn) {
-    db.exec('BEGIN TRANSACTION');
-    try {
-        const result = fn();
-        db.exec('COMMIT');
-        return result;
-    }
-    catch (error) {
-        db.exec('ROLLBACK');
-        throw error;
-    }
-}
-// ============================================================================
-// Decision Context Management (v3.2.2)
+// Decision Context Management (Async - v3.2.2)
 // ============================================================================
 /**
  * Validate JSON structure for alternatives array
- * @param alternatives - JSON string or null
- * @throws Error if JSON is invalid or not an array
  */
 function validateAlternativesJson(alternatives) {
     if (alternatives === null || alternatives === undefined)
@@ -382,8 +220,6 @@ function validateAlternativesJson(alternatives) {
 }
 /**
  * Validate JSON structure for tradeoffs object
- * @param tradeoffs - JSON string or null
- * @throws Error if JSON is invalid or doesn't have pros/cons structure
  */
 function validateTradeoffsJson(tradeoffs) {
     if (tradeoffs === null || tradeoffs === undefined)
@@ -393,7 +229,6 @@ function validateTradeoffsJson(tradeoffs) {
         if (typeof parsed !== 'object' || parsed === null) {
             throw new Error('tradeoffs must be a JSON object');
         }
-        // Optional: Check for pros/cons keys if provided
         if (parsed.pros !== undefined && !Array.isArray(parsed.pros)) {
             throw new Error('tradeoffs.pros must be an array');
         }
@@ -410,85 +245,54 @@ function validateTradeoffsJson(tradeoffs) {
 }
 /**
  * Add decision context to a decision
- *
- * @param db - Database instance
- * @param decisionKey - Decision key to attach context to
- * @param rationale - Rationale for the decision (required)
- * @param alternatives - JSON array of alternatives considered (optional)
- * @param tradeoffs - JSON object with pros/cons (optional)
- * @param decidedBy - Agent name who decided (optional)
- * @param relatedTaskId - Related task ID (optional)
- * @param relatedConstraintId - Related constraint ID (optional)
- * @returns Context ID
  */
-export function addDecisionContext(db, decisionKey, rationale, alternatives = null, tradeoffs = null, decidedBy = null, relatedTaskId = null, relatedConstraintId = null) {
+export async function addDecisionContext(adapter, decisionKey, rationale, alternatives = null, tradeoffs = null, decidedBy = null, relatedTaskId = null, relatedConstraintId = null) {
     // Validate JSON inputs
     validateAlternativesJson(alternatives);
     validateTradeoffsJson(tradeoffs);
+    const knex = adapter.getKnex();
     // Get decision key ID
-    const keyId = getOrCreateContextKey(db, decisionKey);
+    const keyId = await getOrCreateContextKey(adapter, decisionKey);
     // Get agent ID if provided
     let agentId = null;
     if (decidedBy) {
-        agentId = getOrCreateAgent(db, decidedBy);
+        agentId = await getOrCreateAgent(adapter, decidedBy);
     }
     // Insert context
-    const result = db.prepare(`
-    INSERT INTO t_decision_context (
-      decision_key_id,
-      rationale,
-      alternatives_considered,
-      tradeoffs,
-      decided_by_agent_id,
-      related_task_id,
-      related_constraint_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?)
-  `).run(keyId, rationale, alternatives, tradeoffs, agentId, relatedTaskId, relatedConstraintId);
-    return result.lastInsertRowid;
+    const [id] = await knex('t_decision_context').insert({
+        decision_key_id: keyId,
+        rationale,
+        alternatives_considered: alternatives,
+        tradeoffs,
+        decided_by_agent_id: agentId,
+        related_task_id: relatedTaskId,
+        related_constraint_id: relatedConstraintId,
+        decision_date: Math.floor(Date.now() / 1000),
+    });
+    return id;
 }
 /**
  * Get decision with context
- *
- * @param db - Database instance
- * @param decisionKey - Decision key
- * @returns Decision with context or null if not found
  */
-export function getDecisionWithContext(db, decisionKey) {
+export async function getDecisionWithContext(adapter, decisionKey) {
+    const knex = adapter.getKnex();
     // First get the decision
-    const decision = db.prepare(`
-    SELECT
-      k.key,
-      d.value,
-      d.version,
-      CASE d.status WHEN 1 THEN 'active' WHEN 2 THEN 'deprecated' ELSE 'draft' END as status,
-      l.name as layer,
-      a.name as decided_by,
-      datetime(d.ts, 'unixepoch') as updated
-    FROM t_decisions d
-    JOIN m_context_keys k ON d.key_id = k.id
-    LEFT JOIN m_layers l ON d.layer_id = l.id
-    LEFT JOIN m_agents a ON d.agent_id = a.id
-    WHERE k.key = ?
-  `).get(decisionKey);
+    const decision = await knex('t_decisions as d')
+        .join('m_context_keys as k', 'd.key_id', 'k.id')
+        .leftJoin('m_layers as l', 'd.layer_id', 'l.id')
+        .leftJoin('m_agents as a', 'd.agent_id', 'a.id')
+        .where('k.key', decisionKey)
+        .select('k.key', 'd.value', 'd.version', knex.raw(`CASE d.status WHEN 1 THEN 'active' WHEN 2 THEN 'deprecated' ELSE 'draft' END as status`), 'l.name as layer', 'a.name as decided_by', knex.raw(`datetime(d.ts, 'unixepoch') as updated`))
+        .first();
     if (!decision)
         return null;
     // Get all contexts for this decision
-    const contexts = db.prepare(`
-    SELECT
-      dc.id,
-      dc.rationale,
-      dc.alternatives_considered,
-      dc.tradeoffs,
-      a.name as decided_by,
-      datetime(dc.decision_date, 'unixepoch') as decision_date,
-      dc.related_task_id,
-      dc.related_constraint_id
-    FROM t_decision_context dc
-    JOIN m_context_keys k ON dc.decision_key_id = k.id
-    LEFT JOIN m_agents a ON dc.decided_by_agent_id = a.id
-    WHERE k.key = ?
-    ORDER BY dc.decision_date DESC
-  `).all(decisionKey);
+    const contexts = await knex('t_decision_context as dc')
+        .join('m_context_keys as k', 'dc.decision_key_id', 'k.id')
+        .leftJoin('m_agents as a', 'dc.decided_by_agent_id', 'a.id')
+        .where('k.key', decisionKey)
+        .select('dc.id', 'dc.rationale', 'dc.alternatives_considered', 'dc.tradeoffs', 'a.name as decided_by', knex.raw(`datetime(dc.decision_date, 'unixepoch') as decision_date`), 'dc.related_task_id', 'dc.related_constraint_id')
+        .orderBy('dc.decision_date', 'desc');
     return {
         ...decision,
         context: contexts,
@@ -496,54 +300,46 @@ export function getDecisionWithContext(db, decisionKey) {
 }
 /**
  * List decision contexts with optional filters
- *
- * @param db - Database instance
- * @param filters - Optional filters
- * @returns Array of decision contexts
  */
-export function listDecisionContexts(db, filters) {
-    let query = `
-    SELECT
-      dc.id,
-      k.key as decision_key,
-      dc.rationale,
-      dc.alternatives_considered,
-      dc.tradeoffs,
-      a.name as decided_by,
-      datetime(dc.decision_date, 'unixepoch') as decision_date,
-      dc.related_task_id,
-      dc.related_constraint_id
-    FROM t_decision_context dc
-    JOIN m_context_keys k ON dc.decision_key_id = k.id
-    LEFT JOIN m_agents a ON dc.decided_by_agent_id = a.id
-    WHERE 1=1
-  `;
-    const params = [];
+export async function listDecisionContexts(adapter, filters) {
+    const knex = adapter.getKnex();
+    let query = knex('t_decision_context as dc')
+        .join('m_context_keys as k', 'dc.decision_key_id', 'k.id')
+        .leftJoin('m_agents as a', 'dc.decided_by_agent_id', 'a.id')
+        .select('dc.id', 'k.key as decision_key', 'dc.rationale', 'dc.alternatives_considered', 'dc.tradeoffs', 'a.name as decided_by', knex.raw(`datetime(dc.decision_date, 'unixepoch') as decision_date`), 'dc.related_task_id', 'dc.related_constraint_id');
     if (filters?.decisionKey) {
-        query += ' AND k.key = ?';
-        params.push(filters.decisionKey);
+        query = query.where('k.key', filters.decisionKey);
     }
     if (filters?.relatedTaskId !== undefined) {
-        query += ' AND dc.related_task_id = ?';
-        params.push(filters.relatedTaskId);
+        query = query.where('dc.related_task_id', filters.relatedTaskId);
     }
     if (filters?.relatedConstraintId !== undefined) {
-        query += ' AND dc.related_constraint_id = ?';
-        params.push(filters.relatedConstraintId);
+        query = query.where('dc.related_constraint_id', filters.relatedConstraintId);
     }
     if (filters?.decidedBy) {
-        query += ' AND a.name = ?';
-        params.push(filters.decidedBy);
+        query = query.where('a.name', filters.decidedBy);
     }
-    query += ' ORDER BY dc.decision_date DESC';
+    query = query.orderBy('dc.decision_date', 'desc');
     if (filters?.limit) {
-        query += ' LIMIT ?';
-        params.push(filters.limit);
+        query = query.limit(filters.limit);
     }
     if (filters?.offset) {
-        query += ' OFFSET ?';
-        params.push(filters.offset);
+        query = query.offset(filters.offset);
     }
-    return db.prepare(query).all(...params);
+    return await query;
+}
+/**
+ * Backwards compatibility alias for getAdapter
+ */
+export function getDatabase() {
+    return getAdapter();
+}
+/**
+ * Execute a function within a database transaction
+ */
+export async function transaction(callback) {
+    const adapter = getAdapter();
+    const knex = adapter.getKnex();
+    return await knex.transaction(callback);
 }
 //# sourceMappingURL=database.js.map