@jcbuisson/express-x-drizzle 3.1.6 → 3.1.12

package/CLAUDE.md

@@ -24,6 +24,6 @@ The library exports one function: `drizzleOfflinePlugin(app, db, metadata, model
 
 1. **Per-model services** — For each table in `models`, registers an `express-x` service named after the table. Each service exposes: `findUnique`, `findMany`, `createWithMeta`, `updateWithMeta`, `deleteWithMeta`. All mutation methods write to both the model table and the `metadata` table inside a transaction, keeping timestamps in sync.
 
-2. **`sync` service** — Implements an offline-first reconciliation algorithm. The client sends its local metadata dictionary (`{ uid → { created_at, updated_at, deleted_at } }`) plus a `cutoffDate`. The server computes set intersections between client UIDs and database UIDs, then determines add/update/delete operations for both sides. A `Mutex` (from `express-x`) serializes concurrent sync calls globally. The return value tells the client which records to add, update, or delete locally, and which UIDs the client should push to the database with full data.
+2. **`sync` service** — Implements an offline-first reconciliation algorithm. The client sends its local metadata dictionary (`{ uid → { created_at, updated_at, deleted_at } }`). The server computes set intersections between client UIDs and database UIDs, then determines add/update/delete operations for both sides. An overlap-aware lock serializes sync calls whose `where` scopes can touch the same records. The return value tells the client which records to add, update, or delete locally, and which UIDs the client should push to the database with full data.
 
 **Key invariant:** The sync algorithm compares `updated_at` (falling back to `created_at`) timestamps to decide which side wins a conflict — the most recently updated side wins. Records marked `deleted_at` on the client trigger a soft-delete propagation to the database.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x-drizzle",
-  "version": "3.1.6",
+  "version": "3.1.12",
   "description": "Drizzle ORM plugins for express-x framework",
   "main": "src/drizzle-plugins.mjs",
   "type": "module",

package/src/drizzle-plugins.mjs

@@ -1,21 +1,10 @@
 import { and, eq, gt, gte, lt, lte, isNull, getTableName } from "drizzle-orm";
 
-import { Mutex, truncateString, computeSyncResult } from '@jcbuisson/express-x'
+import { truncateString, computeSyncResult } from '@jcbuisson/express-x'
 
 
 //////////////////////////       UTILITIES       //////////////////////////
 
-function stringifyWithSortedKeys(obj) {
-   return JSON.stringify(obj, (_, value) => {
-      if (value && typeof value === 'object' && !Array.isArray(value) && Object.prototype.toString.call(value) === '[object Object]') {
-         const sorted = {}
-         Object.keys(value).sort().forEach(k => { sorted[k] = value[k] })
-         return sorted
-      }
-      return value
-   })
-}
-
 function whereToDrizzleFilters(table, where) {
    const conditions = Object.entries(where)
       .filter(([_, value]) => value !== undefined)
@@ -35,8 +24,98 @@ function whereToDrizzleFilters(table, where) {
    return conditions.length ? and(...conditions) : undefined;
 }
 
+function isPlainObject(value) {
+   return value && typeof value === 'object' && !Array.isArray(value) && Object.prototype.toString.call(value) === '[object Object]'
+}
+
+function hasRangeOperator(value) {
+   return isPlainObject(value) && ['gte', 'gt', 'lte', 'lt'].some(key => key in value)
+}
+
+function valueWithinRange(value, range) {
+   if (value === null || value === undefined) return false
+   if ('gte' in range && value < range.gte) return false
+   if ('gt' in range && value <= range.gt) return false
+   if ('lte' in range && value > range.lte) return false
+   if ('lt' in range && value >= range.lt) return false
+   return true
+}
+
+function rangesOverlap(a, b) {
+   const lower = [
+      'gte' in a && { value: a.gte, inclusive: true },
+      'gt' in a && { value: a.gt, inclusive: false },
+      'gte' in b && { value: b.gte, inclusive: true },
+      'gt' in b && { value: b.gt, inclusive: false },
+   ].filter(Boolean).sort((x, y) => x.value === y.value ? Number(x.inclusive) - Number(y.inclusive) : x.value > y.value ? -1 : 1)[0]
+
+   const upper = [
+      'lte' in a && { value: a.lte, inclusive: true },
+      'lt' in a && { value: a.lt, inclusive: false },
+      'lte' in b && { value: b.lte, inclusive: true },
+      'lt' in b && { value: b.lt, inclusive: false },
+   ].filter(Boolean).sort((x, y) => x.value === y.value ? Number(x.inclusive) - Number(y.inclusive) : x.value < y.value ? -1 : 1)[0]
+
+   if (!lower || !upper) return true
+   if (lower.value < upper.value) return true
+   if (lower.value > upper.value) return false
+   return lower.inclusive && upper.inclusive
+}
+
+function constraintsOverlap(a, b) {
+   if (a === undefined || b === undefined) return true
+   if (a === null || b === null) return a === null && b === null
+
+   const aRange = hasRangeOperator(a)
+   const bRange = hasRangeOperator(b)
+
+   if (aRange && bRange) return rangesOverlap(a, b)
+   if (aRange) return valueWithinRange(b, a)
+   if (bRange) return valueWithinRange(a, b)
+   if (isPlainObject(a) || isPlainObject(b)) return true
+   return a === b
+}
+
+function whereScopesOverlap(a = {}, b = {}) {
+   const sharedKeys = Object.keys(a).filter(key => key in b)
+   for (const key of sharedKeys) {
+      if (!constraintsOverlap(a[key], b[key])) return false
+   }
+   return true
+}
+
+class OverlapLock {
+   constructor() {
+      this.active = []
+      this.queue = []
+   }
+
+   acquire(where) {
+      return new Promise(resolve => {
+         const entry = { where, resolve }
+         this.queue.push(entry)
+         this.pump()
+      })
+   }
 
-// DOIT FAIRE UN ROLLBACK EN CAS D'ERREUR SERVEUR (EX: ERREUR SÉMANTIQUE TYPE PB CLÉ ÉTRANGÈRE OU AUTRE)
+   pump() {
+      for (let i = 0; i < this.queue.length; i++) {
+         const entry = this.queue[i]
+         if (this.active.some(active => whereScopesOverlap(active.where, entry.where))) continue
+         this.queue.splice(i, 1)
+         i -= 1
+         this.active.push(entry)
+         entry.resolve(() => {
+            this.active = this.active.filter(active => active !== entry)
+            this.pump()
+         })
+      }
+   }
+
+   get idle() {
+      return this.active.length === 0 && this.queue.length === 0
+   }
+}
 
 
 //////////////////////////       DRIZZLE OFFLINE PLUGIN       //////////////////////////
@@ -109,22 +188,20 @@ export function drizzleOfflinePlugin(app, db, metadata, models) {
       })
    }
 
-   const syncMutexes = new Map()
+   const syncLocks = new Map()
 
    // add a synchronization service
    app.createService('sync', {
 
-      // CUTOFFDATE INUTILE ?
-      go: async (modelName, where, cutoffDate, clientMetadataDict) => {
+      go: async (modelName, where, clientMetadataDict) => {
 
-         // get or create a mutex specific to modelName + where
-         const mutexKey = `${modelName}:${stringifyWithSortedKeys(where)}`
-         if (!syncMutexes.has(mutexKey)) syncMutexes.set(mutexKey, new Mutex())
-         // acquire it: no other sync operation from another client on this model+where can occur in parallel
-         await syncMutexes.get(mutexKey).acquire()
+         // overlap-aware lock so independent scopes can still run in parallel, but overlapping where predicates do not
+         if (!syncLocks.has(modelName)) syncLocks.set(modelName, new OverlapLock())
+         const syncLock = syncLocks.get(modelName)
+         const releaseSyncLock = await syncLock.acquire(where)
 
          try {
-            console.log('>>>>> SYNC', modelName, where, cutoffDate)
+            console.log('>>>>> SYNC', modelName, where)
             const databaseService = app.service(modelName)
       
             // STEP1: get existing database `where` values and build a dictionary
@@ -166,10 +243,8 @@ export function drizzleOfflinePlugin(app, db, metadata, models) {
             console.log('*** err sync', err)
             throw err
          } finally {
-            const mutex = syncMutexes.get(mutexKey)
-            mutex.release()
-            // Remove idle mutexes so the Map stays bounded for dynamic where clauses.
-            if (mutex.queue.length === 0) syncMutexes.delete(mutexKey)
+            releaseSyncLock()
+            if (syncLock.idle) syncLocks.delete(modelName)
          }
       },
    })