@jcbuisson/express-x 2.1.13 → 2.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "2.1.13",
+  "version": "2.1.14",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",

package/src/index.mjs

@@ -1,14 +1,398 @@
 
-import { expressX } from './server.mjs'
-import { addTimestamp, hashPassword, protect, isAuthenticated, isNotExpired, extendExpiration } from './common-hooks.mjs'
-
-export {
-   expressX,
-
-   addTimestamp,
-   hashPassword,
-   protect,
-   isAuthenticated,
-   isNotExpired,
-   extendExpiration,
+// import { expressX } from './server.mjs'
+// import { addTimestamp, hashPassword, protect, isAuthenticated, isNotExpired, extendExpiration } from './common-hooks.mjs'
+
+// export {
+//    expressX,
+
+//    addTimestamp,
+//    hashPassword,
+//    protect,
+//    isAuthenticated,
+//    isNotExpired,
+//    extendExpiration,
+// }
+
+
+import express from "express"
+import { createServer } from "http"
+import { Server } from "socket.io"
+import bcrypt from 'bcryptjs'
+
+
+
+// UTILISER L'ACKNOWLEDGEMENT : https://socket.io/docs/v4/#acknowledgements
+
+
+export function expressX(config) {
+
+   const services = {}
+   const socketConnectListeners = []
+   const socketDisconnectingListeners = []
+   const socketDisconnectListeners = []
+
+
+   function addConnectListener(func) {
+      socketConnectListeners.push(func)
+   }
+
+   function addDisconnectingListener(func) {
+      socketDisconnectingListeners.push(func)
+   }
+
+   function addDisconnectListener(func) {
+      socketDisconnectListeners.push(func)
+   }
+
+   const app = express()
+   const httpServer = createServer(app)
+
+   // so that config can be accessed anywhere with app.get('config')
+   app.set('config', config)
+
+   const io = new Server(httpServer, {
+      path: config?.WS_PATH || '/socket.io/',
+      connectionStateRecovery: {
+         // the backup duration of the sessions and the packets
+         maxDisconnectionDuration: 2 * 60 * 1000,
+         // whether to skip middlewares upon successful recovery
+         skipMiddlewares: true,
+      }
+   })
+
+   // so that io server is accessible to hooks & services
+   app.set('io', io)
+
+   // logging function - a winston logger must be configured first
+   app.log = (severity, message) => {
+      const logger = app.get('logger')
+      if (logger) logger.log(severity, message); else console.log(`[${severity}]`, message)
+   }
+
+   io.on('connection', async function(socket) {
+      if (socket.recovered) {
+         // recovery was successful: socket.id, socket.rooms and socket.data were restored
+         // (network/Wifi disconnections)
+         console.log('reconnection!!!', socket.id, socket.data)
+      } else {
+         // new or unrecoverable connection
+         // (page open, page refresh/reload)
+      }
+
+      app.log('verbose', `Client connected ${socket.id}`)
+
+      // // emit 'connection' event for app (expressjs extends EventEmitter)
+      // app.emit('connection', socket)
+
+      socketConnectListeners.forEach(listener => listener(socket))
+
+      // // send 'connected' event to client
+      // socket.emit('connected', socket.id)
+
+      socket.on('disconnecting', (reason) => {
+         app.log('verbose', `Client disconnecting ${socket.id}, ${reason}`)
+         socketDisconnectingListeners.forEach(listener => listener(socket, reason))
+      })
+
+      socket.on('disconnect', (reason) => {
+         app.log('verbose', `Client disconnect ${socket.id}, ${reason}`)
+         socketDisconnectListeners.forEach(listener => listener(socket, reason))
+      })
+
+      /*
+      * Handle websocket client request
+      * Emit in return a 'client-response' message
+      */
+      socket.on('client-request', async ({ uid, name, action, args }) => {
+         const trimmedArgs = args ? JSON.stringify(args).slice(0, 300) : ''
+         app.log('verbose', `client-request ${uid} ${name} ${action} ${trimmedArgs}`)
+         if (name in services) {
+            const service = services[name]
+            try {
+               const serviceMethod = service['__' + action]
+               if (serviceMethod) {
+                  const context = {
+                     app,
+                     caller: 'client',
+                     transport: 'ws',
+                     socket,
+                     // connectionId,
+                     serviceName: name,
+                     methodName: action,
+                     args,
+                  }
+
+                  try {
+                     // call method with context
+                     const result = await serviceMethod(context, ...args)
+
+                     const trimmedResult = result ? JSON.stringify(result).slice(0, 300) : ''
+                     app.log('verbose', `client-response ${uid} ${trimmedResult}`)
+                     socket.emit('client-response', {
+                        uid,
+                        result,
+                     })
+                  } catch(err) {
+                     console.log('!!!!!!error', err.code, err.message)
+                     app.log('verbose', err.stack)
+                     socket.emit('client-response', {
+                        uid,
+                        error: {
+                           code: err.code || 'unknown-error',
+                           message: err.message,
+                           stack: err.stack,
+                        }
+                     })
+                  }
+               } else {
+                  socket.emit('client-response', {
+                     uid,
+                     error: {
+                        code: 'missing-method',
+                        message: `there is no method named '${action}' for service '${name}'`,
+                     }
+                  })
+               }
+            } catch(err) {
+               console.log('err', err)
+               app.log('verbose', err.stack)
+               socket.emit('client-response', {
+                  uid,
+                  error: {
+                     code: err.code || 'unknown-error',
+                     message: err.message,
+                     stack: err.stack,
+            }
+               })
+            }
+         } else {
+            socket.emit('client-response', {
+               uid,
+               error: {
+                  code: 'missing-service',
+                  message: `there is no service named '${name}'`,
+               }
+            })
+         }
+      })
+
+   })
+
+   /*
+    * create a service `name` with given `methods`
+    */
+   function createService(name, methods) {
+      const service = {}
+
+      for (const methodName in methods) {
+         const method = methods[methodName]
+         if (! method instanceof Function) continue
+
+         // `context` is the context of execution (transport type, connection, app)
+         // `args` is the list of arguments of the method
+         service['__' + methodName] = async (context, ...args) => {
+            // put args into context
+            context.args = args
+
+            // if a hook or the method throws an error, it will be caught by `socket.on('client-request'`
+            // and the client will get a rejected promise
+
+            // call 'before' hooks, possibly modifying `context`
+            const beforeMethodHooks = service?._hooks?.before && service._hooks.before[methodName] || []
+            const beforeAllHooks = service?._hooks?.before?.all || []
+            for (const hook of [...beforeAllHooks, ...beforeMethodHooks]) {
+               await hook(context)
+            }
+
+            // call method
+            const result = await method(...args)
+            // put result into context
+            context.result = result
+
+            // call 'after' hooks, possibly modifying `context`
+            const afterMethodHooks = service?._hooks?.after && service._hooks.after[methodName] || []
+            const afterAllHooks = service?._hooks?.after?.all || []
+            for (const hook of [...afterMethodHooks, ...afterAllHooks]) {
+               await hook(context)
+            }
+
+            // publish 'service-event' event associated to service/method
+            if (service.publishFunction) {
+               // collect channel names to socket is member of
+               const channelNames = await service.publishFunction(context)
+               app.log('verbose', `publish channels ${name} ${methodName} ${channelNames}`)
+               // send event on all these channels
+               if (channelNames.length > 0) {
+                  let sender = io.to(channelNames[0])
+                  for (let i = 1; i < channelNames.length; i++) {
+                     sender = sender.to(channelNames[i])
+                  }
+                  sender.emit('service-event', {
+                     name,
+                     action: methodName,
+                     result,
+                  })
+               }
+            }
+            
+            return context.result
+         }
+
+         // hooked version of method to be used server-side
+         service[methodName] = (...args) => {
+            const context = {
+               app,
+               caller: 'server',
+               serviceName: service._name,
+               methodName,
+               args,
+            }
+            const hookedMethod = service['__' + methodName]
+            return hookedMethod(context, ...args)
+         }
+      }
+
+      // attach pub/sub publish callback
+      service.publish = async (func) => {
+         service.publishFunction = func
+      },
+
+      // attach hooks
+      service.hooks = (hooks) => {
+         service._hooks = hooks
+      }
+
+      // cache service in `services`
+      services[name] = service
+      return service
+   }
+
+   function configure(callback) {
+      callback(app)
+   }
+
+   // `app.service(name)` starts here!
+   function service(name) {
+      // get service from `services` cache
+      if (name in services) return services[name]
+      app.log('error', `there is no service named '${name}'`, 'missing-service')
+   }
+
+   function joinChannel(channelName, socket) {
+      app.log('verbose', `joining ${channelName}, ${JSON.stringify(socket.data)}`)
+      socket.join(channelName)
+   }
+
+   function leaveChannel(channelName, socket) {
+      app.log('verbose', `leaving ${channelName}, ${JSON.stringify(socket.data)}`)
+      socket.leave(channelName)
+   }
+
+   // There is a need for events sent outside any service method call, for example on unsolicited-by-frontend backend state change
+   async function sendAppEvent(channelName, type, value) {
+      console.log('sendAppEvent', channelName, type, value)
+      io.to(channelName).emit('app-event', { type, value })
+   }
+
+   // enhance `app` with objects and methods
+   return Object.assign(app, {
+      io,
+      httpServer,
+      createService,
+      service,
+      configure,
+      joinChannel,
+      leaveChannel,
+      sendAppEvent,
+      addConnectListener,
+      addDisconnectingListener,
+      addDisconnectListener,
+   })
+}
+
+export default class EXError extends Error {
+   constructor(code, message) {
+      super(message)
+      this.code = code
+   }
+}
+
+
+
+
+/*
+ * Add a timestamp property of name `field` with current time as value
+*/
+export const addTimestamp = (field) => async (context) => {
+   context.result[field] = (new Date()).toISOString()
+   return context
+}
+
+/*
+ * Hash password of the property `field`
+*/
+export const hashPassword = (passwordField) => async (context) => {
+   const user = context.result
+   user[passwordField] = await bcrypt.hash(user[passwordField], 5)
+   return context
+}
+
+/*
+ * Remove `field` from `context.result`
+*/
+export function protect(field) {
+   return async (context) => {
+      if (Array.isArray(context.result)) {
+         for (const value of context.result) {
+            delete value[field]
+         }
+      } else {
+         delete context.result[field]
+      }
+      return (context)
+   }
+}
+
+export const isNotExpired = async (context) => {
+   // do nothing if it's not a client call from a ws connexion
+   if (!context.socket) return
+   const expiresAt = context.socket.data.expiresAt
+   if (expiresAt) {
+      const expiresAtDate = new Date(expiresAt)
+      const now = new Date()
+      if (now > expiresAtDate) {
+         // expiration date is met
+         // clear socket.data
+         context.socket.data = {}
+         // leave all rooms except socket#id
+         const rooms = new Set(context.socket.rooms)
+         for (const room of rooms) {
+            if (room === context.socket.id) continue
+            context.socket.leave(room)
+         }
+         // send an event to the client (typical client handling: logout)
+         context.socket.emit('expired')
+         // throw exception
+         throw new EXError('not-authenticated', "Session expired")
+      }
+   } else {
+      throw new EXError('not-authenticated', "No expiresAt in socket.data")
+   }
+}
+
+/*
+ * Throw an error for a client service method call when socket.data does not contain user
+*/
+export const isAuthenticated = async (context) => {
+   // do nothing if it's not a client call from a ws connexion
+   if (!context.socket) return
+   if (!context.socket.data.user) throw new EXError('not-authenticated', 'no user in socket.data')
+}
+
+/*
+ * Extend value of socket.data.expiresAt of `duration` milliseconds
+*/
+export const extendExpiration = (duration) => async (context) => {
+   const now = new Date()
+   context.socket.data.expiresAt = new Date(now.getTime() + duration)
 }