local-lite 0.0.5 → 0.0.7

package/dist/adapters/remote/supabase.js

@@ -137,20 +137,9 @@ class SupabaseRemoteAdapter {
                     batch.push(operations[i]);
                     i++;
                 }
-                const buildRowData = (item) => {
-                    const row = {
-                        ...(item.payload || {}),
-                        [this.primaryKey]: item.rowId,
-                        [this.deletedColumn]: false,
-                    };
-                    if (this.updatedAtColumn && !row[this.updatedAtColumn]) {
-                        row[this.updatedAtColumn] = new Date(item.timestamp).toISOString();
-                    }
-                    return row;
-                };
                 if (batch.length === 1) {
                     try {
-                        const rowData = buildRowData(batch[0]);
+                        const rowData = this.buildRowData(batch[0]);
                         const { error } = await client.from(op.tableName).upsert(rowData);
                         if (error) {
                             const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'INSERT' });
@@ -174,7 +163,7 @@ class SupabaseRemoteAdapter {
                     const retryIndividually = async () => {
                         for (const item of batch) {
                             try {
-                                const singleRow = buildRowData(item);
+                                const singleRow = this.buildRowData(item);
                                 const { error: singleErr } = await client.from(op.tableName).upsert(singleRow);
                                 if (singleErr) {
                                     const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'INSERT' });
@@ -193,7 +182,7 @@ class SupabaseRemoteAdapter {
                         }
                     };
                     try {
-                        const rows = batch.map(buildRowData);
+                        const rows = batch.map((item) => this.buildRowData(item));
                         const { error } = await client.from(op.tableName).upsert(rows);
                         if (!error) {
                             for (const item of batch)
@@ -209,87 +198,173 @@ class SupabaseRemoteAdapter {
                 }
                 continue;
             }
-            // Handle DELETE
+            // Batch consecutive DELETEs for the same table
             if (op.operation === 'DELETE') {
-                try {
-                    const patch = {
-                        [this.deletedColumn]: this.deletedValue,
-                    };
-                    if (this.updatedAtColumn) {
-                        patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                const batch = [];
+                while (i < operations.length &&
+                    operations[i].operation === 'DELETE' &&
+                    operations[i].tableName === op.tableName) {
+                    batch.push(operations[i]);
+                    i++;
+                }
+                const patch = {
+                    [this.deletedColumn]: this.deletedValue,
+                };
+                if (this.updatedAtColumn) {
+                    patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                }
+                if (batch.length === 1) {
+                    try {
+                        const { error } = await client
+                            .from(op.tableName)
+                            .update(patch)
+                            .eq(this.primaryKey, op.rowId);
+                        if (error) {
+                            const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'DELETE' });
+                            this.logger.error(msg);
+                            failedIds.push(op.id);
+                            errors[op.id] = msg;
+                        }
+                        else {
+                            successfulIds.push(op.id);
+                        }
                     }
-                    const { error } = await client
-                        .from(op.tableName)
-                        .update(patch)
-                        .eq(this.primaryKey, op.rowId);
-                    if (error) {
-                        const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'DELETE' });
+                    catch (err) {
+                        const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'DELETE' });
                         this.logger.error(msg);
                         failedIds.push(op.id);
                         errors[op.id] = msg;
                     }
-                    else {
-                        successfulIds.push(op.id);
-                    }
                 }
-                catch (err) {
-                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'DELETE' });
-                    this.logger.error(msg);
-                    failedIds.push(op.id);
-                    errors[op.id] = msg;
+                else {
+                    // Bulk soft-delete using .in() to collapse N round-trips into 1
+                    const rowIds = batch.map((item) => item.rowId);
+                    try {
+                        const { error } = await client
+                            .from(op.tableName)
+                            .update(patch)
+                            .in(this.primaryKey, rowIds);
+                        if (!error) {
+                            for (const item of batch)
+                                successfulIds.push(item.id);
+                        }
+                        else {
+                            // Fallback to individual updates if .in() fails
+                            for (const item of batch) {
+                                try {
+                                    const { error: singleErr } = await client
+                                        .from(op.tableName)
+                                        .update(patch)
+                                        .eq(this.primaryKey, item.rowId);
+                                    if (singleErr) {
+                                        const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'DELETE' });
+                                        failedIds.push(item.id);
+                                        errors[item.id] = msg;
+                                    }
+                                    else {
+                                        successfulIds.push(item.id);
+                                    }
+                                }
+                                catch (singleErr) {
+                                    const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'DELETE' });
+                                    failedIds.push(item.id);
+                                    errors[item.id] = msg;
+                                }
+                            }
+                        }
+                    }
+                    catch {
+                        for (const item of batch)
+                            failedIds.push(item.id);
+                    }
                 }
