local-lite 0.0.5 → 0.0.6

package/dist/core/query-builder.js

@@ -35,6 +35,143 @@ function formatColumnIdentifier(col) {
     }
     return `"${trimmed.replace(/"/g, '""')}"`;
 }
+// ---------------------------------------------------------------------------
+// Module-scoped SQL compilation helpers (defined once, reused on every query)
+// ---------------------------------------------------------------------------
+/**
+ * Compiles a single column comparison value into one or more SQL fragments.
+ * Supports null, boolean, scalar, and operator-object forms ($eq, $gt, $in, …).
+ */
+function compileComparison(safeCol, val, params) {
+    if (val === null) {
+        return `${safeCol} IS NULL`;
+    }
+    if (typeof val === 'boolean') {
+        params.push(val ? 1 : 0);
+        return `${safeCol} = ?`;
+    }
+    if (typeof val === 'string' || typeof val === 'number') {
+        params.push(val);
+        return `${safeCol} = ?`;
+    }
+    if (typeof val === 'object' && !Array.isArray(val)) {
+        const ops = val;
+        const subClauses = [];
+        const eqVal = ops.$eq !== undefined ? ops.$eq : ops.eq;
+        if (eqVal !== undefined) {
+            subClauses.push(`${safeCol} = ?`);
+            params.push(typeof eqVal === 'boolean' ? (eqVal ? 1 : 0) : eqVal);
+        }
+        const neVal = ops.$ne !== undefined ? ops.$ne : ops.ne;
+        if (neVal !== undefined) {
+            subClauses.push(`${safeCol} != ?`);
+            params.push(typeof neVal === 'boolean' ? (neVal ? 1 : 0) : neVal);
+        }
+        const gtVal = ops.$gt !== undefined ? ops.$gt : ops.gt;
+        if (gtVal !== undefined) {
+            subClauses.push(`${safeCol} > ?`);
+            params.push(gtVal);
+        }
+        const gteVal = ops.$gte !== undefined ? ops.$gte : ops.gte;
+        if (gteVal !== undefined) {
+            subClauses.push(`${safeCol} >= ?`);
+            params.push(gteVal);
+        }
+        const ltVal = ops.$lt !== undefined ? ops.$lt : ops.lt;
+        if (ltVal !== undefined) {
+            subClauses.push(`${safeCol} < ?`);
+            params.push(ltVal);
+        }
+        const lteVal = ops.$lte !== undefined ? ops.$lte : ops.lte;
+        if (lteVal !== undefined) {
+            subClauses.push(`${safeCol} <= ?`);
+            params.push(lteVal);
+        }
+        const inVal = ops.$in !== undefined ? ops.$in : ops.in;
+        if (Array.isArray(inVal) && inVal.length > 0) {
+            const placeholders = inVal.map(() => '?').join(', ');
+            subClauses.push(`${safeCol} IN (${placeholders})`);
+            params.push(...inVal);
+        }
+        const ninVal = ops.$nin !== undefined ? ops.$nin : ops.nin;
+        if (Array.isArray(ninVal) && ninVal.length > 0) {
+            const placeholders = ninVal.map(() => '?').join(', ');
+            subClauses.push(`${safeCol} NOT IN (${placeholders})`);
+            params.push(...ninVal);
+        }
+        const containsVal = ops.$contains !== undefined ? ops.$contains : ops.contains;
+        if (containsVal !== undefined) {
+            subClauses.push(`${safeCol} LIKE ?`);
+            params.push(`%${containsVal}%`);
+        }
+        const startsWithVal = ops.$startsWith !== undefined ? ops.$startsWith : ops.startsWith;
+        if (startsWithVal !== undefined) {
+            subClauses.push(`${safeCol} LIKE ?`);
+            params.push(`${startsWithVal}%`);
+        }
+        const endsWithVal = ops.$endsWith !== undefined ? ops.$endsWith : ops.endsWith;
+        if (endsWithVal !== undefined) {
+            subClauses.push(`${safeCol} LIKE ?`);
+            params.push(`%${endsWithVal}`);
+        }
+        const nullVal = ops.$null !== undefined ? ops.$null : ops.null;
+        if (nullVal !== undefined) {
+            subClauses.push(nullVal ? `${safeCol} IS NULL` : `${safeCol} IS NOT NULL`);
+        }
+        if (subClauses.length > 0) {
+            return subClauses.join(' AND ');
+        }
+    }
+    return null;
+}
+/**
+ * Recursively compiles a where-conditions object (including $or / $and) into SQL clauses.
+ */
+function compileWhereConditions(where, params) {
+    const clauses = [];
+    // Handle $or — compile each branch, join with OR
+    if (Array.isArray(where.$or) && where.$or.length > 0) {
+        const orClauses = [];
+        for (const sub of where.$or) {
+            if (typeof sub === 'object' && sub !== null) {
+                const subList = compileWhereConditions(sub, params);
+                if (subList.length > 0) {
+                    orClauses.push(`(${subList.join(' AND ')})`);
+                }
+            }
+        }
+        if (orClauses.length > 0) {
+            clauses.push(`(${orClauses.join(' OR ')})`);
+        }
+    }
+    // Handle $and — compile each branch, join with AND
+    if (Array.isArray(where.$and) && where.$and.length > 0) {
+        const andClauses = [];
+        for (const sub of where.$and) {
+            if (typeof sub === 'object' && sub !== null) {
+                const subList = compileWhereConditions(sub, params);
+                if (subList.length > 0) {
+                    andClauses.push(`(${subList.join(' AND ')})`);
+                }
+            }
+        }
+        if (andClauses.length > 0) {
+            clauses.push(`(${andClauses.join(' AND ')})`);
+        }
+    }
+    // Handle regular column conditions
+    for (const [col, val] of Object.entries(where)) {
+        if (col === '$or' || col === '$and')
+            continue;
+        const safeCol = formatColumnIdentifier(col);
+        const clause = compileComparison(safeCol, val, params);
+        if (clause) {
+            clauses.push(clause);
+        }
+    }
+    return clauses;
+}
+// ---------------------------------------------------------------------------
 /**
  * Fluent, type-safe SQL Query Builder for local-first SQLite operations.
  * Allows writing expressive JavaScript code that compiles and executes high-performance SQL under the hood.
@@ -171,6 +308,7 @@ class QueryBuilder {
     }
     /**
      * Compiles the current builder state into an executable SQL string and parameter list.
+     * Uses module-scoped compileComparison / compileWhereConditions helpers (defined once).
      */
     toSQL() {
         const params = [];
@@ -184,79 +322,10 @@ class QueryBuilder {
             const col2 = formatColumnIdentifier(j.secondCol);
             sql += ` ${j.type} JOIN ${joinTable} ON ${col1} = ${col2}`;
         }
-        // Build WHERE clauses
+        // Build WHERE clauses (delegates to module-scoped helpers)
         const whereClauses = [];
         if (this.whereConditions && typeof this.whereConditions === 'object') {
-            for (const [col, val] of Object.entries(this.whereConditions)) {
-                if (col === '$or' || col === '$and')
-                    continue;
-                const safeCol = formatColumnIdentifier(col);
-                if (val === null) {
-                    whereClauses.push(`${safeCol} IS NULL`);
-                }
-                else if (typeof val === 'boolean') {
-                    whereClauses.push(`${safeCol} = ?`);
-                    params.push(val ? 1 : 0);
-                }
-                else if (typeof val === 'string' || typeof val === 'number') {
-                    whereClauses.push(`${safeCol} = ?`);
-                    params.push(val);
-                }
-                else if (typeof val === 'object' && !Array.isArray(val)) {
-                    const ops = val;
-                    const eqVal = ops.$eq !== undefined ? ops.$eq : ops.eq;
-                    if (eqVal !== undefined) {
-                        whereClauses.push(`${safeCol} = ?`);
-                        params.push(typeof eqVal === 'boolean' ? (eqVal ? 1 : 0) : eqVal);
-                    }
-                    const neVal = ops.$ne !== undefined ? ops.$ne : ops.ne;
-                    if (neVal !== undefined) {
-                        whereClauses.push(`${safeCol} != ?`);
-                        params.push(typeof neVal === 'boolean' ? (neVal ? 1 : 0) : neVal);
-                    }
-                    const gtVal = ops.$gt !== undefined ? ops.$gt : ops.gt;
-                    if (gtVal !== undefined) {
-                        whereClauses.push(`${safeCol} > ?`);
-                        params.push(gtVal);
-                    }
-                    const gteVal = ops.$gte !== undefined ? ops.$gte : ops.gte;
-                    if (gteVal !== undefined) {
-                        whereClauses.push(`${safeCol} >= ?`);
-                        params.push(gteVal);
-                    }
-                    const ltVal = ops.$lt !== undefined ? ops.$lt : ops.lt;
-                    if (ltVal !== undefined) {
-                        whereClauses.push(`${safeCol} < ?`);
-                        params.push(ltVal);
-                    }
-                    const lteVal = ops.$lte !== undefined ? ops.$lte : ops.lte;
-                    if (lteVal !== undefined) {
-                        whereClauses.push(`${safeCol} <= ?`);
-                        params.push(lteVal);
-                    }
-                    const inVal = ops.$in !== undefined ? ops.$in : ops.in;
-                    if (Array.isArray(inVal) && inVal.length > 0) {
-                        const placeholders = inVal.map(() => '?').join(', ');
-                        whereClauses.push(`${safeCol} IN (${placeholders})`);
-                        params.push(...inVal);
-                    }
-                    const ninVal = ops.$nin !== undefined ? ops.$nin : ops.nin;
-                    if (Array.isArray(ninVal) && ninVal.length > 0) {
-                        const placeholders = ninVal.map(() => '?').join(', ');
-                        whereClauses.push(`${safeCol} NOT IN (${placeholders})`);
-                        params.push(...ninVal);
-                    }
-                    const containsVal = ops.$contains !== undefined ? ops.$contains : ops.contains;
-                    if (containsVal !== undefined) {
-                        whereClauses.push(`${safeCol} LIKE ?`);
-                        params.push(`%${containsVal}%`);
-                    }
-                    const nullVal = ops.$null !== undefined ? ops.$null : ops.null;
-                    if (nullVal !== undefined) {
-                        whereClauses.push(nullVal ? `${safeCol} IS NULL` : `${safeCol} IS NOT NULL`);
-                    }
-                }
-            }
+            whereClauses.push(...compileWhereConditions(this.whereConditions, params));
         }
         // Push down soft-deletion check on primary table if deleted column exists and not explicitly overridden
         const schemaManager = 'schemaManager' in this.client

package/dist/core/query.js

@@ -48,26 +48,14 @@ function matchesField(fieldValue, filter) {
     if (ops.$lte !== undefined && !(fieldValue <= ops.$lte)) {
         return false;
     }
-    if (ops.$contains !== undefined) {
-        const str = fieldValue === null || fieldValue === undefined ? '' : String(fieldValue).toLowerCase();
-        const search = String(ops.$contains).toLowerCase();
-        if (!str.includes(search)) {
+    if (ops.$contains !== undefined || ops.$startsWith !== undefined || ops.$endsWith !== undefined) {
+        const str = fieldValue == null ? '' : String(fieldValue).toLowerCase();
+        if (ops.$contains !== undefined && !str.includes(String(ops.$contains).toLowerCase()))
             return false;
-        }
-    }
-    if (ops.$startsWith !== undefined) {
-        const str = fieldValue === null || fieldValue === undefined ? '' : String(fieldValue).toLowerCase();
-        const prefix = String(ops.$startsWith).toLowerCase();
-        if (!str.startsWith(prefix)) {
+        if (ops.$startsWith !== undefined && !str.startsWith(String(ops.$startsWith).toLowerCase()))
             return false;
-        }
-    }
-    if (ops.$endsWith !== undefined) {
-        const str = fieldValue === null || fieldValue === undefined ? '' : String(fieldValue).toLowerCase();
-        const suffix = String(ops.$endsWith).toLowerCase();
-        if (!str.endsWith(suffix)) {
+        if (ops.$endsWith !== undefined && !str.endsWith(String(ops.$endsWith).toLowerCase()))
             return false;
-        }
     }
     if (ops.$null !== undefined) {
         const isNull = fieldValue === null || fieldValue === undefined;
@@ -131,18 +119,28 @@ function hasExplicitDeletedFilter(where) {
 function applyQueryOptions(rows, options) {
     if (!rows || rows.length === 0)
         return [];
-    let result = [...rows];
-    // 0. Automatic soft-delete filtering: omit deleted records unless includeDeleted is true
-    // or the where filter explicitly targets 'deleted'.
-    if (!options?.includeDeleted && !hasExplicitDeletedFilter(options?.where)) {
+    const needsDeleteFilter = !options?.includeDeleted && !hasExplicitDeletedFilter(options?.where);
+    const needsWhere = Boolean(options?.where);
+    const needsSort = Boolean(options?.orderBy);
+    const needsSlice = (options?.offset !== undefined && options.offset > 0) ||
+        (options?.limit !== undefined && options.limit > 0);
+    const needsSelect = Array.isArray(options?.select) && options.select.length > 0;
+    // Fast-path: nothing to do
+    if (!needsDeleteFilter && !needsWhere && !needsSort && !needsSlice && !needsSelect) {
+        return rows;
+    }
+    let result = rows;
+    // 0. Soft-delete filtering
+    if (needsDeleteFilter) {
         result = result.filter((row) => !isDeletedRecord(row));
     }
     // 1. Where filtering
-    if (options?.where) {
+    if (needsWhere) {
         result = result.filter((row) => matchesWhere(row, options.where));
     }
     // 2. Order by
-    if (options?.orderBy) {
+    if (needsSort) {
+        result = [...result]; // copy only before sort mutation
         const key = options.orderBy;
         const isAsc = (options.order || 'asc').toLowerCase() === 'asc';
         result.sort((a, b) => {
@@ -164,21 +162,19 @@ function applyQueryOptions(rows, options) {
         });
     }
     // 3. Offset and Limit
-    if (options?.offset !== undefined && options.offset > 0) {
-        result = result.slice(options.offset);
-    }
-    if (options?.limit !== undefined && options.limit > 0) {
-        result = result.slice(0, options.limit);
+    if (needsSlice) {
+        const offset = options?.offset && options.offset > 0 ? options.offset : 0;
+        const limit = options?.limit && options.limit > 0 ? options.limit : undefined;
+        result = limit !== undefined ? result.slice(offset, offset + limit) : result.slice(offset);
     }
-    // 4. Column Projection
-    if (options?.select && Array.isArray(options.select) && options.select.length > 0) {
+    // 4. Column projection
+    if (needsSelect) {
         const fields = options.select;
         result = result.map((row) => {
             const projected = {};
             for (const field of fields) {
-                if (field in row) {
+                if (field in row)
                     projected[field] = row[field];
-                }
             }
             return projected;
         });

package/dist/core/schema-manager.d.ts

@@ -3,15 +3,6 @@ export interface DBExecutable {
 }
 /**
  * Detects the appropriate SQLite column type affinity from a JavaScript runtime value.
- *
- * Mapping:
- * - boolean -> INTEGER (0 or 1)
- * - integer -> INTEGER
- * - float/double -> REAL
- * - string -> TEXT
- * - object/array -> TEXT (JSON formatted)
- * - Uint8Array -> BLOB
- * - null/undefined -> TEXT (flexible SQLite type affinity)
  */
 export declare function detectSQLiteType(value: any): 'INTEGER' | 'REAL' | 'TEXT' | 'BLOB';
 /**
@@ -24,18 +15,16 @@ export declare class SchemaManager {
     private knownTables;
     private knownColumns;
     private knownIndexes;
-    /**
-     * Resets the schema cache (useful for testing or full database resets).
-     */
     clearCache(): void;
-    /**
-     * Checks whether a column is known to exist on the specified table.
-     */
     hasColumn(tableName: string, column: string): boolean;
     /**
      * Introspects table columns via PRAGMA table_info if not previously cached.
      */
     ensureTableIntrospected(db: DBExecutable, tableName: string): Promise<void>;
+    /**
+     * Automatically creates single-column and composite FK+deleted indexes for given columns.
+     */
+    private autoIndexColumns;
     /**
      * Ensures that the target table exists in SQLite with the specified primary key.
      */

package/dist/core/schema-manager.js

@@ -6,36 +6,14 @@ exports.formatValueForStorage = formatValueForStorage;
 const sql_js_1 = require("../utils/sql.js");
 /**
  * Detects the appropriate SQLite column type affinity from a JavaScript runtime value.
- *
- * Mapping:
- * - boolean -> INTEGER (0 or 1)
- * - integer -> INTEGER
- * - float/double -> REAL
- * - string -> TEXT
- * - object/array -> TEXT (JSON formatted)
- * - Uint8Array -> BLOB
- * - null/undefined -> TEXT (flexible SQLite type affinity)
  */
 function detectSQLiteType(value) {
-    if (value === null || value === undefined) {
-        return 'TEXT';
-    }
-    const type = typeof value;
-    if (type === 'boolean') {
+    if (typeof value === 'boolean')
         return 'INTEGER';
-    }
-    if (type === 'number') {
+    if (typeof value === 'number')
         return Number.isInteger(value) ? 'INTEGER' : 'REAL';
-    }
-    if (type === 'string') {
-        return 'TEXT';
-    }
-    if (value instanceof Uint8Array) {
+    if (value instanceof Uint8Array)
         return 'BLOB';
-    }
-    if (type === 'object') {
-        return 'TEXT';
-    }
     return 'TEXT';
 }
 /**
@@ -44,32 +22,23 @@ function detectSQLiteType(value) {
  * - Plain objects and arrays are JSON serialized
  */
 function formatValueForStorage(value) {
-    if (value === null || value === undefined) {
+    if (value === null || value === undefined)
         return null;
-    }
-    if (typeof value === 'boolean') {
+    if (typeof value === 'boolean')
         return value ? 1 : 0;
-    }
-    if (typeof value === 'object' && !(value instanceof Uint8Array)) {
+    if (typeof value === 'object' && !(value instanceof Uint8Array))
         return JSON.stringify(value);
-    }
     return value;
 }
 class SchemaManager {
     knownTables = new Set();
     knownColumns = new Set();
     knownIndexes = new Set();
-    /**
-     * Resets the schema cache (useful for testing or full database resets).
-     */
     clearCache() {
         this.knownTables.clear();
         this.knownColumns.clear();
         this.knownIndexes.clear();
     }
-    /**
-     * Checks whether a column is known to exist on the specified table.
-     */
     hasColumn(tableName, column) {
         return this.knownColumns.has(`${tableName}:${column.toLowerCase()}`);
     }
@@ -84,57 +53,54 @@ class SchemaManager {
         const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
         try {
             const tableInfo = await db.execute(`PRAGMA table_info(${safeTable});`);
+            const cols = [];
             if (Array.isArray(tableInfo)) {
                 for (const col of tableInfo) {
-                    if (col && col.name) {
+                    if (col?.name) {
                         this.knownColumns.add(`${tableName}:${String(col.name).toLowerCase()}`);
+                        cols.push(String(col.name));
                     }
                 }
             }
-            // Auto-create high performance single and composite indexes for foreign keys (_id) and soft-deletes (deleted)
-            const hasDeleted = this.knownColumns.has(`${tableName}:deleted`);
-            for (const entry of this.knownColumns) {
-                if (!entry.startsWith(`${tableName}:`))
-                    continue;
-                const colName = entry.slice(tableName.length + 1);
-                if (colName.endsWith('_id') && colName !== 'id') {
-                    const fkIndexKey = `${tableName}:${colName}`;
-                    if (!this.knownIndexes.has(fkIndexKey)) {
-                        this.knownIndexes.add(fkIndexKey);
-                        try {
-                            const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${colName}`);
-                            const safeFk = (0, sql_js_1.escapeIdentifier)(colName);
-                            await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeFk});`);
-                        }
-                        catch { }
+            await this.autoIndexColumns(db, tableName, safeTable, cols);
+        }
+        catch { }
+    }
+    /**
+     * Automatically creates single-column and composite FK+deleted indexes for given columns.
+     */
+    async autoIndexColumns(db, tableName, safeTable, columns) {
+        const hasDeleted = this.knownColumns.has(`${tableName}:deleted`);
+        for (const key of columns) {
+            const lower = key.toLowerCase();
+            if (lower.endsWith('_id') || lower === 'deleted' || lower === 'created_at' || lower === 'updated_at') {
+                const indexKey = `${tableName}:${lower}`;
+                if (!this.knownIndexes.has(indexKey)) {
+                    this.knownIndexes.add(indexKey);
+                    try {
+                        await db.execute(`CREATE INDEX IF NOT EXISTS ${(0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${key}`)} ON ${safeTable} (${(0, sql_js_1.escapeIdentifier)(key)});`);
                     }
-                    if (hasDeleted) {
-                        const compositeKey = `${tableName}:${colName}_deleted`;
-                        if (!this.knownIndexes.has(compositeKey)) {
-                            this.knownIndexes.add(compositeKey);
-                            try {
-                                const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${colName}_del`);
-                                const safeFk = (0, sql_js_1.escapeIdentifier)(colName);
-                                const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
-                                await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeFk}, ${safeDel});`);
-                            }
-                            catch { }
-                        }
+                    catch { }
+                }
+            }
+            if (hasDeleted && lower.endsWith('_id') && lower !== 'id') {
+                const compositeKey = `${tableName}:${lower}_deleted`;
+                if (!this.knownIndexes.has(compositeKey)) {
+                    this.knownIndexes.add(compositeKey);
+                    try {
+                        await db.execute(`CREATE INDEX IF NOT EXISTS ${(0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${lower}_del`)} ON ${safeTable} (${(0, sql_js_1.escapeIdentifier)(key)}, "deleted");`);
                     }
+                    catch { }
                 }
             }
         }
-        catch {
-            // Ignore
-        }
     }
     /**
      * Ensures that the target table exists in SQLite with the specified primary key.
      */
     async ensureTable(db, tableName, primaryKey = 'id') {
-        if (this.knownTables.has(tableName)) {
+        if (this.knownTables.has(tableName))
             return;
-        }
         const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
         const safePk = (0, sql_js_1.escapeIdentifier)(primaryKey);
         await db.execute(`CREATE TABLE IF NOT EXISTS ${safeTable} (${safePk} TEXT PRIMARY KEY);`);
@@ -147,102 +113,46 @@ class SchemaManager {
      */
     async ensureColumns(db, tableName, payload, primaryKey = 'id') {
         await this.ensureTable(db, tableName, primaryKey);
-        if (!payload || typeof payload !== 'object') {
+        if (!payload || typeof payload !== 'object')
             return {};
-        }
         const keys = Object.keys(payload);
-        if (keys.length === 0) {
+        if (keys.length === 0)
             return {};
-        }
         const safeTable = (0, sql_js_1.escapeIdentifier)(tableName);
         let cacheMiss = false;
         for (const key of keys) {
-            if (key === primaryKey)
-                continue;
-            const cacheKey = `${tableName}:${key.toLowerCase()}`;
-            if (!this.knownColumns.has(cacheKey)) {
+            if (key !== primaryKey && !this.knownColumns.has(`${tableName}:${key.toLowerCase()}`)) {
                 cacheMiss = true;
                 break;
             }
         }
         if (cacheMiss) {
-            // Query PRAGMA table_info to discover existing columns from SQLite
             try {
                 const tableInfo = await db.execute(`PRAGMA table_info(${safeTable});`);
                 if (Array.isArray(tableInfo)) {
                     for (const col of tableInfo) {
-                        if (col && col.name) {
+                        if (col?.name) {
                             this.knownColumns.add(`${tableName}:${String(col.name).toLowerCase()}`);
                         }
                     }
                 }
             }
-            catch (err) {
-                // Fallback for mocks or custom drivers where PRAGMA table_info might not be supported
-            }
-            // Check for columns that still do not exist, and alter table
+            catch { }
             for (const key of keys) {
                 if (key === primaryKey)
                     continue;
                 const cacheKey = `${tableName}:${key.toLowerCase()}`;
                 if (!this.knownColumns.has(cacheKey)) {
                     const detectedType = detectSQLiteType(payload[key]);
-                    const safeCol = (0, sql_js_1.escapeIdentifier)(key);
                     try {
-                        await db.execute(`ALTER TABLE ${safeTable} ADD COLUMN ${safeCol} ${detectedType};`);
-                    }
-                    catch (err) {
-                        // Ignore if column already exists (e.g. concurrent race)
-                        const msg = String(err?.message || err || '');
-                        if (!msg.toLowerCase().includes('duplicate column')) {
-                            // Ignore or rethrow
-                        }
+                        await db.execute(`ALTER TABLE ${safeTable} ADD COLUMN ${(0, sql_js_1.escapeIdentifier)(key)} ${detectedType};`);
                     }
+                    catch { }
                     this.knownColumns.add(cacheKey);
                 }
-                // Auto-index foreign keys and common query columns
-                const lowerKey = key.toLowerCase();
-                if (lowerKey.endsWith('_id') ||
-                    lowerKey === 'deleted' ||
-                    lowerKey === 'created_at' ||
-                    lowerKey === 'updated_at') {
-                    const indexKey = `${tableName}:${lowerKey}`;
-                    if (!this.knownIndexes.has(indexKey)) {
-                        this.knownIndexes.add(indexKey);
-                        try {
-                            const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${key}`);
-                            const safeCol = (0, sql_js_1.escapeIdentifier)(key);
-                            await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeCol});`);
-                        }
-                        catch {
-                            // Ignore if indexes are not supported by adapter or already exist
-                        }
-                    }
-                }
-            }
-        }
-        // Auto-create high performance composite index for foreign keys with soft-deletion
-        if (this.knownColumns.has(`${tableName}:deleted`)) {
-            for (const key of keys) {
-                const lowerKey = key.toLowerCase();
-                if (lowerKey.endsWith('_id') && lowerKey !== 'id') {
-                    const compositeKey = `${tableName}:${lowerKey}_deleted`;
-                    if (!this.knownIndexes.has(compositeKey)) {
-                        this.knownIndexes.add(compositeKey);
-                        try {
-                            const idxName = (0, sql_js_1.escapeIdentifier)(`idx_${tableName}_${lowerKey}_del`);
-                            const safeFk = (0, sql_js_1.escapeIdentifier)(key);
-                            const safeDel = (0, sql_js_1.escapeIdentifier)('deleted');
-                            await db.execute(`CREATE INDEX IF NOT EXISTS ${idxName} ON ${safeTable} (${safeFk}, ${safeDel});`);
-                        }
-                        catch {
-                            // Ignore
-                        }
-                    }
-                }
             }
+            await this.autoIndexColumns(db, tableName, safeTable, keys);
         }
-        // Format all values for SQLite storage
         const formatted = {};
         for (const key of keys) {
             formatted[key] = formatValueForStorage(payload[key]);