@jcbuisson/express-x 3.1.11 → 3.1.12

package/CLAUDE.md

@@ -61,7 +61,7 @@ No build step — the source is run directly as ES modules.
 
 The sync system reconciles a client Dexie cache with a server database. The protocol:
 
-1. Client calls `sync.go(modelName, where, cutoffDate, clientMetadataDict)` with its local metadata snapshot.
+1. Client calls `sync.go(modelName, where, clientMetadataDict)` with its local metadata snapshot.
 2. Server computes diff using `computeSyncResult` (exported from `server.mjs`, pure function, no I/O).
 3. Server returns `{ addClient, updateClient, deleteClient, addDatabase, updateDatabase }`.
 4. Client applies each batch: puts addClient records into Dexie, deletes deleteClient, updates updateClient, then calls `createWithMeta`/`updateWithMeta` for addDatabase/updateDatabase.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "3.1.11",
+  "version": "3.1.12",
   "description": "",
   "type": "module",
   "main": "src/server.mjs",
@@ -30,7 +30,7 @@
   "devDependencies": {
     "@electric-sql/pglite": "^0.4.5",
     "@jcbuisson/express-x-client": "^3.1.11",
-    "@jcbuisson/express-x-drizzle": "^3.1.6",
+    "@jcbuisson/express-x-drizzle": "^3.1.11",
     "@vueuse/core": "^14.3.0",
     "dexie": "^4.4.2",
     "drizzle-orm": "^0.45.2",

package/test/offline.test.mjs

@@ -8,6 +8,7 @@ process.on('unhandledRejection', (reason, promise) => {
 import { test, describe, after } from 'node:test'
 import assert from 'node:assert/strict'
 import { io as ioc } from 'socket.io-client'
+import { firstValueFrom } from 'rxjs'
 import { PGlite } from '@electric-sql/pglite'
 import { drizzle } from 'drizzle-orm/pglite'
 import { pgTable, text, timestamp, integer } from 'drizzle-orm/pg-core'
@@ -350,7 +351,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       const { clientApp, cleanup } = await createTestContext(serverApp => {
          serverApp.createService('sync', {
             // Tell the client both u1 and u2 need to be pushed (client is newer for both)
-            go: async (mn, where, cutoff, clientMetadataDict) => ({
+            go: async (mn, where, clientMetadataDict) => ({
                addClient: [], updateClient: [], deleteClient: [], addDatabase: [],
                updateDatabase: [ clientMetadataDict['u1'], clientMetadataDict['u2'] ],
             }),
@@ -546,7 +547,7 @@ describe('Full offline-first client ↔ server protocol', () => {
             findMany: async () => [],
          })
          app.createService('sync', {
-            go: async (_modelName, _where, _cutoffDate, clientMetadataDict) => {
+            go: async (_modelName, _where, clientMetadataDict) => {
                if (slowSync) {
                   resolveSyncStarted()
                   await syncRelease
@@ -603,7 +604,7 @@ describe('Full offline-first client ↔ server protocol', () => {
       await reconnected
       await syncStarted
 
-      assert.ok(clientApp.disconnectedDate, 'disconnect cutoff should remain while reconnect sync is running')
+      assert.ok(clientApp.disconnectedDate, 'disconnect marker should remain while reconnect sync is running')
       assert.equal(serverRows.length, 0, 'offline row should not be pushed before sync is released')
 
       releaseSync()
@@ -613,7 +614,7 @@ describe('Full offline-first client ↔ server protocol', () => {
          await new Promise(resolve => setTimeout(resolve, 10))
       }
 
-      assert.equal(clientApp.disconnectedDate, null, 'disconnect cutoff should clear after reconnect sync completes')
+      assert.equal(clientApp.disconnectedDate, null, 'disconnect marker should clear after reconnect sync completes')
       assert.deepEqual(serverRows, [{ uid: 'reconnect-1', label: 'from reconnect' }])
 
       socket.disconnect()
@@ -1246,6 +1247,132 @@ describe('Full offline-first client ↔ server protocol', () => {
       }
    })
 
+   test('sync.go serializes overlapping where scopes on the server', async () => {
+      const modelName = `model${++dbCounter}`
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
+
+      await db.insert(modelTable).values({ uid: 'r1', label: 'x' })
+      await db.insert(metaTable).values({ uid: 'r1', created_at: T0 })
+
+      const serverApp = expressX({})
+      serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable])
+
+      const modelService = serverApp.service(modelName)
+      const originalFindMany = modelService.findMany
+      let releaseBroadFindMany
+      let broadFindManyEntered
+      let narrowFindManyEntered = false
+      const broadFindManyStarted = new Promise(resolve => { broadFindManyEntered = resolve })
+      const broadFindManyRelease = new Promise(resolve => { releaseBroadFindMany = resolve })
+
+      modelService.findMany = async (where) => {
+         if (Object.keys(where).length === 0) {
+            broadFindManyEntered()
+            await broadFindManyRelease
+         } else {
+            narrowFindManyEntered = true
+         }
+         return originalFindMany(where)
+      }
+
+      try {
+         const broadSync = serverApp.service('sync').go(modelName, {}, {})
+         await broadFindManyStarted
+
+         const narrowSync = serverApp.service('sync').go(modelName, { label: 'x' }, {})
+         await new Promise(resolve => setTimeout(resolve, 20))
+         assert.equal(narrowFindManyEntered, false, 'narrow overlapping sync must wait for broad sync')
+
+         releaseBroadFindMany()
+         await Promise.all([broadSync, narrowSync])
+         assert.equal(narrowFindManyEntered, true, 'narrow sync should run after broad sync releases')
+      } finally {
+         pglite.close()
+      }
+   })
+
+   test('getObservable syncs persisted where scopes on a new client session', async () => {
+      // If whereList was left in IndexedDB by a previous run, addSynchroDBWhere()
+      // returns false. getObservable() must still sync once for this app session;
+      // otherwise the first emission can be stale forever until a manual sync/reconnect.
+      const modelName = `model${++dbCounter}`
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
+
+      await db.insert(modelTable).values({ uid: 'r1', label: 'from-server' })
+      await db.insert(metaTable).values({ uid: 'r1', created_at: T0 })
+
+      const { clientApp, cleanup } = await createTestContext(
+         serverApp => serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable]),
+         { useOfflinePlugin: true },
+      )
+
+      try {
+         const model = clientApp.createOfflineModel(modelName, ['label'])
+         await model.db.whereList.add({ sortedjson: '{}' })
+
+         const rows = await firstValueFrom(model.getObservable({}))
+
+         assert.deepEqual(rows.map(row => row.uid), ['r1'])
+      } finally {
+         await cleanup()
+         pglite.close()
+      }
+   })
+
+   test('initial connect syncs scopes registered while the client started offline', async () => {
+      const modelName = `model${++dbCounter}`
+      const { pglite, db, metaTable, modelTable } = await createTestDb(modelName)
+
+      await db.insert(modelTable).values({ uid: 'r1', label: 'from-server' })
+      await db.insert(metaTable).values({ uid: 'r1', created_at: T0 })
+
+      const serverApp = expressX({})
+      serverApp.configure(drizzleOfflinePlugin, db, metaTable, [modelTable])
+      await new Promise(resolve => serverApp.httpServer.listen(0, resolve))
+      const port = serverApp.httpServer.address().port
+
+      const socket = ioc(`http://localhost:${port}`, {
+         transports: ['websocket'],
+         autoConnect: false,
+      })
+      const clientApp = createClient(socket, { debug: false })
+      offlinePlugin(clientApp)
+      const model = clientApp.createOfflineModel(modelName, ['label'])
+      let subscription
+
+      try {
+         await model.db.whereList.add({ sortedjson: '{}' })
+
+         const observedServerRow = new Promise((resolve, reject) => {
+            const timeout = setTimeout(() => reject(new Error('timed out waiting for synced row')), 1000)
+            subscription = model.getObservable({}).subscribe({
+               next: rows => {
+                  if (rows.some(row => row.uid === 'r1')) {
+                     clearTimeout(timeout)
+                     subscription.unsubscribe()
+                     resolve(rows)
+                  }
+               },
+               error: reject,
+            })
+         })
+
+         socket.connect()
+         await new Promise((resolve, reject) => {
+            socket.on('connect', resolve)
+            socket.on('connect_error', reject)
+         })
+
+         const rows = await observedServerRow
+         assert.deepEqual(rows.map(row => row.uid), ['r1'])
+      } finally {
+         if (subscription) subscription.unsubscribe()
+         socket.disconnect()
+         await new Promise(resolve => serverApp.io.close(resolve))
+         pglite.close()
+      }
+   })
+
    test('update() rollback clears stale updated_at from metadata', async () => {
       // Optimistic update sets updated_at = now in metadata before the server responds.
       // On rejection the rollback does db.metadata.update(uid, previousMetadata), but