@jcbuisson/express-x 1.3.7 → 1.4.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.3.7",
+  "version": "1.4.1",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",
@@ -18,7 +18,6 @@
   },
   "keywords": [],
   "dependencies": {
-    "@jcbuisson/express-x-client": "^1.0.10",
     "@prisma/client": "^4.10.1",
     "axios": "^1.4.0",
     "bcryptjs": "^2.4.3",

package/src/index.mjs

@@ -1,11 +1,9 @@
 
 import { expressX } from './server.mjs'
-import { expressXClient } from './client.mjs'
 import { hashPassword, protect, setSessionJWT, } from './common-hooks.mjs'
 
 export {
    expressX,
-   expressXClient,
 
    hashPassword,
    protect,

package/src/server.mjs

@@ -14,10 +14,17 @@ export function expressX(prisma, options = {}) {
    if (options.ws === undefined) options.ws = { ws_prefix: "expressx" }
 
    const services = {}
-   const connections = {}
 
+   app.connections = {}
    let lastConnectionId = 1
 
+   app.printCnx = (label) => {
+      console.log(label)
+      for (const id in app.connections) {
+         console.log(`CNX ${id}, data ${JSON.stringify(app.connections[id].data)}`)
+      }
+   }
+
    // logging function - a winston logger must be configured first
    app.log = (severity, message) => {
       const logger = app.get('logger')
@@ -62,18 +69,21 @@ export function expressX(prisma, options = {}) {
             const beforeMethodHooks = service?.hooks?.before && service.hooks.before[methodName] || []
             const beforeAllHooks = service?.hooks?.before?.all || []
             for (const hook of [...beforeMethodHooks, ...beforeAllHooks]) {
-               context = await hook({ ...context, args })
+               // context = await hook(context)
+               await hook(context)
             }
 
             // call method
             const result = await method(...context.args)
-            app.log('debug', 'result ' + JSON.stringify(result))
+            // put result into context
+            context.result = result
    
             // call 'after' hooks
             const afterMethodHooks = service?.hooks?.after && service.hooks.after[methodName] || []
             const afterAllHooks = service?.hooks?.after?.all || []
             for (const hook of [...afterMethodHooks, ...afterAllHooks]) {
-               context = await hook({ ...context, result })
+               // context = await hook(context)
+               await hook(context)
             }
             return result
          }
@@ -117,10 +127,11 @@ export function expressX(prisma, options = {}) {
    async function addHttpRest(path, service) {
       const context = {
          app,
-         http: { name: service.name }
+         transport: 'http',
+         params: { name: service.name }
       }
 
-      // introspect schema
+      // introspect schema and return a map: field name => prisma type
       async function getTypesMap() {
          const dmmf = await service.prisma._getDmmf()
          const fieldDescriptions = dmmf.modelMap[service.name].fields
@@ -133,7 +144,7 @@ export function expressX(prisma, options = {}) {
 
       app.post(path, async (req, res) => {
          app.log('verbose', `http request POST ${req.url}`)
-         context.http.req = req
+         context.params.req = req
          try {
             const value = await service.__create(context, { data: req.body })
             publish(service, 'create', value)
@@ -146,7 +157,7 @@ export function expressX(prisma, options = {}) {
 
       app.get(path, async (req, res) => {
          app.log('verbose', `http request GET ${req.url}`)
-         context.http.req = req
+         context.params.req = req
          const query = { ...req.query }
          try {
             // the values in `req.query` are all strings, but Prisma need proper types
@@ -182,7 +193,7 @@ export function expressX(prisma, options = {}) {
 
       app.get(`${path}/:id`, async (req, res) => {
          app.log('verbose', `http request GET ${req.url}`)
-         context.http.req = req
+         context.params.req = req
          try {
             const value = await service.__findUnique(context, {
                where: {
@@ -199,7 +210,7 @@ export function expressX(prisma, options = {}) {
 
       app.patch(`${path}/:id`, async (req, res) => {
          app.log('verbose', `http request PATCH ${req.url}`)
-         context.http.req = req
+         context.params.req = req
          try {
             const value = await service.__update(context, {
                where: {
@@ -217,7 +228,7 @@ export function expressX(prisma, options = {}) {
 
       app.delete(`${path}/:id`, async (req, res) => {
          app.log('verbose', `http request DELETE ${req.url}`)
-         context.http.req = req
+         context.params.req = req
          try {
             const value = await service.__delete(context, {
                where: {
@@ -252,10 +263,13 @@ export function expressX(prisma, options = {}) {
             id: lastConnectionId++,
             socket,
             channelNames: new Set(),
+            data: {
+               a: 123
+            },
          }
          // store connection in cache 
-         connections[connection.id] = connection
-         app.log('verbose', `active connections ${Object.keys(connections)}`)
+         app.connections[connection.id] = connection
+         app.log('verbose', `Connection ids: ${Object.keys(app.connections)}`)
 
          // emit 'connection' event for app (expressjs extends EventEmitter)
          app.emit('connection', connection)
@@ -265,7 +279,23 @@ export function expressX(prisma, options = {}) {
 
          socket.on('disconnect', () => {
             app.log('verbose', `Client disconnected ${connection.id}`)
-            delete connections[connection.id]
+
+            // remove connection record after 1mn (leaves time in case of connection transfer)
+            setTimeout(() => {
+               app.log('verbose', `Delete connection ${connection.id}`)
+               delete app.connections[connection.id]
+            }, 60 * 1000)
+         })
+
+         
+         // handle connection data transfer caused by a disconnection/reconnection (page reload, network issue, etc.)
+         socket.on('cnx-transfer', async ({ from, to }) => {
+            app.log('verbose', `cnx-transfer from ${from} to ${to}`)
+            if (!app.connections[from]) return
+            app.connections[to] = app.connections[from]
+            app.connections[to].socket = socket
+            delete app.connections[from]
+            // app.printCnx('AFTER TRANSFER')
          })
 
 
@@ -282,11 +312,13 @@ export function expressX(prisma, options = {}) {
                   if (serviceMethod) {
                      const context = {
                         app,
-                        ws: { connection, name, action, args },
+                        transport: 'ws',
+                        params: { connection, name, action, args },
                      }
 
                      try {
                         const result = await serviceMethod(context, ...args)
+                        app.log('verbose', `client-response ${uid} ${JSON.stringify(result)}`)
                         socket.emit('client-response', {
                            uid,
                            result,
@@ -294,7 +326,7 @@ export function expressX(prisma, options = {}) {
                         // pub/sub: send event on associated channels
                         publish(service, action, result)
                      } catch(err) {
-                        app.log('error', err)
+                        app.log('error', err.toString())
                         io.emit('client-response', {
                            uid,
                            error: err.toString(),
@@ -330,7 +362,7 @@ export function expressX(prisma, options = {}) {
          app.log('verbose', `publish channels ${service.name} ${action} ${channelNames}`)
          for (const channelName of channelNames) {
             app.log('verbose', `service-event ${service.name} ${action} ${channelName}`)
-            const connectionList = Object.values(connections).filter(cnx => cnx.channelNames.has(channelName))
+            const connectionList = Object.values(app.connections).filter(cnx => cnx.channelNames.has(channelName))
             for (const connection of connectionList) {
                app.log('verbose', `emit to ${connection.id} ${service.name} ${action} ${result}`)
                connection.socket.emit('service-event', {

package/test/index.test.js

@@ -2,17 +2,24 @@
 import bodyParser from 'body-parser'
 import axios from 'axios'
 import io from 'socket.io-client'
+import { PrismaClient } from '@prisma/client'
 
 
-// import { assert } from 'chai'
 import { describe, it, before, after, beforeEach, afterEach } from 'node:test'
 import { strict as assert } from 'node:assert'
 
-import { expressX, expressXClient } from '../src/index.mjs'
+import { expressX } from '../src/index.mjs'
 
+const prisma = new PrismaClient({
+   datasources: {
+      db: {
+         url: "file:./dev.db",
+      },
+   },
+})
 
 // `app` is a regular express application, enhanced with services and real-time features
-const app = expressX()
+const app = expressX(prisma)
 
 
 
@@ -137,41 +144,3 @@ describe('HTTP/REST API', () => {
       app.server.close()
    })
 })
-
-
-// test compatibility with client API
-describe('Client API', () => {
-
-   let clientApp, socket
-
-   before(async () => {
-      await new Promise((resolve) => {
-         app.server.listen(8008, () => {
-            console.log(`App listening at http://localhost:8008`)
-            resolve()
-         })
-      })
-
-      socket = io('http://localhost:8008', { transports: ["websocket"] })
-      clientApp = expressXClient(socket)
-   })
-
-   after(async () => {
-      app.server.close()
-   })
-
-   it("can create a user", async () => {
-      const user = await clientApp.service('User').create({
-         data: {
-            name: "chris",
-            email: 'chris@mail.fr'
-         },
-      })
-      assert(user.name === 'chris')
-   })
-
-   after(async () => {
-      await socket.close()
-      await app.server.close()
-   })
-})

package/src/client.mjs

@@ -1,95 +0,0 @@
-
-import { v4 } from 'uuid'
-
-export function expressXClient(socket, options={}) {
-   if (options.debug === undefined) options.debug = false
-
-   const waitingPromisesByUid = {}
-   const action2service2handlers = {}
-   let onConnectionCallback = null
-   let onDisconnectionCallback = null
-
-   const setConnectionCallback = (callback) => {
-      onConnectionCallback = callback
-   }
-
-   const setDisconnectionCallback = (callback) => {
-      onDisconnectionCallback = callback
-   }
-
-   // on connection
-   socket.on("connected", async (connectionId) => {
-      if (options.debug) console.log('connected', connectionId)
-      if (onConnectionCallback) onConnectionCallback(connectionId)
-   })
-
-   // on receiving response from service request
-   socket.on('client-response', ({ uid, error, result }) => {
-      if (options.debug) console.log('client-response', uid, error, result)
-      if (!waitingPromisesByUid[uid]) return // may not exist because a timeout removed it
-      const [resolve, reject] = waitingPromisesByUid[uid]
-      if (error) {
-         reject(error)
-      } else {
-         resolve(result)
-      }
-      delete waitingPromisesByUid[uid]
-   })
-
-   // on receiving events from pub/sub
-   socket.on('service-event', ({ name, action, result }) => {
-      if (!action2service2handlers[action]) action2service2handlers[action] = {}
-      const serviceHandlers = action2service2handlers[action]
-      const handler = serviceHandlers[name]
-      if (handler) handler(result)
-   })
-
-   async function serviceMethodRequest(name, action, ...args) {
-      const uid = v4()
-      // create a promise which will resolve or reject by an event 'client-response'
-      const promise = new Promise((resolve, reject) => {
-         waitingPromisesByUid[uid] = [resolve, reject]
-         // a 5s timeout may also reject the promise
-         setTimeout(() => {
-            delete waitingPromisesByUid[uid]
-            reject(`Error: timeout on service '${name}', action '${action}', args: ${args}`)
-         }, 5000)
-      })
-      // send request to server through websocket
-      socket.emit('client-request', {
-         uid,
-         name,
-         action,
-         args,
-      })
-      return promise
-   }
-
-   function service(name) {
-      const service = {
-         // associate a handler to a pub/sub event for this service
-         on: (action, handler) => {
-            if (!action2service2handlers[action]) action2service2handlers[action] = {}
-            const serviceHandlers = action2service2handlers[action]
-            serviceHandlers[name] = handler
-         },
-      }
-      // use a Proxy to allow for any method name for a service
-      const handler = {
-         get(service, action) {
-            if (!(action in service)) {
-               // newly used property `action`: define it as a service method request function
-               service[action] = (...args) => serviceMethodRequest(name, action, ...args)
-            }
-            return service[action]
-         }
-      }
-      return new Proxy(service, handler)
-   }
-
-   return {
-      setConnectionCallback,
-      setDisconnectionCallback,
-      service,
-   }
-}