fix(electric): combine cursor expressions into single requestSnapshot

Instead of making two separate requestSnapshot calls (one for whereFrom,
one for whereCurrent), combine them using OR into a single request.
This avoids potential issues with multiple sequential snapshot requests
that were causing timeouts in CI.

The combined expression (whereFrom OR whereCurrent) matches the original
behavior where cursor was combined with the where clause.

Author: samwillis

packages/electric-db-collection/src/electric.ts

@@ -6,7 +6,7 @@ import {
 } from "@electric-sql/client"
 import { Store } from "@tanstack/store"
 import DebugModule from "debug"
-import { DeduplicatedLoadSubset, and } from "@tanstack/db"
+import { DeduplicatedLoadSubset, and, or } from "@tanstack/db"
 import {
   ExpectedNumberInAwaitTxIdError,
   StreamAbortedError,
@@ -393,38 +393,24 @@ function createLoadSubsetDedupe<T extends Row<unknown>>({
       const { cursor, where, orderBy, limit } = opts
 
       if (cursor) {
-        // Make sequential requests for cursor-based pagination
-        // Note: requests are sequential to avoid potential issues with concurrent snapshots
-
-        // Request 1: Rows matching whereFrom (rows > cursor, with limit)
-        // Combine main where with cursor.whereFrom
-        const whereFromOpts: LoadSubsetOptions = {
-          where: where ? and(where, cursor.whereFrom) : cursor.whereFrom,
+        // Combine whereFrom and whereCurrent into a single request using OR
+        // This gets: (rows > cursor) OR (rows = cursor for ties)
+        // Using a single request avoids potential issues with multiple sequential snapshots
+        const combinedCursor = or(cursor.whereFrom, cursor.whereCurrent)
+        const cursorOpts: LoadSubsetOptions = {
+          where: where ? and(where, combinedCursor) : combinedCursor,
           orderBy,
+          // Note: limit applies to combined result, which may include ties
+          // This matches the original behavior where cursor was combined with where
           limit,
         }
-        const whereFromParams = compileSQL<T>(whereFromOpts)
-
-        debug(
-          `${collectionId ? `[${collectionId}] ` : ``}Requesting cursor.whereFrom snapshot (with limit ${limit})`
-        )
-
-        await stream.requestSnapshot(whereFromParams)
-
-        // Request 2: All rows matching whereCurrent (ties at boundary, no limit)
-        // Combine main where with cursor.whereCurrent
-        const whereCurrentOpts: LoadSubsetOptions = {
-          where: where ? and(where, cursor.whereCurrent) : cursor.whereCurrent,
-          orderBy,
-          // No limit - get all ties
-        }
-        const whereCurrentParams = compileSQL<T>(whereCurrentOpts)
+        const cursorParams = compileSQL<T>(cursorOpts)
 
         debug(
-          `${collectionId ? `[${collectionId}] ` : ``}Requesting cursor.whereCurrent snapshot (all ties)`
+          `${collectionId ? `[${collectionId}] ` : ``}Requesting cursor snapshot (whereFrom OR whereCurrent, limit ${limit})`
         )
 
-        await stream.requestSnapshot(whereCurrentParams)
+        await stream.requestSnapshot(cursorParams)
       } else {
         // No cursor - standard single request
         const snapshotParams = compileSQL<T>(opts)

packages/electric-db-collection/tests/electric-live-query.test.ts

@@ -1198,8 +1198,8 @@ describe(`Electric Collection - loadSubset deduplication`, () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     // The existing live query re-requests its data after truncate
-    // After must-refetch, the query requests data again (1 initial + 2 after truncate)
-    expect(mockRequestSnapshot).toHaveBeenCalledTimes(3)
+    // After must-refetch, the query requests data again (1 initial + 1 after truncate)
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(2)
 
     // Create the same live query again after reset
     // This should NOT be deduped because the reset cleared the deduplication state,
@@ -1218,8 +1218,8 @@ describe(`Electric Collection - loadSubset deduplication`, () => {
     await new Promise((resolve) => setTimeout(resolve, 0))
 
     // Should have more calls - the different query triggered a new request
-    // 1 initial + 2 after must-refetch + 1 for new query = 4
-    expect(mockRequestSnapshot).toHaveBeenCalledTimes(4)
+    // 1 initial + 1 after must-refetch + 1 for new query = 3
+    expect(mockRequestSnapshot).toHaveBeenCalledTimes(3)
   })
 
   it(`should deduplicate unlimited queries regardless of orderBy`, async () => {