@jcbuisson/express-x 2.1.1 → 2.1.4

package/package.json

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

package/src/common-hooks.mjs

@@ -35,25 +35,30 @@ export function protect(field) {
 }
 
 /*
- * Does nothing for calls which are not client-side
- * Check if the 'expireAt' key in socket.data is met
- * If it is met, throw an error (which will be sent back to the calling server or client) and reset socket.data
- * If not, do nothing. If needed, an application-level hook may automatically extend the expiration data at each service call
+ * Throw an error for a client service method call when socket.data.expiresAt is missing or overdue
 */
 export const isNotExpired = async (context) => {
-   if (context.caller !== 'client') return
-   
-   const expireAt = context.socket.data.expireAt
-   if (expireAt) {
-      const expireAtDate = new Date(expireAt)
+   // 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 > expireAtDate) {
+      if (now > expiresAtDate) {
          // expiration date is met: clear socket.data & throw exception
-         const { clientIP } = socket.data
-         socket.data = { clientIP }
+         context.socket.data = {}
          throw new Error('session-expired')
       }
    } else {
       throw new Error('session-expired')
    }
 }
+
+/*
+ * 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 Error('not-authenticated')
+}

package/src/index.mjs

@@ -1,6 +1,6 @@
 
 import { expressX } from './server.mjs'
-import { addTimestamp, hashPassword, protect, isNotExpired } from './common-hooks.mjs'
+import { addTimestamp, hashPassword, protect, isAuthenticated, isNotExpired } from './common-hooks.mjs'
 
 export {
    expressX,
@@ -8,5 +8,6 @@ export {
    addTimestamp,
    hashPassword,
    protect,
+   isAuthenticated,
    isNotExpired,
 }

package/src/server.mjs

@@ -3,14 +3,27 @@ import { createServer } from "http"
 import { Server } from "socket.io"
 
 
+// UTILISER L'ACKNOWLEDGEMENT : https://socket.io/docs/v4/#acknowledgements
+
 export function expressX(config) {
 
    const services = {}
    let appHooks = []
-   let socketConnectHandler = null
+   const socketConnectListeners = []
+   const socketDisconnectingListeners = []
+   const socketDisconnectListeners = []
+
+
+   function addConnectListener(func) {
+      socketConnectListeners.push(func)
+   }
+
+   function addDisconnectingListener(func) {
+      socketDisconnectingListeners.push(func)
+   }
 
-   function onSocketConnect(func) {
-      socketConnectHandler = func
+   function addDisconnectListener(func) {
+      socketDisconnectListeners.push(func)
    }
 
    const app = express()
@@ -29,6 +42,9 @@ export function expressX(config) {
       }
    })
 
+   // 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')
@@ -43,21 +59,26 @@ export function expressX(config) {
       } else {
          // new or unrecoverable connection
          // (page open, page refresh/reload)
-         socket.data.clientIP = socket.handshake.address
       }
 
       app.log('verbose', `Client connected ${socket.id}`)
 
-      // emit 'connection' event for app (expressjs extends EventEmitter)
-      app.emit('connection', socket)
+      // // emit 'connection' event for app (expressjs extends EventEmitter)
+      // app.emit('connection', socket)
+
+      socketConnectListeners.forEach(listener => listener(socket))
 
-      if (socketConnectHandler) socketConnectHandler(socket)
+      // // send 'connected' event to client
+      // socket.emit('connected', socket.id)
 
-      // 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', () => {
-         app.log('verbose', `Client disconnected ${socket.id}`)
+      socket.on('disconnect', (reason) => {
+         app.log('verbose', `Client disconnect ${socket.id}, ${reason}`)
+         socketDisconnectListeners.forEach(listener => listener(socket, reason))
       })
 
       /*
@@ -94,13 +115,14 @@ export function expressX(config) {
                         result,
                      })
                   } catch(err) {
-                     console.log('!!!!!!error', err.code, err)
+                     console.log('!!!!!!error', err)
                      app.log('verbose', err.stack)
                      socket.emit('client-response', {
                         uid,
                         error: {
                            code: err.code || 'unknown-error',
-                           message: err.stack,
+                           message: err.message,
+                           stack: err.stack,
                         }
                      })
                   }
@@ -120,8 +142,9 @@ export function expressX(config) {
                   uid,
                   error: {
                      code: err.code || 'unknown-error',
-                     message: err.stack,
-                  }
+                     message: err.message,
+                     stack: err.stack,
+            }
                })
             }
          } else {
@@ -153,8 +176,8 @@ export function expressX(config) {
             // 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'` (ws)
-            // or by express (http) and the client will get a rejected promise
+            // 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 beforeAppHooks = appHooks?.before || []
@@ -271,7 +294,9 @@ export function expressX(config) {
       joinChannel,
       leaveChannel,
       sendAppEvent,
-      onSocketConnect,
+      addConnectListener,
+      addDisconnectingListener,
+      addDisconnectListener,
    })
 
 }