@jcbuisson/express-x 3.1.0 → 3.1.1

package/CLAUDE.md

@@ -40,10 +40,9 @@ No build step — the source is run directly as ES modules.
 
 ### Source Files
 - `src/server.mjs` — complete server-side framework; all exports live here.
-- `src/client.mjs` — local mirror of the client-side library (`@jcbuisson/express-x-client`). Used for development and to track changes before publishing.
 
 ### Related Packages (also authored here, published separately)
-- **`@jcbuisson/express-x-client`** (`node_modules/@jcbuisson/express-x-client/src/client.mts`) — published client library: `createClient`, `offlinePlugin`, `Mutex`, `wherePredicate`. TypeScript source consumed directly via `tsx`. `src/client.mjs` is the local development counterpart.
+- **`@jcbuisson/express-x-client`** (`node_modules/@jcbuisson/express-x-client/src/client.mts`) — published client library: `createClient`, `offlinePlugin`, `Mutex`, `wherePredicate`.
 - **`@jcbuisson/express-x-drizzle`** (`node_modules/@jcbuisson/express-x-drizzle/src/drizzle-plugins.mjs`) — Drizzle ORM offline plugin. The installed version may lag behind local development; tests wire it via `serverApp.configure(drizzleOfflinePlugin, ...)`.
 
 ### Core Concepts
@@ -56,7 +55,7 @@ No build step — the source is run directly as ES modules.
 
 4. **Channels & Pub/Sub**: Socket.io rooms. After a service method completes, `service.publishFunction(context)` returns channel names; the result is broadcast as `service-event` to all sockets in those rooms. Clients subscribe with `app.service(name).on(action, handler)`.
 
-5. **WebSocket Protocol**: Client calls `socket.timeout(ms).emitWithAck('client-request', { name, action, args })` → server handler receives `({ name, action, args }, ack)` and responds via `ack({ result })` or `ack({ error })`. Correlation is handled by Socket.io's built-in acknowledgment mechanism — no custom uid tracking.
+5. **WebSocket Protocol**: Client calls `socket.timeout(ms).emitWithAck('client-request', { name, action, args })` → server handler receives `({ name, action, args }, ack)` and responds via `ack({ result })` or `ack({ error })`. Correlation is handled by Socket.io's built-in acknowledgment mechanism.
 
 ### Offline Sync Architecture
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "3.1.0",
+  "version": "3.1.1",
   "description": "",
   "type": "module",
   "main": "src/server.mjs",

package/src/server.mjs

@@ -253,11 +253,11 @@ export function expressX(config) {
     * create a service `name` with given `methods`
     */
    function createService(name, methods) {
-      const service = {}
+      const service = { _name: name }
 
       for (const methodName in methods) {
          const method = methods[methodName]
-         if (! method instanceof Function) continue
+         if (!(method instanceof Function)) continue
 
          // `context` is the context of execution (transport type, connection, app)
          // `args` is the list of arguments of the method
@@ -442,7 +442,7 @@ export async function reloadPlugin(app) {
       roomCache[socket.id] = new Set(socket.rooms)
 
       if (alreadySavedData) dataCache[socket.id] = Object.assign(dataCache[socket.id], alreadySavedData)
-      if (alreadySavedRooms) roomCache[socket.id].add(alreadySavedRooms)
+      if (alreadySavedRooms) for (const room of alreadySavedRooms) roomCache[socket.id].add(room)
    })
 
    app.addConnectListener((socket) => {
@@ -474,194 +474,8 @@ export async function reloadPlugin(app) {
             toSocket.emit('cnx-transfer-ack', fromSocketId, toSocketId)
          } else {
             console.log(`*** CNX TRANSFER ERROR, ${fromSocketId} -> ${toSocketId}`)
-            toSocket.emit('cnx-transfer-error', fromSocketId, toSocketId)
+            if (toSocket) toSocket.emit('cnx-transfer-error', fromSocketId, toSocketId)
          }
       })
    })
 }
