@jcbuisson/express-x-client 3.1.11 → 3.1.13

package/CLAUDE.md

@@ -35,7 +35,7 @@ Enriches `app` with offline-first IndexedDB CRUD via Dexie. Call `app.createOffl
 This plugin also adds three dynamic attributes to `app`:
 - `app.isConnected` — boolean, updated on socket connect/disconnect
 - `app.connectedDate` — `Date` of the last connection, or `null`
-- `app.disconnectedDate` — `Date` of the last disconnection, or `null` (used as `cutoffDate` for sync)
+- `app.disconnectedDate` — `Date` of the last disconnection, or `null`
 
 Each model maintains three Dexie stores under the same DB name:
 - `values` — the actual records (indexed on `uid`, `__deleted__`)
@@ -47,7 +47,7 @@ Each model maintains three Dexie stores under the same DB name:
 
 **Optimistic writes**: `create`, `update`, `remove` write to IndexedDB immediately, then call the server service method. On server error they roll back the local change.
 
-**Sync on reconnect**: When the socket reconnects, every registered model calls `synchronizeAll`, which iterates its `whereList` and calls the server's `sync.go(modelName, where, cutoffDate, clientMetadataDict)` service. The response contains five buckets (`addClient`, `updateClient`, `deleteClient`, `addDatabase`, `updateDatabase`) that are applied in order.
+**Sync on reconnect**: When the socket reconnects, every registered model calls `synchronizeAll`, which iterates its `whereList` and calls the server's `sync.go(modelName, where, clientMetadataDict)` service. The response contains five buckets (`addClient`, `updateClient`, `deleteClient`, `addDatabase`, `updateDatabase`) that are applied in order.
 
 **Real-time observables**: `getObservable(where)` returns an RxJS `Observable` backed by Dexie's `liveQuery`. It also registers the `where` in `whereList` and triggers a sync if it is a new, unregistered filter. Vue component lifecycle cleanup is handled by `tryOnScopeDispose`.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x-client",
-  "version": "3.1.11",
+  "version": "3.1.13",
   "type": "module",
   "description": "Client library for ExpressX framework",
   "main": "src/client.mts",

package/src/client.mts

@@ -184,6 +184,8 @@ export function offlinePlugin(app) {
 
       const dbName = modelName;
       const db = getOrCreateDB(dbName, fields);
+      const synchronizedWhereKeys = new Set();
+      const synchronizeWherePromises = new Map();
 
       const reset = async () => {
          console.log('reset', modelName);
@@ -231,10 +233,16 @@ export function offlinePlugin(app) {
          // optimistic update
          const now = new Date()
          await db.values.add({ uid, ...data })
-         await db.metadata.add({ uid, created_at: now })
+         await db.metadata.add({ uid, created_at: now, __dirty__: true })
          // execute on server, asynchronously, if connection is active
          if (app.isConnected) {
             app.service(modelName).createWithMeta(uid, data, now)
+            .then(async result => {
+               const [value, meta] = Array.isArray(result) ? result : []
+               if (value?.uid) await db.values.put(value)
+               if (meta?.uid) await db.metadata.put({ ...meta, __dirty__: false })
+               else await db.metadata.update(uid, { __dirty__: false })
+            })
             .catch(async err => {
                console.log(`*** err sync ${modelName} create`, err)
                // rollback
@@ -251,10 +259,16 @@ export function offlinePlugin(app) {
          // optimistic update of cache
          const now = new Date()
          await db.values.update(uid, data)
-         await db.metadata.update(uid, { updated_at: now })
+         await db.metadata.update(uid, { updated_at: now, __dirty__: true })
          // execute on server, asynchronously, if connection is active
          if (app.isConnected) {
             app.service(modelName).updateWithMeta(uid, data, now)
+            .then(async result => {
+               const [value, meta] = Array.isArray(result) ? result : []
+               if (value?.uid) await db.values.put(value)
+               if (meta?.uid) await db.metadata.put({ ...meta, __dirty__: false })
+               else await db.metadata.update(uid, { __dirty__: false })
+            })
             .catch(async err => {
                console.log(`*** err sync ${modelName} update`, err)
                // rollback
@@ -264,7 +278,10 @@ export function offlinePlugin(app) {
                // Restoring the full previousMetadata snapshot would overwrite any
                // deleted_at that remove() set while the socket round-trip was in flight,
                // silently un-deleting the record.
-               await db.metadata.update(uid, { updated_at: previousMetadata.updated_at ?? null })
+               await db.metadata.update(uid, {
+                  updated_at: previousMetadata.updated_at ?? null,
+                  __dirty__: previousMetadata.__dirty__ ?? false,
+               })
             })
          }
          return await db.values.get(uid)
@@ -274,15 +291,20 @@ export function offlinePlugin(app) {
          const deleted_at = new Date()
          // optimistic delete in cache
          await db.values.update(uid, { __deleted__: true })
-         await db.metadata.update(uid, { deleted_at })
+         await db.metadata.update(uid, { deleted_at, __dirty__: true })
          // and in database, if connected
          if (app.isConnected) {
             app.service(modelName).deleteWithMeta(uid, deleted_at)
+            .then(async result => {
+               const [, meta] = Array.isArray(result) ? result : []
+               if (meta?.uid) await db.metadata.put({ ...meta, __dirty__: false })
+               else await db.metadata.update(uid, { __dirty__: false })
+            })
             .catch(async err => {
                console.log(`*** err sync ${modelName} remove`, err)
                // rollback
                await db.values.update(uid, { __deleted__: null })
-               await db.metadata.update(uid, { deleted_at: null })
+               await db.metadata.update(uid, { deleted_at: null, __dirty__: false })
             })
          }
       }
@@ -322,8 +344,9 @@ export function offlinePlugin(app) {
          //   behavior as before.
          return defer(() => {
             const ready = addSynchroWhere(where).then((isNew: boolean) => {
-               if (isNew && app.isConnected) {
-                  return synchronize(modelName, db.values, db.metadata, where, app.disconnectedDate)
+               const whereKey = stringifyWithSortedKeys(where)
+               if (app.isConnected && (isNew || !synchronizedWhereKeys.has(whereKey))) {
+                  return synchronizeWhere(where)
                }
             })
             return from(ready).pipe(switchMap(() => liveQuery$))
@@ -341,11 +364,27 @@ export function offlinePlugin(app) {
       function removeSynchroWhere(where: object) {
          console.log('removeSynchroWhere', dbName, modelName, where)
          count -= 1
+         synchronizedWhereKeys.delete(stringifyWithSortedKeys(where))
          return removeSynchroDBWhere(where, db.whereList)
       }
 
       async function synchronizeAll() {
-         await synchronizeModelWhereList(modelName, db.values, db.metadata, app.disconnectedDate, db.whereList)
+         await synchronizeModelWhereList(modelName, db.values, db.metadata, db.whereList, synchronizeWhere)
+      }
+
+      async function synchronizeWhere(where) {
+         const whereKey = stringifyWithSortedKeys(where)
+         if (!synchronizeWherePromises.has(whereKey)) {
+            const promise = synchronize(modelName, db.values, db.metadata, where)
+               .then(() => {
+                  synchronizedWhereKeys.add(whereKey)
+               })
+               .finally(() => {
+                  synchronizeWherePromises.delete(whereKey)
+               })
+            synchronizeWherePromises.set(whereKey, promise)
+         }
+         return synchronizeWherePromises.get(whereKey)
       }
 
       // Automatically clean up when the component using this composable unmounts
@@ -369,12 +408,16 @@ export function offlinePlugin(app) {
       }
    }
 
+   let hasConnected = false
+
    app.addConnectListener(async (_socket) => {
       app.connectedDate = new Date()
       console.log('onConnect', app.connectedDate)
       app.isConnected = true
       const disconnectedDate = app.disconnectedDate
-      if (disconnectedDate) {
+      const isInitialConnect = !hasConnected
+      hasConnected = true
+      if (disconnectedDate || isInitialConnect) {
          const results = await Promise.allSettled(modelSyncFunctions.map(sync => sync()))
          const failures = results.filter(result => result.status === 'rejected')
          if (failures.length > 0) {
@@ -396,7 +439,7 @@ export function offlinePlugin(app) {
    const mutex = new Mutex()
 
    // ex: where = { uid: 'azer' }
-   async function synchronize(modelName, idbValues, idbMetadata, where, cutoffDate) {
+   async function synchronize(modelName, idbValues, idbMetadata, where) {
       await mutex.acquire()
       console.log('synchronize', modelName, where)
 
@@ -416,10 +459,16 @@ export function offlinePlugin(app) {
                clientMetadataDict[value.uid] = {}
             }
          }
+         const dirtyMetadataList = await idbMetadata.filter(metadata => metadata.__dirty__).toArray()
+         for (const metadata of dirtyMetadataList) {
+            if (metadata.uid in clientMetadataDict) continue
+            const value = await idbValues.get(metadata.uid)
+            if (value || metadata.deleted_at) clientMetadataDict[metadata.uid] = metadata
+         }
 
          // call sync service on `where` perimeter
          const { addClient, updateClient, deleteClient, addDatabase, updateDatabase } =
-            await app.service('sync').go(modelName, where, cutoffDate, clientMetadataDict)
+            await app.service('sync').go(modelName, where, clientMetadataDict)
          console.log('-> service.sync', modelName, where, addClient, updateClient, deleteClient, addDatabase, updateDatabase)
 
          // 1- add missing elements in indexedDB cache
@@ -435,7 +484,7 @@ export function offlinePlugin(app) {
                   // add() would throw ConstraintError and abort the entire transaction,
                   // silently dropping every other addClient record in the batch.
                   await idbValues.put(value)
-                  await idbMetadata.put(metaData)
+                  await idbMetadata.put({ ...metaData, __dirty__: false })
                }
             })
          }
@@ -453,7 +502,7 @@ export function offlinePlugin(app) {
             const value = { ...elt }
             delete value.__deleted__
             await idbValues.put(value)
-            await idbMetadata.put({ uid: elt.uid, ...serverMeta })
+            await idbMetadata.put({ uid: elt.uid, ...serverMeta, __dirty__: false })
          }
 
          // 4- create elements of `addDatabase` with full data from cache
@@ -468,7 +517,10 @@ export function offlinePlugin(app) {
             delete fullValue.uid
             delete fullValue.__deleted__
             try {
-               await app.service(modelName).createWithMeta(elt.uid, fullValue, elt.created_at)
+               const result = await app.service(modelName).createWithMeta(elt.uid, fullValue, elt.created_at)
+               const serverMeta = Array.isArray(result) ? result[1] : null
+               if (serverMeta?.uid) await idbMetadata.put({ ...serverMeta, __dirty__: false })
+               else await idbMetadata.update(elt.uid, { __dirty__: false })
             } catch(err) {
                console.log("*** err sync user addDatabase", err, elt.uid, fullValue, elt.created_at)
                // rollback
@@ -485,7 +537,10 @@ export function offlinePlugin(app) {
             delete fullValue.uid
             delete fullValue.__deleted__
             try {
-               await app.service(modelName).updateWithMeta(elt.uid, fullValue, elt.updated_at)
+               const result = await app.service(modelName).updateWithMeta(elt.uid, fullValue, elt.updated_at)
+               const serverMeta = Array.isArray(result) ? result[1] : null
+               if (serverMeta?.uid) await idbMetadata.put({ ...serverMeta, __dirty__: false })
+               else await idbMetadata.update(elt.uid, { __dirty__: false })
             } catch(err) {
                console.log("*** err sync user updateDatabase", err)
                // Leave client's local version intact; it will be retried on the next sync.
@@ -550,10 +605,11 @@ export function offlinePlugin(app) {
       }
    }
 
-   async function synchronizeModelWhereList(modelName, idbValues, idbMetadata, cutoffDate, whereDb) {
+   async function synchronizeModelWhereList(modelName, idbValues, idbMetadata, whereDb, syncWhere = null) {
       const whereList = await getWhereList(whereDb)
       for (const where of whereList) {
-         await synchronize(modelName, idbValues, idbMetadata, where, cutoffDate)
+         if (syncWhere) await syncWhere(where)
+         else await synchronize(modelName, idbValues, idbMetadata, where)
       }
    }