@jcbuisson/express-x 2.1.14 → 2.1.16

package/package.json

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

package/src/index.mjs

@@ -1,19 +1,3 @@
-
-// 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"
@@ -124,6 +108,9 @@ export function expressX(config) {
 
                   try {
                      // call method with context
+                     if (name === 'highlighted_part') {
+                        console.log('')
+                     }
                      const result = await serviceMethod(context, ...args)
 
                      const trimmedResult = result ? JSON.stringify(result).slice(0, 300) : ''
@@ -133,7 +120,7 @@ export function expressX(config) {
                         result,
                      })
                   } catch(err) {
-                     console.log('!!!!!!error', err.code, err.message)
+                     console.log('!!!!!!error', 'name', name, 'action', action, 'args', args, 'err.code', err.code, 'err.message', err.message)
                      app.log('verbose', err.stack)
                      socket.emit('client-response', {
                         uid,
@@ -310,7 +297,7 @@ export function expressX(config) {
    })
 }
 
-export default class EXError extends Error {
+export class EXError extends Error {
    constructor(code, message) {
       super(message)
       this.code = code
@@ -356,7 +343,7 @@ export function protect(field) {
 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
+   const expiresAt = context.socket?.data?.expiresAt
    if (expiresAt) {
       const expiresAtDate = new Date(expiresAt)
       const now = new Date()
@@ -385,8 +372,9 @@ export const isNotExpired = async (context) => {
 */
 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')
+   if (context.caller !== 'client') return
+   if (!context.socket?.data) throw new EXError('not-authenticated', 'no data in socket')
+   if (!context.socket.data?.user) throw new EXError('not-authenticated', 'no user in socket.data')
 }
 
 /*
@@ -394,5 +382,7 @@ export const isAuthenticated = async (context) => {
 */
 export const extendExpiration = (duration) => async (context) => {
    const now = new Date()
+   if (context.caller !== 'client') return
+   if (!context.socket?.data) throw new EXError('not-authenticated', 'no data in socket')
    context.socket.data.expiresAt = new Date(now.getTime() + duration)
 }

package/src/common-hooks.mjs

@@ -1,81 +0,0 @@
-
-import bcrypt from 'bcryptjs'
-
-import { EXError } from './server.mjs'
-
-/*
- * 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)
-}

package/src/server.mjs

@@ -1,300 +0,0 @@
-import express from "express"
-import { createServer } from "http"
-import { Server } from "socket.io"
-
-
-// UTILISER L'ACKNOWLEDGEMENT : https://socket.io/docs/v4/#acknowledgements
-
-export default class EXError extends Error {
-   constructor(code, message) {
-      super(message)
-      this.code = code
-   }
-}
-
-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,
-   })
-
-}