-                i++;
                 continue;
             }
-            // Handle UPDATE
+            // Batch consecutive UPDATEs for the same table
             if (op.operation === 'UPDATE') {
-                try {
-                    const patch = {
-                        ...(op.payload || {}),
-                        [this.deletedColumn]: false,
-                    };
-                    if (this.updatedAtColumn) {
-                        patch[this.updatedAtColumn] = new Date(op.timestamp).toISOString();
+                const batch = [];
+                while (i < operations.length &&
+                    operations[i].operation === 'UPDATE' &&
+                    operations[i].tableName === op.tableName) {
+                    batch.push(operations[i]);
+                    i++;
+                }
+                if (batch.length === 1) {
+                    const item = batch[0];
+                    try {
+                        const patch = this.buildRowData(item);
+                        const { error, data } = await client
+                            .from(op.tableName)
+                            .update(patch)
+                            .eq(this.primaryKey, item.rowId)
+                            .select(this.primaryKey);
+                        if (error) {
+                            const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'UPDATE' });
+                            this.logger.error(msg);
+                            failedIds.push(item.id);
+                            errors[item.id] = msg;
+                        }
+                        else if (!data || data.length === 0) {
+                            const { error: upsertErr } = await client.from(op.tableName).upsert(patch);
+                            if (upsertErr) {
+                                const msg = (0, logger_js_1.formatSupabaseError)(upsertErr, { table: op.tableName, operation: 'UPSERT_FALLBACK' });
+                                this.logger.error(msg);
+                                failedIds.push(item.id);
+                                errors[item.id] = msg;
+                            }
+                            else {
+                                successfulIds.push(item.id);
+                            }
+                        }
+                        else {
+                            successfulIds.push(item.id);
+                        }
                     }
-                    const { error, data } = await client
-                        .from(op.tableName)
-                        .update(patch)
-                        .eq(this.primaryKey, op.rowId)
-                        .select(this.primaryKey);
-                    if (error) {
-                        const msg = (0, logger_js_1.formatSupabaseError)(error, { table: op.tableName, operation: 'UPDATE' });
+                    catch (err) {
+                        const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'UPDATE' });
                         this.logger.error(msg);
-                        failedIds.push(op.id);
-                        errors[op.id] = msg;
+                        failedIds.push(item.id);
+                        errors[item.id] = msg;
                     }
-                    else if (!data || data.length === 0) {
-                        // If row did not exist remotely, fallback to upsert
-                        const rowData = {
-                            ...patch,
-                            [this.primaryKey]: op.rowId,
-                        };
-                        const { error: upsertErr } = await client.from(op.tableName).upsert(rowData);
-                        if (upsertErr) {
-                            const msg = (0, logger_js_1.formatSupabaseError)(upsertErr, { table: op.tableName, operation: 'UPSERT_FALLBACK' });
-                            this.logger.error(msg);
-                            failedIds.push(op.id);
-                            errors[op.id] = msg;
+                }
+                else {
+                    // Bulk upsert for multiple consecutive updates (merges fields by primaryKey in 1 HTTP call)
+                    const rows = batch.map((item) => this.buildRowData(item));
+                    try {
+                        const { error } = await client.from(op.tableName).upsert(rows);
+                        if (!error) {
+                            for (const item of batch)
+                                successfulIds.push(item.id);
                         }
                         else {
-                            successfulIds.push(op.id);
+                            // Fallback to individual updates if bulk upsert has a schema conflict
+                            for (const item of batch) {
+                                try {
+                                    const singleRow = this.buildRowData(item);
+                                    const { error: singleErr } = await client.from(op.tableName).upsert(singleRow);
+                                    if (singleErr) {
+                                        const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'UPDATE' });
+                                        failedIds.push(item.id);
+                                        errors[item.id] = msg;
+                                    }
+                                    else {
+                                        successfulIds.push(item.id);
+                                    }
+                                }
+                                catch (singleErr) {
+                                    const msg = (0, logger_js_1.formatSupabaseError)(singleErr, { table: op.tableName, operation: 'UPDATE' });
+                                    failedIds.push(item.id);
+                                    errors[item.id] = msg;
+                                }
+                            }
                         }
                     }
-                    else {
-                        successfulIds.push(op.id);
+                    catch {
+                        for (const item of batch) {
+                            failedIds.push(item.id);
+                        }
                     }
                 }
-                catch (err) {
-                    const msg = (0, logger_js_1.formatSupabaseError)(err, { table: op.tableName, operation: 'UPDATE' });
-                    this.logger.error(msg);
-                    failedIds.push(op.id);
-                    errors[op.id] = msg;
-                }
-                i++;
                 continue;
             }
             i++;
