@jcbuisson/express-x-plugins 4.0.12 → 4.1.0

package/package.json

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

package/src/electric-client-plugin.mjs

@@ -1,16 +1,17 @@
 import { Shape, ShapeStream } from '@electric-sql/client'
-import { firstValueFrom, Observable, Subject, takeUntil } from 'rxjs'
-import { getCurrentScope, onScopeDispose, ref } from 'vue'
+import { Observable } from 'rxjs'
+// import { firstValueFrom, Subject, takeUntil } from 'rxjs'
+// import { getCurrentScope, onScopeDispose } from 'vue'
 
 /**
  * Add Electric-backed reactive models to an Express-X client.
  *
  * Usage:
  *   electricClientPlugin(app)
- *   const todo = app.createElectricModel('todos') // primary key is provided by client
- *   const todo = app.createElectricModel('todos', { idGeneration: 'server' }) // primary key is server-generated
- *   todo.getObservable({ completed: false }).subscribe(...)
- *   const completedTodos = await todo.findMany({ completed: false })
+ *   const todoModel = app.createElectricModel('todos') // primary key is automatically provided by server (auto-increment)
+ *   const todoMilk = await todoModel.create({ label: "Buy milk" })
+ *   todoMilk.update({ completed: true })
+ *   todoModel.getObservable({ completed: false }).subscribe(...) // subscribe to an observable for todos with completed===false
  */
 export function electricClientPlugin(app, options = {}) {
    const shapePath = options.shapePath ?? '/electric/v1/shape'
@@ -23,10 +24,10 @@ export function electricClientPlugin(app, options = {}) {
       const service = app.service(modelName)
       const url = modelOptions.url ?? modelPath(shapePath, modelName)
       const streamOptions = modelOptions.streamOptions ?? {}
-      const idGeneration = modelOptions.idGeneration ?? 'client'
-      if (!['client', 'server'].includes(idGeneration)) {
-         throw new TypeError("idGeneration must be 'client' or 'server'")
-      }
+      // const idGeneration = modelOptions.idGeneration ?? 'client'
+      // if (!['client', 'server'].includes(idGeneration)) {
+      //    throw new TypeError("idGeneration must be 'client' or 'server'")
+      // }
 
       function getObservable(where = {}) {
          // Validate eagerly
@@ -52,24 +53,35 @@ export function electricClientPlugin(app, options = {}) {
          })
       }
 
-      function findMany(where = {}) {
-         const observable = getObservable(where)
-         if (!getCurrentScope()) return firstValueFrom(observable)
-
-         const scopeDisposed = new Subject()
-         onScopeDispose(() => {
-            scopeDisposed.next()
-            scopeDisposed.complete()
-         })
-         return firstValueFrom(observable.pipe(takeUntil(scopeDisposed)))
-      }
-
-      async function create(data) {
-         assertPlainObject(data, 'mutation data')
-         if (idGeneration === 'server') return service.create(data)
-         const uid = globalThis.crypto?.randomUUID?.()
-         if (!uid) throw new Error('crypto.randomUUID() is required')
-         return service.create(uid, data)
+      // function findMany(where = {}) {
+      //    const observable = getObservable(where)
+      //    if (!getCurrentScope()) return firstValueFrom(observable)
+
+      //    const scopeDisposed = new Subject()
+      //    onScopeDispose(() => {
+      //       scopeDisposed.next()
+      //       scopeDisposed.complete()
+      //    })
+      //    return firstValueFrom(observable.pipe(takeUntil(scopeDisposed)))
+      // }
+
+      // async function create(data) {
+      //    assertPlainObject(data, 'mutation data')
+      //    if (idGeneration === 'server') return service.create(data)
+      //    const uid = globalThis.crypto?.randomUUID?.()
+      //    if (!uid) throw new Error('crypto.randomUUID() is required')
+      //    return service.create(uid, data)
+      // }
+
+      async function create(uidOrData, data) {
+         const hasUid = data !== undefined
+         const mutationData = hasUid ? data : uidOrData
+         assertPlainObject(mutationData, 'mutation data')
+         if (hasUid) {
+            return service.create(uidOrData, data)
+         } else {
+            return service.create(data)
+         }
       }
 
       async function update(id, data) {
@@ -80,7 +92,7 @@ export function electricClientPlugin(app, options = {}) {
          return service.delete(id)
       }
 
-      return { getObservable, findMany, create, update, remove }
+      return { getObservable, /*findMany,*/ create, update, remove }
    }
 
    return Object.assign(app, { createElectricModel })

package/src/electric-server-plugin.mjs

@@ -16,9 +16,11 @@ export function electricOfflinePlugin(app, db, models, options = {}) {
    const shapePath = options.shapePath ?? '/electric/v1/shape/:model'
    const fetchImpl = options.fetch ?? globalThis.fetch
    if (typeof fetchImpl !== 'function') throw new TypeError('a fetch implementation is required')
+   const authorizeFunc = options.authorize || (() => true)
+   if (typeof authorizeFunc !== 'function') throw new TypeError('an authorize function is required')
 
    async function authorize(context, modelName, action, args) {
-      const allowed = await options.authorize(context, { modelName, action, args })
+      const allowed = await authorizeFunc(context, { modelName, action, args })
       if (!allowed) {
          const error = new Error(`not authorized to ${action} '${modelName}'`)
          error.code = 'forbidden'
@@ -54,13 +56,13 @@ export function electricOfflinePlugin(app, db, models, options = {}) {
 
          // create(data): the primary key is server-generated
          // create(uid, data): uid (the primary key) is provided by the client
-         create: async function(idOrData, data) {
+         create: async function(uidOrData, data) {
             const hasClientId = data !== undefined
-            const mutationData = hasClientId ? data : idOrData
-            await authorize(this, model.name, 'create', hasClientId ? [idOrData, mutationData] : [mutationData])
+            const mutationData = hasClientId ? data : uidOrData
+            await authorize(this, model.name, 'create', hasClientId ? [uidOrData, mutationData] : [mutationData])
             assertPlainObject(mutationData, 'mutation data')
             const safeData = hasClientId
-               ? { ...mutationData, [model.primaryKey]: idOrData }
+               ? { ...mutationData, [model.primaryKey]: uidOrData }
                : { ...mutationData }
             const entries = Object.entries(safeData).filter(([, value]) => value !== undefined)
             const columns = entries.map(([column]) => quoteIdentifier(column, 'data column'))

package/src/reload-server-plugin.mjs

@@ -74,7 +74,7 @@ export async function reloadPlugin(app, options = {}) {
             // copy rooms
             for (const room of fromSocketRooms) {
                if (room === fromSocketId) continue // do not include room associated to socket#id
-               toSocket.join(room)
+               await toSocket.join(room)
             }
             // copy data
             toSocket.data = {

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

@@ -12,11 +12,15 @@ class FakeSocket {
       this.emitted = []
       this.sockets = sockets
       this.disconnectingListener = disconnectingListener
+      this.joinDelay = Promise.resolve()
    }
 
    on(event, handler) { this.handlers.set(event, handler) }
    emit(event, ...args) { this.emitted.push([event, ...args]) }
-   join(room) { this.rooms.add(room) }
+   async join(room) {
+      await this.joinDelay
+      this.rooms.add(room)
+   }
    disconnect() {
       this.disconnectingListener(this, 'server namespace disconnect')
       this.sockets.delete(this.id)
@@ -46,9 +50,16 @@ test('transfers state when the replacement connects before the old socket discon
    const transferToken = oldSocket.emitted.find(([event]) => event === 'cnx-transfer-token')[1]
 
    const newSocket = new FakeSocket('new', sockets, (...args) => disconnectingListener(...args))
+   let finishJoin
+   newSocket.joinDelay = new Promise(resolve => { finishJoin = resolve })
    sockets.set(newSocket.id, newSocket)
    connectListener(newSocket)
-   await newSocket.handlers.get('cnx-transfer')('old', 'new', transferToken)
+   const transfer = newSocket.handlers.get('cnx-transfer')('old', 'new', transferToken)
+
+   await Promise.resolve()
+   assert.equal(newSocket.emitted.some(([event]) => event === 'cnx-transfer-ack'), false)
+   finishJoin()
+   await transfer
 
    assert.equal(newSocket.data.user, 'Ada')
    assert.equal(newSocket.rooms.has('project:1'), true)