@jcbuisson/express-x-plugins 4.0.10 → 4.0.12

package/package.json

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

package/src/electric-server-plugin.mjs

@@ -191,7 +191,7 @@ function buildWhere(where, startIndex = 1) {
          clauses.push(`${quotedColumn} IS NULL`)
          continue
       }
-      if (constraint && typeof constraint === 'object' && !Array.isArray(constraint)) {
+      if (constraint && typeof constraint === 'object' && !Array.isArray(constraint) && !(constraint instanceof Date)) {
          const entries = Object.entries(constraint)
          if (entries.length === 0 || entries.some(([operator]) => !RANGE_OPERATORS[operator])) {
             throw new TypeError(`unsupported where constraint for '${column}'`)

package/src/reload-server-plugin.mjs

@@ -19,11 +19,13 @@ export async function reloadPlugin(app, options = {}) {
    const data = Object.create(null)
    const transferTokens = Object.create(null)
    const transferExpiryTimers = Object.create(null)
+   const consumedSocketIds = new Set()
    roomCache.set(app, rooms)
    dataCache.set(app, data)
 
    app.addDisconnectingListener((socket, reason) => {
       console.log('onSocketDisconnecting', socket.id, reason)
+      if (consumedSocketIds.delete(socket.id)) return
       // save socket data & rooms in caches
       const alreadySavedData = data[socket.id]
       const alreadySavedRooms = rooms[socket.id]
@@ -48,13 +50,14 @@ export async function reloadPlugin(app, options = {}) {
       console.log('onSocketConnect', socket.id)
       const transferToken = randomUUID()
       socket.data.__cnxTransferToken = transferToken
+      transferTokens[socket.id] = transferToken
       socket.emit('cnx-transfer-token', transferToken)
    
       // when client ask for transfer from fromSocketId to toSocketId
       socket.on('cnx-transfer', async (fromSocketId, toSocketId, claimedToken) => {
          app.log('verbose', `cnx-transfer from ${fromSocketId} to ${toSocketId}`)
          // A socket may only claim its own ID as the destination — prevent session hijacking
-         if (toSocketId !== socket.id || typeof claimedToken !== 'string'
+         if (toSocketId !== socket.id || fromSocketId === socket.id || typeof claimedToken !== 'string'
             || transferTokens[fromSocketId] !== claimedToken) {
             app.log('verbose', `cnx-transfer rejected: toSocketId ${toSocketId} !== socket.id ${socket.id}`)
             socket.emit('cnx-transfer-error', fromSocketId, toSocketId)
@@ -62,19 +65,20 @@ export async function reloadPlugin(app, options = {}) {
          }
          // copy connection room & data from 'fromSocketId' to 'toSocketId'
          const toSocket = io.sockets.sockets.get(toSocketId)
-         // data & rooms of fromSocketId are taken from dataCache and roomCache, since socket no longer exists
-         const fromSocketRooms = rooms[fromSocketId]
+         const fromSocket = io.sockets.sockets.get(fromSocketId)
+         // Usually the old socket has disconnected and its state is cached. During a
+         // fast reload it may still be live, so snapshot it directly instead.
+         const fromSocketRooms = rooms[fromSocketId] ?? fromSocket?.rooms
+         const fromSocketData = data[fromSocketId] ?? fromSocket?.data
          if (toSocket && fromSocketRooms) {
             // copy rooms
             for (const room of fromSocketRooms) {
                if (room === fromSocketId) continue // do not include room associated to socket#id
-               const allowed = typeof options.authorizeRoomRestore === 'function'
-                  && await options.authorizeRoomRestore({ app, socket: toSocket, room })
-               if (allowed) toSocket.join(room)
+               toSocket.join(room)
             }
             // copy data
             toSocket.data = {
-               ...data[fromSocketId],
+               ...fromSocketData,
                ...toSocket.data,
                __cnxTransferToken: transferToken,
             }
@@ -86,6 +90,10 @@ export async function reloadPlugin(app, options = {}) {
             delete transferTokens[fromSocketId]
             clearTimeout(transferExpiryTimers[fromSocketId])
             delete transferExpiryTimers[fromSocketId]
+            if (fromSocket) {
+               consumedSocketIds.add(fromSocketId)
+               fromSocket.disconnect(true)
+            }
             // send acknowlegment to toSocket
             toSocket.emit('cnx-transfer-ack', fromSocketId, toSocketId)
          } else {

package/test/electric-server-plugin.test.mjs

@@ -74,6 +74,19 @@ test('protects the configured primary key during updates', async () => {
    assert.deepEqual(queries[0].values, ['editable', 'Ada', 7])
 })
 
+test('accepts Date values in server-side filters', async () => {
+   const { services, queries } = fixture()
+   const createdAt = new Date('2026-08-01T12:00:00.000Z')
+
+   await services.get('todos').findUnique.call({}, { createdAt })
+
+   assert.equal(
+      queries[0].sql,
+      'SELECT * FROM "todos" WHERE "createdAt" = $1 LIMIT 1',
+   )
+   assert.deepEqual(queries[0].values, [createdAt])
+})
+
 test('requires authorization and reports forbidden calls', async () => {
    const { services } = fixture({ authorize: async () => false })
    await assert.rejects(

package/test/reload-server-plugin.test.mjs

@@ -0,0 +1,60 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import { reloadPlugin } from '../src/reload-server-plugin.mjs'
+
+class FakeSocket {
+   constructor(id, sockets, disconnectingListener) {
+      this.id = id
+      this.data = {}
+      this.rooms = new Set([id])
+      this.handlers = new Map()
+      this.emitted = []
+      this.sockets = sockets
+      this.disconnectingListener = disconnectingListener
+   }
+
+   on(event, handler) { this.handlers.set(event, handler) }
+   emit(event, ...args) { this.emitted.push([event, ...args]) }
+   join(room) { this.rooms.add(room) }
+   disconnect() {
+      this.disconnectingListener(this, 'server namespace disconnect')
+      this.sockets.delete(this.id)
+   }
+}
+
+test('transfers state when the replacement connects before the old socket disconnects', async () => {
+   const sockets = new Map()
+   let connectListener
+   let disconnectingListener
+   const app = {
+      get(key) {
+         if (key === 'io') return { sockets: { sockets } }
+         if (key === 'config') return {}
+      },
+      addConnectListener(listener) { connectListener = listener },
+      addDisconnectingListener(listener) { disconnectingListener = listener },
+      log() {},
+   }
+   await reloadPlugin(app, { authorizeRoomRestore: async () => true })
+
+   const oldSocket = new FakeSocket('old', sockets, (...args) => disconnectingListener(...args))
+   oldSocket.data.user = 'Ada'
+   oldSocket.rooms.add('project:1')
+   sockets.set(oldSocket.id, oldSocket)
+   connectListener(oldSocket)
+   const transferToken = oldSocket.emitted.find(([event]) => event === 'cnx-transfer-token')[1]
+
+   const newSocket = new FakeSocket('new', sockets, (...args) => disconnectingListener(...args))
+   sockets.set(newSocket.id, newSocket)
+   connectListener(newSocket)
+   await newSocket.handlers.get('cnx-transfer')('old', 'new', transferToken)
+
+   assert.equal(newSocket.data.user, 'Ada')
+   assert.equal(newSocket.rooms.has('project:1'), true)
+   assert.equal(sockets.has('old'), false)
+   assert.deepEqual(
+      newSocket.emitted.find(([event]) => event === 'cnx-transfer-ack').slice(1),
+      ['old', 'new'],
+   )
+})