@jcbuisson/express-x 1.1.3 → 1.2.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.1.3",
+  "version": "1.2.0",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",
@@ -15,11 +15,13 @@
     "test": "mocha --require esm 'test/**/*.test.js'",
     "generate": "npx prisma generate",
     "migrate": "npx prisma migrate dev --name init"
-},
+  },
   "keywords": [],
   "dependencies": {
+    "@jcbuisson/express-x-client": "^1.0.10",
     "@prisma/client": "^4.10.1",
     "axios": "^1.4.0",
+    "bcrypt": "^5.1.0",
     "config": "^3.3.9",
     "esm": "^3.2.25",
     "express": "^4.18.2",

package/src/client.mjs

@@ -0,0 +1,95 @@
+
+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,
+   }
+}

package/src/common-hooks.mjs

@@ -0,0 +1,53 @@
+
+import config from 'config'
+import bcrypt from 'bcrypt'
+
+
+// hash password of user record
+// name of the password field is found in `config.authentication.local.passwordField` (default: 'password')
+export async function hashPassword(context) {
+   const passwordField = config.authentication.local.passwordField
+   context.args[0][passwordField] = await bcrypt.hash(context.args[0][passwordField], 5)
+   return context
+}
+
+
+export async function authenticate(context) {
+   console.log('authenticate hook', context.transport, context.name, context.action, context?.connection?.accessToken)
+   return context
+
+   if (context.transport === 'ws') {
+      // for WS transport, just check that connection.accessToken is set and valid
+      if (!context?.connection?.accessToken) throw new Error("WS connection is not secured by a JWT access token")
+      // TODO: check token validity
+
+   } else if (context.transport === 'http') {
+      // for HTTP transport, check that the associated request has a header with a valid JWT
+      // TODO: check headers for access token
+   }
+   return (context)
+}
+
+
+// remove `field` from `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 async function setSessionJWT(context) {
+   if (context.transport === 'ws') {
+      // associate JWT token to WS connection to mark it as secure
+      context.connection.accessToken = context.result.accessToken
+   }
+   return context
+}

package/src/index.mjs

@@ -1,377 +1,13 @@
 
-import http from 'http'
-import { Server } from "socket.io"
-import { PrismaClient } from '@prisma/client'
+import { expressXServer } from './server.mjs'
+import { expressXClient } from './client.mjs'
+import { hashPassword, protect, setSessionJWT, } from './common-hooks.mjs'
 
