@jcbuisson/express-x-plugins 5.0.3 → 5.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x-plugins",
-  "version": "5.0.3",
+  "version": "5.0.4",
   "description": "Plugins for express-x",
   "type": "module",
   "main": "./src/electric-server-plugin.mjs",

package/src/electric-offline-model.mjs

@@ -158,20 +158,23 @@ export function createOfflineElectricModel({ db, service, modelName, url, primar
 
    async function reconcileSnapshot(rows) {
       await retryLeader(() => db.transaction(async tx => {
-         for (const row of rows) {
-            const id = String(row[primaryKey])
-            if (row.version != null) {
-               await tx.query(`DELETE FROM electric_mutation_queue
-                  WHERE model_name = $1 AND row_id = $2 AND acknowledged_version <= $3::numeric`,
-               [modelName, id, String(row.version)])
-            }
-            if (row.deleted) continue
-            await tx.query(`INSERT INTO electric_local_rows (model_name, row_id, data)
-               SELECT $1, $2, $3::jsonb WHERE NOT EXISTS
-                  (SELECT 1 FROM electric_mutation_queue WHERE model_name = $1 AND row_id = $2)
-               ON CONFLICT (model_name, row_id) DO UPDATE SET data = EXCLUDED.data`,
-            [modelName, id, json(row)])
-         }
+         // Send the snapshot once instead of making two worker round trips per row.
+         const incoming = json(rows)
+         await tx.query(`DELETE FROM electric_mutation_queue AS pending
+            USING jsonb_array_elements($2::jsonb) AS incoming(data)
+            WHERE pending.model_name = $1
+              AND pending.row_id = incoming.data->>$3
+              AND pending.acknowledged_version <= (incoming.data->>'version')::numeric`,
+         [modelName, incoming, primaryKey])
+         await tx.query(`INSERT INTO electric_local_rows (model_name, row_id, data)
+            SELECT $1, incoming.data->>$3, incoming.data
+            FROM jsonb_array_elements($2::jsonb) AS incoming(data)
+            WHERE NOT COALESCE((incoming.data->>'deleted')::boolean, false)
+              AND NOT EXISTS (SELECT 1 FROM electric_mutation_queue AS pending
+                 WHERE pending.model_name = $1 AND pending.row_id = incoming.data->>$3)
+            ON CONFLICT (model_name, row_id) DO UPDATE SET data = EXCLUDED.data
+            WHERE electric_local_rows.data IS DISTINCT FROM EXCLUDED.data`,
+         [modelName, incoming, primaryKey])
          const activeIds = rows.filter(row => !row.deleted).map(row => String(row[primaryKey]))
          await tx.query(`DELETE FROM electric_local_rows AS local
             WHERE local.model_name = $1 AND NOT (local.row_id = ANY($2::text[]))

package/test/electric-offline-model.test.mjs

@@ -66,3 +66,43 @@ test('offline writes stay local until the acknowledged Electric version arrives'
       await db.close()
    }
 })
+
+test('large snapshots use three queries and preserve bigint versions and tombstones', async () => {
+   const db = new PGlite()
+   const { createOfflineElectricModel } = await import('../src/electric-offline-model.mjs')
+   let queries = 0
+   const countedDb = {
+      exec: (...args) => db.exec(...args),
+      query: (...args) => db.query(...args),
+      transaction: callback => db.transaction(tx => callback({
+         query: (...args) => { queries++; return tx.query(...args) },
+      })),
+   }
+   const model = createOfflineElectricModel({
+      db: countedDb, service: {}, modelName: 'range', primaryKey: 'uid',
+      ShapeStreamClass: Stream, ShapeClass: Shape, ownsSync: true,
+      network: { onLine: true }, retryMs: 60_000,
+   })
+   try {
+      await model.prepare()
+      model.start()
+      await model.waitForIdle()
+      const rows = Array.from({ length: 100 }, () => ({
+         uid: crypto.randomUUID(), label: 'shared', version: '9007199254740993', deleted: false,
+      }))
+      Shape.current.emit({ rows })
+      await model.waitForIdle()
+      assert.equal(queries, 3)
+      assert.equal((await model.findMany()).length, 100)
+      assert.equal((await model.findMany())[0].version, '9007199254740993')
+      queries = 0
+      Shape.current.emit({ rows: [{ ...rows[0], deleted: true }, { ...rows[1], label: 'changed' }] })
+      await model.waitForIdle()
+      assert.equal(queries, 3)
+      assert.deepEqual(await model.findMany(), [{ ...rows[1], label: 'changed' }])
+   } finally {
+      model.stop()
+      await model.waitForIdle()
+      await db.close()
+   }
+})