local-lite 0.0.5 → 0.0.7

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]);

package/dist/core/sync-worker.js

@@ -611,9 +611,12 @@ class SyncWorker {
             const isLastChunk = i + DELTA_CHUNK_SIZE >= totalChanges;
             const queuedEvents = [];
             await this.db.transaction(async (tx) => {
+                // Pre-fetch active pending outbox records in 1 query for this chunk to eliminate N+1 bridge roundtrips
+                const pendingOutboxMap = await outbox_store_js_1.OutboxStore.getActivePendingMap(tx);
                 for (const change of chunk) {
-                    // 1. Check for pending local mutations for this (table_name, row_id)
-                    const localPendingRecord = await outbox_store_js_1.OutboxStore.findPendingByRow(tx, change.tableName, change.rowId);
+                    const outboxKey = `${change.tableName}:${change.rowId}`;
+                    // 1. Check in-memory map for pending local mutations for this (table_name, row_id)
+                    const localPendingRecord = pendingOutboxMap.get(outboxKey);
                     // 2. Conflict resolution if there is a pending local change
                     if (localPendingRecord) {
                         // Only load the current local row when a resolver actually needs it.
@@ -640,11 +643,13 @@ class SyncWorker {
                         if (resolution === 'apply-remote') {
                             // Remote change wins: remove the superseded local pending outbox mutation
                             await outbox_store_js_1.OutboxStore.deleteRecord(tx, localPendingRecord.id);
+                            pendingOutboxMap.delete(outboxKey);
                         }
                         else if (typeof resolution === 'object' && resolution.mergePayload) {
                             // Merge scenario
                             change.payload = resolution.mergePayload;
                             await outbox_store_js_1.OutboxStore.updatePayload(tx, localPendingRecord.id, resolution.mergePayload);
+                            localPendingRecord.payload = resolution.mergePayload;
                         }
                     }
                     // 3. Apply remote change to local database