-/*
- * Enhance `app` express application with Feathers-like services
- */
-function expressX(app, options={}) {
+export {
+   expressXServer,
+   expressXClient,
 
-   if (options.debug === undefined) options.debug = false
-   if (options.ws === undefined) options.ws = { ws_prefix: "expressx" }
-
-   const services = {}
-   const connections = {}
-
-   let lastConnectionId = 1
-
-   /*
-    * 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]
-
-      const service = createService(name, methods)
-      
-      service.prisma = prisma
-      service.entity = prismaOptions.entity
-      
-      if (options.debug) console.log(`created service '${name}' over table '${prismaOptions.entity}'`)
-      return service
-   }
-
-   /*
-    * create a service `name` with given `methods`
-    */
-   function createService(name, methods) {
-      const service = { name }
-
-      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) => {
-            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
-
-            // call 'before' hooks, modifying `context.args`
-            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 })
-            }
-
-            // call method
-            const result = await method(...context.args)
-            // if (options.debug) console.log('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 })
-            }
-            return result
-         }
-
-         // hooked version of method: `create`, etc., to be called from backend with no context
-         service[methodName] = method
-
-         // un-hooked version of method: `_create`, etc., to be called from backend with no context
-         service['_' + methodName] = method
-      }
-
-      // attach pub/sub publish callback
-      service.publish = async (func) => {
-         service.publishCallback = func
-      },
-
-      // attach hooks
-      service.hooks = (hooks) => {
-         service.hooks = hooks
-      }
-
-      // cache service in `services`
-      services[name] = service
-      return service
-   }
-
-   // `app.service(name)` starts here!
-   function service(name) {
-      // get service from `services` cache
-      if (name in services) return services[name]
-      throw Error(`there is no service named '${name}'`)
-   }
-
-   function configure(callback) {
-      callback(app)
-   }
-
-   /*
-    * add an HTTP REST endpoint at `path`, based on `service`
-    */
-   async function addHttpRest(path, service) {
-      const context = {
-         app,
-         http: { name: service.name }
-      }
-
-      // introspect table schema
-      async function getFieldTypes() {
-         const fieldTypes = {}
-         if (service.prisma._activeProvider === 'sqlite') {
-            const fieldInfo = await service.prisma.$queryRawUnsafe(`
-               PRAGMA table_info(${service.entity})
-            `)
-            fieldInfo.forEach(column => {
-               fieldTypes[column.name] = column.type.toLowerCase()
-            })
-         } else if (service.prisma._activeProvider === 'postgresql') {
-            const fieldInfo = await service.prisma.$queryRawUnsafe(`
-               SELECT column_name, data_type
-               FROM information_schema.columns
-               WHERE table_name = '${service.entity}';
-            `)
-            fieldInfo.forEach(column => {
-               fieldTypes[column.column_name] = column.data_type
-            })
-         }
-         return fieldTypes
-      }
-
-
-      app.post(path, async (req, res) => {
-         context.http.req = req
-         try {
-            const value = await service.__create(context, { data: req.body })
-            publish(service, 'create', value)
-            res.json(value)
-         } catch(err) {
-            console.log('callErr', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.get(path, async (req, res) => {
-         context.http.req = req
-         const query = { ...req.query }
-         try {
-            // the values in `req.query` are all strings, but Prisma need proper types
-            // we need to introspect column types and do the proper transtyping
-            for (const fieldName in query) {
-               if (!service.fieldTypes) service.fieldTypes = await getFieldTypes()
-               const fieldType = service.fieldTypes[fieldName]
-
-               if (fieldType === 'integer') {
-                  query[fieldName] = parseInt(query[fieldName])
-               } else if (fieldType === 'numeric') {
-                  query[fieldName] = parseFloat(query[fieldName])
-               } else if (fieldType === 'boolean') {
-                  query[fieldName] = (query[fieldName] === 't') ? true : false
-               } else if (fieldType === 'text' || fieldType === 'character varying') {
-                  query[fieldName] = query[fieldName]
-               } else {
-                  // ?
-                  query[fieldName] = query[fieldName]
-               }
-            }
-
-            const values = await service.__findMany(context, {
-               where: query,
-            })
-            publish(service, 'findMany', values)
-            res.json(values)
-         } catch(err) {
-            console.log('callErr', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.get(`${path}/:id`, async (req, res) => {
-         context.http.req = req
-         try {
-            const value = await service.__findUnique(context, {
-               where: {
-                  id: parseInt(req.params.id)
-               }
-            })
-            publish(service, 'findUnique', value)
-            res.json(value)
-         } catch(err) {
-            console.log('callErr', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.patch(`${path}/:id`, async (req, res) => {
-         context.http.req = req
-         try {
-            const value = await service.__update(context, {
-               where: {
-                  id: parseInt(req.params.id),
-               },
-               data: req.body,
-            })
-            publish(service, 'update', value)
-            res.json(value)
-         } catch(err) {
-            console.log('callErr', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.delete(`${path}/:id`, async (req, res) => {
-         context.http.req = req
-         try {
-            const value = await service.__delete(context, {
-               where: {
-                  id: parseInt(req.params.id)
-               }
-            })
-            publish(service, 'delete', value)
-            res.json(value)
-         } catch(err) {
-            console.log('callErr', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      if (options.debug) console.log(`added HTTP endpoints for service '${service.name}' at path '${path}'`)
-   }
-
-   /*
-    * Create HTTP server
-   */
-   const server = new http.Server(app)
-
-   if (options.ws) {
-      /*
-      * Add websocket transport
-      */
-      const io = new Server(server)
-      
-      io.on('connection', function(socket) {
-         if (options.debug) console.log('Client connected to the WebSocket')
-         const connection = {
-            id: lastConnectionId++,
-            socket,
-            channelNames: new Set(),
-         }
-         // store connection in cache 
-         connections[connection.id] = connection
-         if (options.debug) console.log('active connections', Object.keys(connections))
-
-         // emit 'connection' event for app (expressjs extends EventEmitter)
-         app.emit('connection', connection)
-
-         // send 'connected' event to client
-         socket.emit('connected', connection.id)
-
-         socket.on('disconnect', () => {
-            if (options.debug) console.log('Client disconnected', connection.id)
-            delete connections[connection.id]
-         })
-
-
-         /*
-         * Handle websocket client request
-         * Emit in return a 'client-response' message
-         */
-         socket.on('client-request', async ({ uid, name, action, args }) => {
-            if (options.debug) console.log("client-request", uid, name, action, args)
-            if (name in services) {
-               const service = services[name]
-               try {
-                  const serviceMethod = service['__' + action]
-                  if (serviceMethod) {
-                     const context = {
-                        app,
-                        ws: { connection, name, action, args },
-                     }
-
-                     try {
-                        const result = await serviceMethod(context, ...args)
-                        socket.emit('client-response', {
-                           uid,
-                           result,
-                        })
-                        // pub/sub: send event on associated channels
-                        publish(service, action, result)
-                     } catch(err) {
-                        console.log('callErr', err)
-                        io.emit('client-response', {
-                           uid,
-                           error: err.toString(),
-                        })
-                     }
-                  } else {
-                     io.emit('client-response', {
-                        uid,
-                        error: `there is no method named '${action}' for service '${name}'`,
-                     })
-                  }
-               } catch(error) {
-                  io.emit('client-response', {
-                     uid,
-                     error,
-                  })
-               }
-            } else {
-               io.emit('client-response', {
-                  uid,
-                  error: `there is no service named '${name}'`,
-               })
-            }
-         })
-      })      
-   }
-
-   // publish event on associated channels
-   async function publish(service, action, result) {
-      console.log('PUB!')
-      const publishFunc = service.publishCallback
-      if (publishFunc) {
-         const channelNames = await publishFunc(result, app)
-         if (options.debug) console.log('publish channels', service.name, action, channelNames)
-         for (const channelName of channelNames) {
-            if (options.debug) console.log('service-event', service.name, action, channelName)
-            const connectionList = Object.values(connections).filter(cnx => cnx.channelNames.has(channelName))
-            for (const connection of connectionList) {
-               if (options.debug) console.log('emit to', connection.id, service.name, action, result)
-               connection.socket.emit('service-event', {
-                  name: service.name,
-                  action,
-                  result,
-               })
-            }
-         }
-      }
-   }
-
-   function joinChannel(channelName, connection) {
-      connection.channelNames.add(channelName)
-   }
-
-   function leaveChannel(channelName, connection) {
-      connection.channelNames.delete(channelName)
-   }
-
-   // enhance `app` with objects and methods
-   Object.assign(app, {
-      options,
-      createDatabaseService,
-      createService,
-      service,
-      configure,
-      addHttpRest,
-      server,
-      joinChannel,
-      leaveChannel,
-   })
-   return app
+   hashPassword,
+   protect,
+   setSessionJWT,
 }
-
-export default expressX

package/src/server.mjs

@@ -0,0 +1,378 @@
+
+import http from 'http'
+import { Server } from "socket.io"
+import { PrismaClient } from '@prisma/client'
+
+/*
+ * Enhance `app` express application with Feathers-like services
+ */
+export function expressXServer(app, options={}) {
+
+   if (options.debug === undefined) options.debug = false
+   if (options.ws === undefined) options.ws = { ws_prefix: "expressx" }
+
+   const services = {}
+   const connections = {}
+
+   let lastConnectionId = 1
+
+   /*
+    * 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]
+
+      const service = createService(name, methods)
+      
+      service.prisma = prisma
+      service.entity = prismaOptions.entity
+      
+      if (options.debug) console.log(`created service '${name}' over table '${prismaOptions.entity}'`)
+      return service
+   }
+
+   /*
+    * create a service `name` with given `methods`
+    */
+   function createService(name, methods) {
+      const service = { name }
+
+      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) => {
+            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
+
+            // call 'before' hooks, modifying `context.args`
+            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 })
+            }
+
+            // call method
+            const result = await method(...context.args)
+            // if (options.debug) console.log('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 })
+            }
+            return result
+         }
+
+         // hooked version of method: `create`, etc., to be called from backend with no context
+         service[methodName] = method
+
+         // un-hooked version of method: `_create`, etc., to be called from backend with no context
+         service['_' + methodName] = method
+      }
+
+      // attach pub/sub publish callback
+      service.publish = async (func) => {
+         service.publishCallback = func
+      },
+
+      // attach hooks
+      service.hooks = (hooks) => {
+         service.hooks = hooks
+      }
+
+      // cache service in `services`
+      services[name] = service
+      return service
+   }
+
+   // `app.service(name)` starts here!
+   function service(name) {
+      // get service from `services` cache
+      if (name in services) return services[name]
+      throw Error(`there is no service named '${name}'`)
+   }
+
+   function configure(callback) {
+      callback(app)
+   }
+
+   /*
+    * add an HTTP REST endpoint at `path`, based on `service`
+    */
+   async function addHttpRest(path, service) {
+      const context = {
+         app,
+         http: { name: service.name }
+      }
+
+      // introspect table schema
+      async function getFieldTypes() {
+         const fieldTypes = {}
+         if (service.prisma._activeProvider === 'sqlite') {
+            const fieldInfo = await service.prisma.$queryRawUnsafe(`
+               PRAGMA table_info(${service.entity})
+            `)
+            fieldInfo.forEach(column => {
+               fieldTypes[column.name] = column.type.toLowerCase()
+            })
+         } else if (service.prisma._activeProvider === 'postgresql') {
+            const fieldInfo = await service.prisma.$queryRawUnsafe(`
+               SELECT column_name, data_type
+               FROM information_schema.columns
+               WHERE table_name = '${service.entity}';
+            `)
+            fieldInfo.forEach(column => {
+               fieldTypes[column.column_name] = column.data_type
+            })
+         }
+         return fieldTypes
+      }
+
+
+      app.post(path, async (req, res) => {
+         if (options.debug) console.log("http request POST", req)
+         context.http.req = req
+         try {
+            const value = await service.__create(context, { data: req.body })
+            publish(service, 'create', value)
+            res.json(value)
+         } catch(err) {
+            console.log('callErr', err)
+            res.status(500).send(err.toString())
+         }
+      })
+
+      app.get(path, async (req, res) => {
+         if (options.debug) console.log("http request GET", req)
+         context.http.req = req
+         const query = { ...req.query }
+         try {
+            // the values in `req.query` are all strings, but Prisma need proper types
+            // we need to introspect column types and do the proper transtyping
+            for (const fieldName in query) {
+               if (!service.fieldTypes) service.fieldTypes = await getFieldTypes()
+               const fieldType = service.fieldTypes[fieldName]
+
+               if (fieldType === 'integer') {
+                  query[fieldName] = parseInt(query[fieldName])
+               } else if (fieldType === 'numeric') {
+                  query[fieldName] = parseFloat(query[fieldName])
+               } else if (fieldType === 'boolean') {
+                  query[fieldName] = (query[fieldName] === 't') ? true : false
+               } else if (fieldType === 'text' || fieldType === 'character varying') {
+                  query[fieldName] = query[fieldName]
+               } else {
+                  // ?
+                  query[fieldName] = query[fieldName]
+               }
+            }
+
+            const values = await service.__findMany(context, {
+               where: query,
+            })
+            publish(service, 'findMany', values)
+            res.json(values)
+         } catch(err) {
+            console.log('callErr', err)
+            res.status(500).send(err.toString())
+         }
+      })
+
+      app.get(`${path}/:id`, async (req, res) => {
+         if (options.debug) console.log("http request GET", req)
+         context.http.req = req
+         try {
+            const value = await service.__findUnique(context, {
+               where: {
+                  id: parseInt(req.params.id)
+               }
+            })
+            publish(service, 'findUnique', value)
+            res.json(value)
+         } catch(err) {
+            console.log('callErr', err)
+            res.status(500).send(err.toString())
+         }
+      })
+
+      app.patch(`${path}/:id`, async (req, res) => {
+         if (options.debug) console.log("http request PATCH", req)
+         context.http.req = req
+         try {
+            const value = await service.__update(context, {
+               where: {
+                  id: parseInt(req.params.id),
+               },
+               data: req.body,
+            })
+            publish(service, 'update', value)
+            res.json(value)
+         } catch(err) {
+            console.log('callErr', err)
+            res.status(500).send(err.toString())
+         }
+      })
+
+      app.delete(`${path}/:id`, async (req, res) => {
+         if (options.debug) console.log("http request DELETE", req)
+         context.http.req = req
+         try {
+            const value = await service.__delete(context, {
+               where: {
+                  id: parseInt(req.params.id)
+               }
+            })
+            publish(service, 'delete', value)
+            res.json(value)
+         } catch(err) {
+            console.log('callErr', err)
+            res.status(500).send(err.toString())
+         }
+      })
+
+      if (options.debug) console.log(`added HTTP endpoints for service '${service.name}' at path '${path}'`)
+   }
+
+   /*
+    * Create HTTP server
+   */
+   const server = new http.Server(app)
+
+   if (options.ws) {
+      /*
+      * Add websocket transport
+      */
+      const io = new Server(server)
+      
+      io.on('connection', function(socket) {
+         if (options.debug) console.log('Client connected to the WebSocket')
+         const connection = {
+            id: lastConnectionId++,
+            socket,
+            channelNames: new Set(),
+         }
+         // store connection in cache 
+         connections[connection.id] = connection
+         if (options.debug) console.log('active connections', Object.keys(connections))
+
+         // emit 'connection' event for app (expressjs extends EventEmitter)
+         app.emit('connection', connection)
+
+         // send 'connected' event to client
+         socket.emit('connected', connection.id)
+
+         socket.on('disconnect', () => {
+            if (options.debug) console.log('Client disconnected', connection.id)
+            delete connections[connection.id]
+         })
+
+
+         /*
+         * Handle websocket client request
+         * Emit in return a 'client-response' message
+         */
+         socket.on('client-request', async ({ uid, name, action, args }) => {
+            if (options.debug) console.log("client-request", uid, name, action, args)
+            if (name in services) {
+               const service = services[name]
+               try {
+                  const serviceMethod = service['__' + action]
+                  if (serviceMethod) {
+                     const context = {
+                        app,
+                        ws: { connection, name, action, args },
+                     }
+
+                     try {
+                        const result = await serviceMethod(context, ...args)
+                        socket.emit('client-response', {
+                           uid,
+                           result,
+                        })
+                        // pub/sub: send event on associated channels
+                        publish(service, action, result)
+                     } catch(err) {
+                        console.log('callErr', err)
+                        io.emit('client-response', {
+                           uid,
+                           error: err.toString(),
+                        })
+                     }
+                  } else {
+                     io.emit('client-response', {
+                        uid,
+                        error: `there is no method named '${action}' for service '${name}'`,
+                     })
+                  }
+               } catch(error) {
+                  io.emit('client-response', {
+                     uid,
+                     error,
+                  })
+               }
+            } else {
+               io.emit('client-response', {
+                  uid,
+                  error: `there is no service named '${name}'`,
+               })
+            }
+         })
+      })      
+   }
+
+   // publish event on associated channels
+   async function publish(service, action, result) {
+      const publishFunc = service.publishCallback
+      if (publishFunc) {
+         const channelNames = await publishFunc(result, app)
+         if (options.debug) console.log('publish channels', service.name, action, channelNames)
+         for (const channelName of channelNames) {
+            if (options.debug) console.log('service-event', service.name, action, channelName)
+            const connectionList = Object.values(connections).filter(cnx => cnx.channelNames.has(channelName))
+            for (const connection of connectionList) {
+               if (options.debug) console.log('emit to', connection.id, service.name, action, result)
+               connection.socket.emit('service-event', {
+                  name: service.name,
+                  action,
+                  result,
+               })
+            }
+         }
+      }
+   }
+
+   function joinChannel(channelName, connection) {
+      connection.channelNames.add(channelName)
+   }
+
+   function leaveChannel(channelName, connection) {
+      connection.channelNames.delete(channelName)
+   }
+
+   // enhance `app` with objects and methods
+   return Object.assign(app, {
+      options,
+      createDatabaseService,
+      createService,
+      service,
+      configure,
+      addHttpRest,
+      server,
+      joinChannel,
+      leaveChannel,
+   })
+}

package/test/index.test.js

@@ -1,25 +1,29 @@
 
-import expressX from '../src/index.mjs'
 import express from 'express'
 import bodyParser from 'body-parser'
 import axios from 'axios'
+import io from 'socket.io-client'
 
-import { expect, assert } from 'chai'
+
+import { assert } from 'chai'
+
+import { expressXServer, expressXClient } from '../src/index.mjs'
 
 
 // `app` is a regular express application, enhanced with express-x features
-const app = expressX(express(), { debug: false })
+const app = expressXServer(express(), { debug: false })
 
 app.createDatabaseService('User')
 app.createDatabaseService('Post')
 
 
 
-describe('ExpressX API', () => {
+describe('ExpressX API (no running server)', () => {
 
    it("can delete all users", async () => {
       const res = await app.service('User').deleteMany()
-      assert(res.count === 1)
+      console.log('res delete', res)
+      assert(res.count >= 0)
    })
 
    it("can create a user", async () => {
@@ -56,17 +60,19 @@ describe('ExpressX API', () => {
 
 describe('HTTP/REST API', () => {
 
-   // add body parsers for http requests
-   app.use(bodyParser.json())
-   app.use(bodyParser.urlencoded({ extended: false }))
+   let chris
 
-   // add http/rest endpoints
-   app.addHttpRest('/api/user', app.service('User'))
-   app.addHttpRest('/api/post', app.service('Post'))
+   before(() => {
+      // add body parsers for http requests
+      app.use(bodyParser.json())
+      app.use(bodyParser.urlencoded({ extended: false }))
 
-   app.server.listen(8008, () => console.log(`App listening at http://localhost:8008`))
+      // add http/rest endpoints
+      app.addHttpRest('/api/user', app.service('User'))
+      app.addHttpRest('/api/post', app.service('Post'))
 
-   let chris
+      app.server.listen(8008, () => console.log(`App listening at http://localhost:8008`))
+   })
 
    it("can create a user", async () => {
       const res = await axios.post('http://localhost:8008/api/user', {
@@ -104,7 +110,36 @@ describe('HTTP/REST API', () => {
       assert(res?.data?.name === "Christophe")
    })
 
-   it("can stop server", () => {
-      app.server.close()
+   after(async () => {
+      await app.server.close()
+   })
+})
+
+
+// test compatibility with `express-x-client`
+describe('Client API', () => {
+
+   let clientApp, socket
+
+   before(() => {
+      app.server.listen(8008, () => console.log(`App listening at http://localhost:8008`))
+
+      socket = io('http://localhost:8008', { transports: ["websocket"] })
+      clientApp = expressXClient(socket)
+   })
+
+   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()
    })
 })