-
-
-//////////////////////////       OFFLINE PLUGIN       //////////////////////////
-
-const mutex = new Mutex()
-
-export function offlinePlugin(app, modelNames) {
-
-   const prisma = app.get('prisma');
-
-   if (!prisma.metadata) {
-      app.log('error', "A model named 'metadata' is expected in the prisma schema - see https://expressx.jcbuisson.dev/server-api.html#offline")
-      return
-   }
-
-   // add a database service for each model
-   for (const modelName of modelNames) {
-      const model = prisma[modelName];
-      
-      if (!model) {
-         app.log('error', `There is no model named '${modelName}}' in the prisma schema`)
-         return
-      }
-
-      app.createService(modelName, {
-
-         findUnique: model.findUnique,
-         findMany: model.findMany,
-         
-         createWithMeta: async (uid, data, created_at) => {
-            const [value, meta] = await prisma.$transaction([
-               model.create({ data: { uid, ...data } }),
-               prisma.metadata.create({ data: { uid, created_at } })
-            ])
-            return [value, meta]
-         },
-         
-         updateWithMeta: async (uid, data, updated_at) => {
-            const [value, meta] = await prisma.$transaction([
-               model.update({ where: { uid }, data }),
-               prisma.metadata.update({ where: { uid }, data: { updated_at } })
-            ])
-            return [value, meta]
-         },
-         
-         deleteWithMeta: async (uid, deleted_at) => {
-            const [value, meta] = await prisma.$transaction([
-               model.delete({ where: { uid } }),
-               prisma.metadata.update({ where: { uid }, data: { deleted_at } })
-            ])
-            return [value, meta]
-         },
-      })
-   }
-
-   // add a synchronization service
-   app.createService('sync', {
-
-      // AMÉLIORER : ne pas avoir une exclusion mutuelle globale, mais seulement par model/where
-      go: async (modelName, where, cutoffDate, clientMetadataDict) => {
-         await mutex.acquire()
-         try {
-            console.log('>>>>> SYNC', modelName, where, cutoffDate)
-            const databaseService = app.service(modelName)
-            const prisma = app.get('prisma')
-      
-            // STEP 1: get existing database `where` values
-            const databaseValues = await databaseService.findMany({ where })
-         
-            const databaseValuesDict = databaseValues.reduce((accu, value) => {
-               accu[value.uid] = value
-               return accu
-            }, {})
-            // console.log('clientMetadataDict', clientMetadataDict)
-            // console.log('databaseValuesDict', databaseValuesDict)
-         
-            // STEP 2: compute intersections between client and database uids
-            const onlyDatabaseIds = new Set()
-            const onlyClientIds = new Set()
-            const databaseAndClientIds = new Set()
-         
-            for (const uid in databaseValuesDict) {
-               if (uid in clientMetadataDict) {
-                  databaseAndClientIds.add(uid)
-               } else {
-                  onlyDatabaseIds.add(uid)
-               }
-            }
-         
-            for (const uid in clientMetadataDict) {
-               if (uid in databaseValuesDict) {
-                  databaseAndClientIds.add(uid)
-               } else {
-                  onlyClientIds.add(uid)
-               }
-            }
-            // console.log('onlyDatabaseIds', onlyDatabaseIds)
-            // console.log('onlyClientIds', onlyClientIds)
-            // console.log('databaseAndClientIds', databaseAndClientIds)
-         
-            // STEP 3: build add/update/delete sets
-            const addDatabase = []
-            const updateDatabase = []
-            const deleteDatabase = []
-         
-            const addClient = []
-            const updateClient = []
-            const deleteClient = []
-         
-            for (const uid of onlyDatabaseIds) {
-               const databaseValue = databaseValuesDict[uid]
-               let databaseMetaData = await prisma.metadata.findUnique({ where: { uid }})
-               if (!databaseMetaData) {
-                  console.log('no metadata - should not happen', modelName, where, uid)
-                  databaseMetaData = { uid, created_at: new Date() }
-               }
-               addClient.push([databaseValue, databaseMetaData])
-            }
-         
-            for (const uid of onlyClientIds) {
-               const clientMetaData = clientMetadataDict[uid]
-               if (clientMetaData.deleted_at) {
-                  deleteClient.push([uid, clientMetaData.deleted_at])
-               } else if (new Date(clientMetaData.created_at) > cutoffDate) {
-                  addDatabase.push(clientMetaData)
-               } else {
-                  // ???
-               }
-            }
-         
-            for (const uid of databaseAndClientIds) {
-               const databaseValue = databaseValuesDict[uid]
-               const clientMetaData = clientMetadataDict[uid]
-                  || { uid, created_at: new Date() } // should not happen
-               if (clientMetaData.deleted_at) {
-                  deleteDatabase.push(uid)
-                  deleteClient.push([uid, clientMetaData.deleted_at])
-               } else {
-                  const databaseMetaData = await prisma.metadata.findUnique({ where: { uid }})
-                     || { uid, created_at: new Date() } // should not happen
-                  const clientUpdatedAt = new Date(clientMetaData.updated_at || clientMetaData.created_at)
-                  const databaseUpdatedAt = new Date(databaseMetaData.updated_at || databaseMetaData.created_at)
-                  const dateDifference = clientUpdatedAt - databaseUpdatedAt
-                  // console.log('databaseMetaData', databaseMetaData, 'clientMetaData', clientMetaData, 'dateDifference', dateDifference)
-                  if (dateDifference > 0) {
-                     updateDatabase.push(clientMetaData)
-                  } else if (dateDifference < 0) {
-                     updateClient.push(databaseValue)
-                  }
-               }
-            }
-            console.log('addDatabase', truncateString(JSON.stringify(addDatabase)))
-            console.log('deleteDatabase', truncateString(JSON.stringify(deleteDatabase)))
-            console.log('updateDatabase', truncateString(JSON.stringify(updateDatabase)))
-         
-            console.log('addClient', truncateString(JSON.stringify(addClient)))
-            console.log('deleteClient', truncateString(JSON.stringify(deleteClient)))
-            console.log('updateClient', truncateString(JSON.stringify(updateClient)))
-         
-            // STEP4: execute database deletions
-            for (const uid of deleteDatabase) {
-               const clientMetaData = clientMetadataDict[uid]
-               // console.log('---delete', uid, clientMetaData)
-               await databaseService.deleteWithMeta(uid, clientMetaData.deleted_at)
-            }
-         
-            // STEP5: return to client the changes to perform on its cache, and create/update to perform on database with full data
-            // database creations & updates are done later by the client with complete data (this function only has client values's meta-data)
-            return {
-               toAdd: addClient,
-               toUpdate: updateClient,
-               toDelete: deleteClient,
-
-               addDatabase,
-               updateDatabase,
-            }
-         } catch(err) {
-            console.log('*** err sync', err)
-         } finally {
-            mutex.release()
-         }
-      },
-   })
-
-}
-