@@ -438,6 +513,20 @@ class SupabaseRemoteAdapter {
             changes,
         };
     }
+    /**
+     * Formats a row payload for remote Supabase storage (adds primaryKey, deleted: false, updated_at).
+     */
+    buildRowData(item) {
+        const row = {
+            ...(item.payload || {}),
+            [this.primaryKey]: item.rowId,
+            [this.deletedColumn]: false,
+        };
+        if (this.updatedAtColumn && !row[this.updatedAtColumn]) {
+            row[this.updatedAtColumn] = new Date(item.timestamp).toISOString();
+        }
+        return row;
+    }
     /**
      * Helper to determine if a record represents a soft delete.
      */
@@ -454,6 +543,7 @@ class SupabaseRemoteAdapter {
     }
     /**
      * Subscribes to live realtime postgres_changes from Supabase.
+     * Batches rapid burst events in the same microtask turn into a single SQLite sync transaction.
      */
     subscribeToLiveChanges(callback) {
         this.activeLiveCallback = callback;
@@ -479,6 +569,23 @@ class SupabaseRemoteAdapter {
             };
         }
         const channel = client.channel(this.channelName);
+        let pendingLiveChanges = [];
+        let isScheduled = false;
+        const flushLiveChanges = () => {
+            isScheduled = false;
+            if (pendingLiveChanges.length === 0)
+                return;
+            const toSend = pendingLiveChanges;
+            pendingLiveChanges = [];
+            const maxTimestamp = Math.max(...toSend.map((c) => c.timestamp || 0), Date.now());
+            callback({
+                timestamp: maxTimestamp,
+                changes: toSend,
+            });
+        };
+        const scheduleFlush = typeof queueMicrotask === 'function'
+            ? queueMicrotask
+            : (fn) => setTimeout(fn, 0);
         for (const table of this.tables) {
             channel.on('postgres_changes', { event: '*', schema: this.schema, table }, (payload) => {
                 let op = 'UPDATE';
@@ -495,18 +602,17 @@ class SupabaseRemoteAdapter {
                 const timestamp = record[this.updatedAtColumn]
                     ? new Date(record[this.updatedAtColumn]).getTime()
                     : Date.now();
-                callback({
+                pendingLiveChanges.push({
+                    tableName: table,
+                    operation: finalOp,
+                    rowId,
+                    payload: finalOp === 'DELETE' ? null : record,
                     timestamp,
-                    changes: [
-                        {
-                            tableName: table,
-                            operation: finalOp,
-                            rowId,
-                            payload: finalOp === 'DELETE' ? null : record,
-                            timestamp,
-                        },
-                    ],
                 });
+                if (!isScheduled) {
+                    isScheduled = true;
+                    scheduleFlush(flushLiveChanges);
+                }
             });
         }
         channel.subscribe((status) => {
@@ -516,6 +622,7 @@ class SupabaseRemoteAdapter {
         });
         this.activeChannel = channel;
         return () => {
+            flushLiveChanges();
             this.activeLiveCallback = undefined;
             this.destroy();
         };

package/dist/core/client.d.ts

@@ -81,7 +81,7 @@ export declare class LocalFirstClient {
      * Writes a mutation to the outbox table, optionally coalescing with existing PENDING records for the same row.
      * Returns the affected outboxId, or undefined if an offline INSERT was deleted offline before pushing.
      */
-    recordOutboxMutation(tx: LocalTransaction, tableName: string, rowId: string, operation: SyncOp, payload: Record<string, any> | null, timestamp: number): Promise<string | undefined>;
+    recordOutboxMutation(tx: LocalTransaction, tableName: string, rowId: string, operation: SyncOp, payload: Record<string, any> | null, timestamp: number, pendingOutboxMap?: Map<string, OutboxRecord>): Promise<string | undefined>;
     /**
      * Initializes the client: creates sync_outbox schema, ensures autoSchema tables if enabled,
      * applies migrations, and optionally starts automatic sync. Concurrent/repeated calls
@@ -212,14 +212,6 @@ export declare class LocalFirstClient {
     findById<T = any>(tableName: string, id: string, options?: {
         includeDeleted?: boolean;
     }): Promise<T | null>;
-    /**
-     * Finds multiple records by primary keys in a single batched SQL query.
-     * Eliminates the N-roundtrip bridge overhead of multiple findById calls.
-     * Automatically omits soft-deleted records unless includeDeleted: true.
-     *
-     * Example:
-     * const tenants = await client.findByIds('tenants', ['ten-1', 'ten-2', 'ten-3']);
-     */
     findByIds<T = any>(tableName: string, ids: string[], options?: {
         includeDeleted?: boolean;
     }): Promise<T[]>;