@jcbuisson/express-x 1.3.6 → 1.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.3.6",
+  "version": "1.4.0",
   "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

@@ -2,14 +2,14 @@
 import http from 'http'
 import { Server } from "socket.io"
 import express from 'express'
-import { PrismaClient } from '@prisma/client'
 
 /*
  * Enhance `app` express application with services and real-time features
  */
-export function expressX(options = {}) {
+export function expressX(prisma, options = {}) {
 
    const app = express()
+   app.set('prisma', prisma)
 
    if (options.ws === undefined) options.ws = { ws_prefix: "expressx" }
 
@@ -28,13 +28,6 @@ export function expressX(options = {}) {
     * create a service `name` based on Prisma table `entity`
     */
    function createDatabaseService(name, prismaOptions = { entity: name }) {
-
-      let prisma = app.get('prisma')
-      if (!prisma) {
-         prisma = new PrismaClient()
-         app.set('prisma', prisma)
-      }
-
       // take all prisma methods on `entity` table
       const methods = prisma[prismaOptions.entity]
 
@@ -74,7 +67,7 @@ export function expressX(options = {}) {
 
             // call method
             const result = await method(...context.args)
-            app.log('debug', `result ${result}`)
+            app.log('debug', 'result ' + JSON.stringify(result))
    
             // call 'after' hooks
             const afterMethodHooks = service?.hooks?.after && service.hooks.after[methodName] || []
@@ -127,7 +120,7 @@ export function expressX(options = {}) {
          http: { 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
@@ -259,10 +252,11 @@ export function expressX(options = {}) {
             id: lastConnectionId++,
             socket,
             channelNames: new Set(),
+            data: {},
          }
          // store connection in cache 
          connections[connection.id] = connection
-         app.log('verbose', `active connections ${Object.keys(connections)}`)
+         app.log('verbose', `active connection ids: ${Object.keys(connections)}`)
 
          // emit 'connection' event for app (expressjs extends EventEmitter)
          app.emit('connection', connection)
@@ -272,7 +266,16 @@ export function expressX(options = {}) {
 
          socket.on('disconnect', () => {
             app.log('verbose', `Client disconnected ${connection.id}`)
-            delete connections[connection.id]
+
+            // TODO: wait for 1mn before cleaning (a reconnection will use this data)
+            // delete connections[connection.id]
+         })
+
+         // handle connection data transfer caused by a disconnection (page reload, network issue, etc.)
+         socket.on('cnx-transfer', async ({ from, to }) => {
+            app.log('verbose', `cnx-transfer from ${from} to ${to}`)
+            connections[to] = connections[from]
+            delete connections[from]
          })
 
 

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'
 
+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)
 
 
 

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,
-   }
-}