fss-link 1.2.1 → 1.2.3

package/dist/src/config/database-utils.js

@@ -1,664 +0,0 @@
-/**
- * @license
- * Copyright 2025 Google LLC
- * SPDX-License-Identifier: Apache-2.0
- */
-import { DatabaseOperationQueue } from './database-queue.js';
-// Enable debug logging only when explicitly requested
-// - Tests (VITEST=true): All conditions false → DEBUG_DB = false (silent)
-// - Production default: All conditions false → DEBUG_DB = false (clean output)
-// - Production with --debug: FSS_DEBUG=true → DEBUG_DB = true (verbose)
-// - Development: NODE_ENV=development → DEBUG_DB = true (verbose)
-const DEBUG_DB = process.env['FSS_DEBUG'] === 'true' ||
-    process.env['NODE_ENV'] === 'development' ||
-    process.env['FSS_DB_DEBUG'] === 'true';
-/**
- * TEMPORARY DATABASE UTILITIES
- *
- * These wrapper functions provide immediate relief from manual memory management
- * while we transition to a proper ORM/repository pattern.
- *
- * @todo PHASE 2: Replace with Repository pattern (BaseRepository, ModelRepository, etc.)
- * @todo PHASE 3: Consider migrating to Drizzle ORM or similar for full type safety
- *
- * Current problems these wrappers solve:
- * - Manual .free() calls causing memory leaks
- * - Inconsistent error handling patterns
- * - No automatic cleanup on exceptions
- * - Raw SQL scattered throughout business logic
- */
-/**
- * Safe query execution with automatic statement cleanup.
- * Returns all matching rows as an array.
- *
- * @todo UPGRADE: Replace with repository.findMany() method
- *
- * @param db - SQLite database instance
- * @param sql - SQL query string
- * @param params - Query parameters (optional)
- * @returns Array of query results
- * @throws DatabaseError for SQL execution errors
- */
-export function safeQuery(db, sql, params = []) {
-    let stmt = null;
-    // 🔍 DETAILED OPERATION LOGGING
-    if (DEBUG_DB) {
-        if (DEBUG_DB)
-            console.log(`🔍 [DB-OP] QUERY START: ${sql.substring(0, 100)}${sql.length > 100 ? '...' : ''}`);
-        if (params && params.length > 0) {
-            if (DEBUG_DB)
-                console.log(`🔍 [DB-OP] QUERY PARAMS:`, params);
-        }
-    }
-    try {
-        // Validate database connection type before attempting prepare
-        if (!db || typeof db.prepare !== 'function') {
-            throw new DatabaseError(`Invalid database connection - missing prepare() method. Type: ${typeof db}`);
-        }
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] PREPARE: ${sql.substring(0, 80)}${sql.length > 80 ? '...' : ''}`);
-        stmt = db.prepare(sql);
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] PREPARE SUCCESS`);
-        if (params.length > 0) {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] BIND PARAMS:`, params);
-            stmt.bind(params);
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] BIND SUCCESS`);
-        }
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] EXECUTING QUERY...`);
-        const results = [];
-        let stepCount = 0;
-        while (stmt.step()) {
-            stepCount++;
-            results.push(stmt.getAsObject());
-            if (stepCount % 100 === 0) {
-                if (DEBUG_DB)
-                    console.log(`📋 [STMT] PROCESSED ${stepCount} rows...`);
-            }
-        }
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] QUERY COMPLETE: ${results.length} results, ${stepCount} steps`);
-        return results;
-    }
-    catch (error) {
-        console.error(`❌ [DB-OP] QUERY FAILED: ${sql}`);
-        console.error(`❌ [DB-OP] ERROR:`, error);
-        // 🎯 DETECT STATEMENT CLOSED ERRORS - Indicates database corruption
-        if (error instanceof Error && error.message.includes('Statement closed')) {
-            console.error(`🚨 [DB-OP] STATEMENT CLOSED ERROR DETECTED!`);
-            console.error(`🚨 [DB-OP] SQL: ${sql}`);
-            console.error(`🚨 [DB-OP] PARAMS:`, params);
-            console.error(`🚨 [DB-OP] STATEMENT STATE:`, stmt ? 'exists' : 'null');
-            throw new DatabaseError(`Database corruption detected (Statement closed): ${sql}`, error);
-        }
-        throw new DatabaseError(`Query failed: ${sql}`, error);
-    }
-    finally {
-        if (stmt) {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] FREEING STATEMENT...`);
-            try {
-                stmt.free();
-                if (DEBUG_DB)
-                    console.log(`📋 [STMT] STATEMENT FREED SUCCESSFULLY`);
-            }
-            catch (freeError) {
-                console.error(`❌ [STMT] FAILED TO FREE STATEMENT:`, freeError);
-            }
-        }
-        else {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] NO STATEMENT TO FREE`);
-        }
-    }
-}
-/**
- * Safe query execution returning first result or null.
- * Automatically handles statement cleanup.
- *
- * @todo UPGRADE: Replace with repository.findFirst() method
- *
- * @param db - SQLite database instance
- * @param sql - SQL query string
- * @param params - Query parameters (optional)
- * @returns First matching row or null
- * @throws DatabaseError for SQL execution errors
- */
-export function safeQueryFirst(db, sql, params = []) {
-    let stmt = null;
-    // 🔍 DETAILED OPERATION LOGGING
-    if (DEBUG_DB)
-        console.log(`🔍 [DB-OP] QUERY_FIRST START: ${sql.substring(0, 100)}${sql.length > 100 ? '...' : ''}`);
-    if (params && params.length > 0) {
-        if (DEBUG_DB)
-            console.log(`🔍 [DB-OP] QUERY_FIRST PARAMS:`, params);
-    }
-    try {
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] PREPARE FIRST: ${sql.substring(0, 80)}${sql.length > 80 ? '...' : ''}`);
-        stmt = db.prepare(sql);
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] PREPARE FIRST SUCCESS`);
-        if (params.length > 0) {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] BIND FIRST PARAMS:`, params);
-            stmt.bind(params);
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] BIND FIRST SUCCESS`);
-        }
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] EXECUTING FIRST QUERY...`);
-        const hasResult = stmt.step();
-        const result = hasResult ? stmt.getAsObject() : null;
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] QUERY_FIRST COMPLETE:`, hasResult ? 'Found result' : 'No result');
-        return result;
-    }
-    catch (error) {
-        console.error(`❌ [DB-OP] QUERY_FIRST FAILED: ${sql}`);
-        console.error(`❌ [DB-OP] ERROR:`, error);
-        // 🎯 DETECT STATEMENT CLOSED ERRORS
-        if (error instanceof Error && error.message.includes('Statement closed')) {
-            console.error(`🚨 [DB-OP] STATEMENT CLOSED ERROR IN QUERY_FIRST!`);
-            console.error(`🚨 [DB-OP] SQL: ${sql}`);
-            console.error(`🚨 [DB-OP] PARAMS:`, params);
-            throw new DatabaseError(`Database corruption detected (Statement closed): ${sql}`, error);
-        }
-        throw new DatabaseError(`Query failed: ${sql}`, error);
-    }
-    finally {
-        if (stmt) {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] FREEING FIRST STATEMENT...`);
-            try {
-                stmt.free();
-                if (DEBUG_DB)
-                    console.log(`📋 [STMT] FIRST STATEMENT FREED SUCCESSFULLY`);
-            }
-            catch (freeError) {
-                console.error(`❌ [STMT] FAILED TO FREE FIRST STATEMENT:`, freeError);
-            }
-        }
-        else {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] NO FIRST STATEMENT TO FREE`);
-        }
-    }
-}
-/**
- * Safe execution of INSERT/UPDATE/DELETE statements.
- * Automatically handles statement cleanup.
- *
- * @todo UPGRADE: Replace with repository.create()/update()/delete() methods
- *
- * @param db - SQLite database instance
- * @param sql - SQL statement string
- * @param params - Statement parameters (optional)
- * @returns Number of affected rows
- * @throws DatabaseError for SQL execution errors
- */
-export function safeExec(db, sql, params = []) {
-    let stmt = null;
-    // 🔍 DETAILED OPERATION LOGGING
-    if (DEBUG_DB)
-        console.log(`🔍 [DB-OP] EXEC START: ${sql.substring(0, 100)}${sql.length > 100 ? '...' : ''}`);
-    if (params && params.length > 0) {
-        if (DEBUG_DB)
-            console.log(`🔍 [DB-OP] EXEC PARAMS:`, params);
-    }
-    try {
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] PREPARE EXEC: ${sql.substring(0, 80)}${sql.length > 80 ? '...' : ''}`);
-        stmt = db.prepare(sql);
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] PREPARE EXEC SUCCESS`);
-        if (params.length > 0) {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] BIND EXEC PARAMS:`, params);
-            stmt.bind(params);
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] BIND EXEC SUCCESS`);
-        }
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] EXECUTING STATEMENT...`);
-        stmt.step();
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] STATEMENT EXECUTED SUCCESSFULLY`);
-        // Get affected rows count for INSERT/UPDATE/DELETE
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] GETTING CHANGES COUNT...`);
-        const changes = db.exec('SELECT changes() as count')[0];
-        const changeCount = changes?.values?.[0]?.[0] || 0;
-        if (DEBUG_DB)
-            console.log(`📋 [STMT] EXEC COMPLETE: ${changeCount} rows affected`);
-        return changeCount;
-    }
-    catch (error) {
-        console.error(`❌ [DB-OP] EXEC FAILED: ${sql}`);
-        console.error(`❌ [DB-OP] ERROR:`, error);
-        // 🎯 DETECT STATEMENT CLOSED ERRORS
-        if (error instanceof Error && error.message.includes('Statement closed')) {
-            console.error(`🚨 [DB-OP] STATEMENT CLOSED ERROR IN EXEC!`);
-            console.error(`🚨 [DB-OP] SQL: ${sql}`);
-            console.error(`🚨 [DB-OP] PARAMS:`, params);
-            throw new DatabaseError(`Database corruption detected (Statement closed): ${sql}`, error);
-        }
-        console.error(`🚨 [DEBUG] Detailed execution error:`, error);
-        console.error(`🚨 [DEBUG] Error type:`, typeof error);
-        console.error(`🚨 [DEBUG] Error message:`, error?.message);
-        console.error(`🚨 [DEBUG] Error stack:`, error?.stack);
-        throw new DatabaseError(`Execution failed: ${sql}`, error);
-    }
-    finally {
-        if (stmt) {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] FREEING EXEC STATEMENT...`);
-            try {
-                stmt.free();
-                if (DEBUG_DB)
-                    console.log(`📋 [STMT] EXEC STATEMENT FREED SUCCESSFULLY`);
-            }
-            catch (freeError) {
-                console.error(`❌ [STMT] FAILED TO FREE EXEC STATEMENT:`, freeError);
-            }
-        }
-        else {
-            if (DEBUG_DB)
-                console.log(`📋 [STMT] NO EXEC STATEMENT TO FREE`);
-        }
-    }
-}
-/**
- * Safe transaction execution with automatic rollback on error.
- * Ensures consistent database state even if operations fail.
- *
- * @todo UPGRADE: Replace with repository.withTransaction() method
- *
- * @param db - SQLite database instance
- * @param operations - Function containing database operations
- * @returns Result of operations function
- * @throws DatabaseError for transaction failures
- */
-export function safeTransaction(db, operations) {
-    try {
-        db.exec('BEGIN TRANSACTION');
-        const result = operations();
-        db.exec('COMMIT');
-        return result;
-    }
-    catch (error) {
-        try {
-            db.exec('ROLLBACK');
-        }
-        catch (rollbackError) {
-            // Log rollback failure but throw original error
-            console.error('Failed to rollback transaction:', rollbackError);
-        }
-        throw new DatabaseError('Transaction failed', error);
-    }
-}
-/**
- * Get the last inserted row ID from an INSERT operation.
- * Helper for operations that need the new record ID.
- *
- * @todo UPGRADE: Repository pattern will handle this automatically
- *
- * @param db - SQLite database instance
- * @returns Last inserted row ID
- */
-export function getLastInsertId(db) {
-    const result = safeQueryFirst(db, 'SELECT last_insert_rowid() as id');
-    return result?.id || 0;
-}
-/**
- * Custom error class for database operations.
- * Provides consistent error handling across all database functions.
- *
- * @todo UPGRADE: Repository pattern will have more specific error types
- */
-export class DatabaseError extends Error {
-    cause;
-    constructor(message, cause) {
-        super(message);
-        this.cause = cause;
-        this.name = 'DatabaseError';
-        // Include original error details if available
-        if (cause instanceof Error) {
-            this.message += ` (${cause.message})`;
-        }
-    }
-}
-/**
- * MIGRATION HELPERS
- *
- * These functions help gradually replace manual prepare/free patterns
- * throughout the existing codebase.
- */
-/**
- * Check if a table exists in the database.
- * Common pattern used in migration logic.
- *
- * @param db - SQLite database instance
- * @param tableName - Name of table to check
- * @returns True if table exists
- */
-export function tableExists(db, tableName) {
-    const result = safeQueryFirst(db, 'SELECT COUNT(*) as count FROM sqlite_master WHERE type="table" AND name=?', [tableName]);
-    return (result?.count || 0) > 0;
-}
-/**
- * Check if a column exists in a table.
- * Useful for schema validation and migrations.
- *
- * @param db - SQLite database instance
- * @param tableName - Name of table
- * @param columnName - Name of column to check
- * @returns True if column exists
- */
-export function columnExists(db, tableName, columnName) {
-    try {
-        const result = safeQuery(db, `PRAGMA table_info(${tableName})`);
-        return result.some((col) => col.name === columnName);
-    }
-    catch {
-        return false;
-    }
-}
-/**
- * COMMON UTILITY PATTERNS
- *
- * These higher-level helpers encapsulate frequent database patterns
- */
-/**
- * Check if any records exist matching the criteria
- * @param db - SQLite database instance
- * @param table - Table name
- * @param whereClause - WHERE clause (without WHERE keyword)
- * @param params - Parameters for WHERE clause
- * @returns True if any records exist
- */
-export function recordExists(db, table, whereClause, params = []) {
-    const result = safeQueryFirst(db, `SELECT COUNT(*) as count FROM ${table} WHERE ${whereClause}`, params);
-    return (result?.count || 0) > 0;
-}
-/**
- * Count records matching criteria
- * @param db - SQLite database instance
- * @param table - Table name
- * @param whereClause - WHERE clause (without WHERE keyword, optional)
- * @param params - Parameters for WHERE clause
- * @returns Number of matching records
- */
-export function countRecords(db, table, whereClause, params = []) {
-    const sql = whereClause
-        ? `SELECT COUNT(*) as count FROM ${table} WHERE ${whereClause}`
-        : `SELECT COUNT(*) as count FROM ${table}`;
-    const result = safeQueryFirst(db, sql, params);
-    return result?.count || 0;
-}
-/**
- * Delete records with safe execution
- * @param db - SQLite database instance
- * @param table - Table name
- * @param whereClause - WHERE clause (without WHERE keyword)
- * @param params - Parameters for WHERE clause
- * @returns Number of deleted records
- */
-export function deleteRecords(db, table, whereClause, params = []) {
-    return safeExec(db, `DELETE FROM ${table} WHERE ${whereClause}`, params);
-}
-/**
- * Update records with safe execution
- * @param db - SQLite database instance
- * @param table - Table name
- * @param setClause - SET clause (without SET keyword)
- * @param whereClause - WHERE clause (without WHERE keyword)
- * @param params - Parameters for SET and WHERE clauses
- * @returns Number of updated records
- */
-export function updateRecords(db, table, setClause, whereClause, params = []) {
-    return safeExec(db, `UPDATE ${table} SET ${setClause} WHERE ${whereClause}`, params);
-}
-/**
- * ======================================================================================
- * ASYNC LOCKING WRAPPER FUNCTIONS - PHASE 1 ASYNC INFRASTRUCTURE
- * ======================================================================================
- *
- * These functions provide thread-safe database operations by wrapping the existing
- * safe utility functions with DatabaseOperationQueue serialization. This ELIMINATES
- * "Statement closed" errors and race conditions by ensuring only ONE database
- * operation executes at a time.
- *
- * @author Emma - Technical Implementation Specialist
- * @task Task 3: Enhanced Database Utils with Locking
- * @dependencies Task 1 (AsyncMutex), Task 2 (DatabaseOperationQueue)
- */
-// Global database queue instance
-const dbQueue = DatabaseOperationQueue.getInstance();
-/**
- * Thread-safe query execution with async locking protection.
- * Wraps safeQuery() with DatabaseOperationQueue serialization.
- *
- * @param db - SQLite database instance
- * @param sql - SQL query string
- * @param params - Query parameters (optional)
- * @returns Promise<Array> of query results
- * @throws DatabaseError for SQL execution errors
- */
-export async function safeQueryWithLocking(db, sql, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-QUERY] Executing with locking protection: ${sql.substring(0, 80)}...`);
-        const result = safeQuery(db, sql, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-QUERY] Completed successfully: ${result.length} results`);
-        return result;
-    }, `query:${sql.substring(0, 50)}...`);
-}
-/**
- * Thread-safe query first execution with async locking protection.
- * Wraps safeQueryFirst() with DatabaseOperationQueue serialization.
- *
- * @param db - SQLite database instance
- * @param sql - SQL query string
- * @param params - Query parameters (optional)
- * @returns Promise<T | null> first matching row or null
- * @throws DatabaseError for SQL execution errors
- */
-export async function safeQueryFirstWithLocking(db, sql, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-QUERY-FIRST] Executing with locking protection: ${sql.substring(0, 80)}...`);
-        const result = safeQueryFirst(db, sql, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-QUERY-FIRST] Completed successfully: ${result ? 'Found result' : 'No result'}`);
-        return result;
-    }, `queryFirst:${sql.substring(0, 50)}...`);
-}
-/**
- * Thread-safe execution with async locking protection.
- * Wraps safeExec() with DatabaseOperationQueue serialization.
- *
- * @param db - SQLite database instance
- * @param sql - SQL statement string
- * @param params - Statement parameters (optional)
- * @returns Promise<number> of affected rows
- * @throws DatabaseError for SQL execution errors
- */
-export async function safeExecWithLocking(db, sql, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-EXEC] Executing with locking protection: ${sql.substring(0, 80)}...`);
-        const result = safeExec(db, sql, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-EXEC] Completed successfully: ${result} rows affected`);
-        return result;
-    }, `exec:${sql.substring(0, 50)}...`);
-}
-/**
- * Thread-safe transaction execution with async locking protection.
- * Wraps safeTransaction() with DatabaseOperationQueue serialization.
- *
- * CRITICAL: This ensures atomic transactions with NO race conditions.
- * Multiple transactions CANNOT run concurrently - GUARANTEED serialization.
- *
- * @param db - SQLite database instance
- * @param operations - Function containing database operations
- * @returns Promise<T> result of operations function
- * @throws DatabaseError for transaction failures
- */
-export async function safeTransactionWithLocking(db, operations) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-TRANSACTION] Starting transaction with locking protection`);
-        try {
-            db.exec('BEGIN TRANSACTION');
-            if (DEBUG_DB)
-                console.log(`🔒 [ASYNC-TRANSACTION] Transaction started`);
-            const result = await operations(db);
-            db.exec('COMMIT');
-            if (DEBUG_DB)
-                console.log(`✅ [ASYNC-TRANSACTION] Transaction committed successfully`);
-            return result;
-        }
-        catch (error) {
-            console.error(`❌ [ASYNC-TRANSACTION] Transaction failed, rolling back:`, error);
-            try {
-                db.exec('ROLLBACK');
-                if (DEBUG_DB)
-                    console.log(`🔄 [ASYNC-TRANSACTION] Rollback completed`);
-            }
-            catch (rollbackError) {
-                console.error(`🚨 [ASYNC-TRANSACTION] Rollback failed:`, rollbackError);
-            }
-            throw new DatabaseError('Async transaction failed', error);
-        }
-    }, 'transaction');
-}
-/**
- * UTILITY WRAPPERS WITH ASYNC LOCKING
- *
- * These provide async-safe versions of common utility functions
- */
-/**
- * Thread-safe record existence check with async locking protection.
- */
-export async function recordExistsWithLocking(db, table, whereClause, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-EXISTS] Checking record existence: ${table} WHERE ${whereClause}`);
-        const result = recordExists(db, table, whereClause, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-EXISTS] Record existence check: ${result}`);
-        return result;
-    }, `exists:${table}`);
-}
-/**
- * Thread-safe record counting with async locking protection.
- */
-export async function countRecordsWithLocking(db, table, whereClause, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-COUNT] Counting records: ${table}${whereClause ? ` WHERE ${whereClause}` : ''}`);
-        const result = countRecords(db, table, whereClause, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-COUNT] Record count: ${result}`);
-        return result;
-    }, `count:${table}`);
-}
-/**
- * Thread-safe record deletion with async locking protection.
- */
-export async function deleteRecordsWithLocking(db, table, whereClause, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-DELETE] Deleting records: ${table} WHERE ${whereClause}`);
-        const result = deleteRecords(db, table, whereClause, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-DELETE] Records deleted: ${result}`);
-        return result;
-    }, `delete:${table}`);
-}
-/**
- * Thread-safe record updating with async locking protection.
- */
-export async function updateRecordsWithLocking(db, table, setClause, whereClause, params = []) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-UPDATE] Updating records: ${table} SET ${setClause} WHERE ${whereClause}`);
-        const result = updateRecords(db, table, setClause, whereClause, params);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-UPDATE] Records updated: ${result}`);
-        return result;
-    }, `update:${table}`);
-}
-/**
- * Thread-safe last insert ID retrieval with async locking protection.
- */
-export async function getLastInsertIdWithLocking(db) {
-    return dbQueue.executeOperation(async () => {
-        if (DEBUG_DB)
-            console.log(`🔒 [ASYNC-LAST-ID] Getting last insert ID`);
-        // This function should only be called with Database type
-        // FSSLinkDatabase should use pool.withConnection() pattern
-        const result = getLastInsertId(db);
-        if (DEBUG_DB)
-            console.log(`✅ [ASYNC-LAST-ID] Last insert ID: ${result}`);
-        return result;
-    }, 'lastInsertId');
-}
-/**
- * ======================================================================================
- * MIGRATION GUIDE: FROM UNSAFE TO ASYNC-SAFE DATABASE OPERATIONS
- * ======================================================================================
- *
- * OLD (race condition prone):
- * const results = safeQuery(db, 'SELECT * FROM model_configs WHERE auth_type = ?', [authType]);
- * const count = safeExec(db, 'UPDATE model_configs SET is_active = 0');
- *
- * NEW (thread-safe with async locking):
- * const results = await safeQueryWithLocking(db, 'SELECT * FROM model_configs WHERE auth_type = ?', [authType]);
- * const count = await safeExecWithLocking(db, 'UPDATE model_configs SET is_active = 0');
- *
- * TRANSACTION EXAMPLE:
- * const result = await safeTransactionWithLocking(db, async (db) => {
- *   await safeExecWithLocking(db, 'UPDATE model_configs SET is_active = 0');
- *   await safeExecWithLocking(db, 'UPDATE model_configs SET is_active = 1 WHERE id = ?', [modelId]);
- *   return { success: true };
- * });
- *
- * UTILITY EXAMPLES:
- * const exists = await recordExistsWithLocking(db, 'model_configs', 'is_active = 1');
- * const count = await countRecordsWithLocking(db, 'model_configs', 'auth_type = ?', ['ollama']);
- * const deleted = await deleteRecordsWithLocking(db, 'model_configs', 'is_active = 0 AND last_used < ?', [cutoffDate]);
- */
-/**
- * EXAMPLE MIGRATION FROM OLD PATTERN TO NEW PATTERN:
- *
- * // OLD (manual memory management):
- * const stmt = db.prepare('SELECT * FROM model_configs WHERE auth_type = ?');
- * stmt.bind([authType]);
- * const results = [];
- * while (stmt.step()) {
- *   results.push(stmt.getAsObject());
- * }
- * stmt.free(); // Easy to forget!
- *
- * // NEW (automatic cleanup):
- * const results = safeQuery(db, 'SELECT * FROM model_configs WHERE auth_type = ?', [authType]);
- *
- * // UTILITY HELPERS:
- * const hasActiveModels = recordExists(db, 'model_configs', 'is_active = 1');
- * const modelCount = countRecords(db, 'model_configs', 'auth_type = ?', ['ollama']);
- * const deletedCount = deleteRecords(db, 'model_configs', 'is_active = 0 AND last_used < ?', [cutoffDate]);
- *
- * // FUTURE (repository pattern):
- * const results = await modelRepo.findByAuthType(authType);
- * const hasActive = await modelRepo.hasActive();
- * const count = await modelRepo.countByAuthType('ollama');
- * const deleted = await modelRepo.deleteInactive(cutoffDate);
- */ 
-//# sourceMappingURL=database-utils.js.map