@jcbuisson/express-x 1.8.4 → 2.0.1

package/README.md

@@ -33,23 +33,17 @@ backed in a [Prisma](https://www.prisma.io/) database
 
 ```js
 // app.js
-import bodyParser from 'body-parser'
 import { expressXServer } from '@jcbuisson/express-x'
 
 // `app` is a regular express application, enhanced with service and real-time features
 const app = expressX()
 
-// create two CRUD database services. They provide Prisma methods: `create`, 'createMany', 'find', 'findMany', 'upsert', etc.
-app.createDatabaseService('User')
-app.createDatabaseService('Post')
-
-// add body parsers for http requests
-app.use(bodyParser.json())
-app.use(bodyParser.urlencoded({ extended: false }))
+// configure prisma client from schema
+const prisma = new PrismaClient()
 
-// add http/rest endpoints
-app.addHttpRest('/api/user', app.service('User'))
-app.addHttpRest('/api/post', app.service('Post'))
+// create two CRUD database services. They provide Prisma methods: `create`, 'createMany', 'find', 'findMany', 'upsert', etc.
+app.createService('User', prisma.User)
+app.createService('Post', prisma.Post)
 
 app.server.listen(8000, () => console.log(`App listening at http://localhost:8000`))
 ```
@@ -88,40 +82,18 @@ datasource db {
 
 Then create the database:
 ```bash
-npx prisma migrate dev --name init
+npx prisma db push
 ```
 
 The sqlite database file is created at `prisma/dev.db`
 
 
-## Run the application
+## Run the application on the server side
 
 ```bash
 node app.js
 ```
 
-It prints the following lines in the console:
-```bash
-created service 'user' over entity 'User'
-created service 'post' over entity 'Post'
-added HTTP endpoints for service 'user' at path '/api/user'
-added HTTP endpoints for service 'post' at path '/api/post'
-App listening at http://localhost:8000
-```
-
-
-## Enjoy your HTTP REST API
-
-Now you can try the HTTP endpoints `/api/user` and `/api/post`; open a new console and run HTTP requests:
-```bash
-curl -X POST -H 'Content-Type: application/json' -d '{"name":"JC"}' http://localhost:8000/api/user
-# --> {"id":1,"name":"JC"}
-curl http://localhost:8000/api/user
-# --> [{"id":1,"name":"JC"}]
-```
-
-With a few lines of code, we got a complete REST API over the database tables. But there is more!
-
 
 ## Use it with a websocket client
 
@@ -162,9 +134,9 @@ async function main() {
 main()
 ```
 
-For simplicity we use a node client, but you of course you would write something similar with your favorite front-end framework.
+For simplicity we use a node client, but you would write something similar with your favorite front-end framework.
 
-You can use on the client side the exact same statements on services as you would on the server side, such as: `app.service('User').create(...)`.
+You can use the exact same statements on services on the client side as you would on the server side, such as: `app.service('User').create(...)`.
 Of course the `app` object here on the client is quite different that the `app` object on the server; you can find explanations [here]().
 
 Now run the client script:
@@ -218,11 +190,11 @@ import { PrismaClient } from '@prisma/client'
 const app = expressX()
 
 // configure prisma client from schema
-app.set('prisma', new PrismaClient())
+const prisma = new PrismaClient()
 
 // create two CRUD database services. They provide Prisma methods: `create`, 'createMany', 'find', 'findMany', 'upsert', etc.
-app.createDatabaseService('User')
-app.createDatabaseService('Post')
+app.createService('User', prisma.User)
+app.createService('Post', prisma.Post)
 
 // publish
 app.service('User').publish(async (post, context) => {
@@ -233,9 +205,9 @@ app.service('Post').publish(async (post, context) => {
 })
 
 // subscribe
-app.on('connection', (connection) => {
-   console.log('connection', connection.id)
-   app.joinChannel('anonymous', connection)
+app.on('connection', (socket) => {
+   console.log('connection', socket.id)
+   app.joinChannel('anonymous', socket)
 })
 
 app.server.listen(8000, () => console.log(`App listening at http://localhost:8000`))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.8.4",
+  "version": "2.0.1",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",
@@ -17,7 +17,6 @@
   },
   "keywords": [],
   "dependencies": {
-    "@prisma/client": "^4.10.1",
     "bcryptjs": "^2.4.3",
     "config": "^3.3.9",
     "express": "^4.18.2",

package/src/common-hooks.mjs

@@ -1,8 +1,11 @@
 
 import bcrypt from 'bcryptjs'
 
-import { getConnectionDataItem, resetConnection } from './context.mjs'
 
+export const addTimestamp = (field) => async (context) => {
+   context.result[field] = (new Date()).toISOString()
+   return context
+}
 
 /*
  * Hash password of user record
@@ -33,20 +36,22 @@ export function protect(field) {
 
 /*
  * Does nothing for calls which are not client-side with websocket transport
- * Check if the 'expireAt' key in connection data is met
- * If it is met, throw an error (which will be sent back to the calling server or client) and reset connection data
+ * 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
 */
 export const isNotExpired = async (context) => {
+   // return context
    if (context.caller !== 'client' || context.transport !== 'ws') return
    
-   const expireAt = await getConnectionDataItem(context, 'expireAt')
+   const expireAt = context.socket.data.expireAt
    if (expireAt) {
       const expireAtDate = new Date(expireAt)
       const now = new Date()
       if (now > expireAtDate) {
-         // expiration date is met: clear connection data & throw exception
-         await resetConnection(context)
+         // expiration date is met: clear socket.data & throw exception
+         const { clientIP } = socket.data
+         socket.data = { clientIP }
          throw new Error('session-expired')
       }
    } else {

package/src/index.mjs

@@ -1,20 +1,11 @@
 
 import { expressX } from './server.mjs'
-import { hashPassword, protect, isNotExpired } from './common-hooks.mjs'
-import { getContextConnection, resetConnection, getConnectionDataItem, setConnectionDataItem, removeConnectionDataItem, sendServiceEventToClient } from './context.mjs'
+import { addTimestamp, hashPassword, protect, isNotExpired } from './common-hooks.mjs'
 
 export {
    expressX,
 
-   getContextConnection,
-   resetConnection,
-   
-   getConnectionDataItem,
-   setConnectionDataItem,
-   removeConnectionDataItem,
-   
-   sendServiceEventToClient,
-
+   addTimestamp,
    hashPassword,
    protect,
    isNotExpired,

package/src/server.mjs

@@ -1,97 +1,146 @@
+import express from "express"
+import { createServer } from "http"
+import { Server } from "socket.io"
 
-import http from 'http'
-import { Server } from 'socket.io'
-import express from 'express'
 
-/*
- * Enhance `app` express application with services and real-time features
- */
+export function expressX(config) {
 
-// export function expressX(prisma, connectionAdapter, options) {
-
-export function expressX(prisma, config) {
+   const services = {}
+   let appHooks = []
 
    const app = express()
+   const httpServer = createServer(app)
 
    // so that config can be accessed anywhere with app.get('config')
    app.set('config', config)
 
-   // websocket transport by default
-   if (config.WS_TRANSPORT == undefined) config.WS_TRANSPORT = true
-
-   const services = {}
-   let appHooks = []
-
-   const cnx2Socket = {}
+   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,
+      }
+   })
 
-   async function createConnection(clientIP) {
-      const connection = await prisma.Connection.create({
-         data: {
-            clientIP,
-         }
-      })
-      return connection
+   // 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)
    }
 
-   function getConnection(id) {
-      return prisma.Connection.findUnique({ where: { id }})
-   }
+   io.on('connection', async function(socket) {
+      if (socket.recovered) {
+         // recovery was successful: socket.id, socket.rooms and socket.data were restored
+         console.log('reconnection!!!', socket.id)
 
-   async function cloneConnection(id, connection) {
-      return await prisma.Connection.update({
-         where: { id },
-         data: {
-            clientIP: connection.clientIP,
-            channelNames: connection.channelNames,
-            data: connection.data,
-         }
-      })
-   }
+      } else {
+         // new or unrecoverable session
+         console.log("connection", socket.id)
+      }
 
-   async function deleteConnection(id) {
-      try {
-         await prisma.Connection.delete({ where: { id }})
-      } catch(err) {
-         // in case it would no longer exist
+      const clientIP = socket.handshake.address
+      socket.data = {
+         clientIP,
       }
-   }
+      // app.log('verbose', `Client connected ${connectionId} from IP ${clientIP}`)
+      app.log('verbose', `Client connected ${socket.id} from IP ${clientIP}`)
 
-   function getSocket(connectionId) {
-      return cnx2Socket[connectionId]
-   }
+      // emit 'connection' event for app (expressjs extends EventEmitter)
+      app.emit('connection', socket)
 
-   function setSocket(connectionId, socket) {
-      cnx2Socket[connectionId] = socket
-   }
+      // send 'connected' event to client
+      // socket.emit('connected', connectionId)
+      socket.emit('connected', socket.id)
 
+      socket.on('disconnect', () => {
+         // app.log('verbose', `Client disconnected ${connectionId}`)
+         app.log('verbose', `Client disconnected ${socket.id}`)
+      })
 
-   // logging function - a winston logger must be configured first
-   app.log = (severity, message) => {
-      const logger = app.get('logger')
-      if (logger) logger.log(severity, message)
-   }
+      /*
+      * 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,
+                  }
 
-   /*
-    * create a service `name` based on Prisma table `entity`
-    */
-   function createDatabaseService(name, prismaOptions = { entity: name }) {
-      // take all prisma methods on `entity` table
-      const methods = prisma[prismaOptions.entity]
-
-      const service = createService(name, methods)
-      
-      service.prisma = prisma
-      service.entity = prismaOptions.entity
-      
-      app.log('info', `created service '${name}' over table '${prismaOptions.entity}'`)
-      return service
-   }
+                  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)
+                     app.log('verbose', err.stack)
+                     socket.emit('client-response', {
+                        uid,
+                        error: {
+                           code: err.code || 'unknown-error',
+                           message: 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.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 = { _name: name }
+      const service = { name }
 
       for (const methodName in methods) {
          const method = methods[methodName]
@@ -115,7 +164,7 @@ export function expressX(prisma, config) {
             }
 
             // call method
-            const result = await method(...context.args)
+            const result = await method(...args)
             // put result into context
             context.result = result
 
@@ -127,29 +176,22 @@ export function expressX(prisma, config) {
                await hook(context)
             }
 
-            // publish event (websocket transport)
-            if (config.WS_TRANSPORT && service.publishFunction) {
+            // 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 ${service._name} ${methodName} ${channelNames}`)
-               const connections = await app.prisma.Connection.findMany({})
-               for (const channelName of channelNames) {
-                  app.log('verbose', `service-event ${service._name} ${methodName} ${channelName}`)
-                  const connectionList = connections.filter(connection => {
-                     const channelNames = JSON.parse(connection.channelNames)
-                     return channelNames.includes(channelName)
-                  })
-            
-                  for (const connection of connectionList) {
-                     const trimmedResult = result ? JSON.stringify(result).slice(0, 300) : ''
-                     app.log('verbose', `emit to ${connection.id} ${service._name} ${methodName} ${trimmedResult}`)
-                     const socket = getSocket(connection.id)
-                     // emit service event
-                     socket && socket.emit('service-event', {
-                        name: service._name,
-                        action: methodName,
-                        result,
-                     })
+               app.log('verbose', `publish channels ${service.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: service.name,
+                     action: methodName,
+                     result,
+                  })
                }
             }
             
@@ -185,13 +227,6 @@ export function expressX(prisma, config) {
       return service
    }
 
-   // `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 configure(callback) {
       callback(app)
    }
@@ -201,296 +236,33 @@ export function expressX(prisma, config) {
       appHooks = hooks
    }
 
-   /*
-    * add an HTTP REST endpoint at `path`, based on `service`
-    */
-   async function addHttpRest(path, service) {
-      const context = {
-         app,
-         caller: 'client',
-         transport: 'http',
-         serviceName: service._name,
-
-         // params: { name: service._name }
-      }
-
-      // introspect schema and return a map: field name => prisma type
-      function getTypesMap() {
-         const dmmf = service.prisma._runtimeDataModel
-         const fieldDescriptions = dmmf.models[service._name].fields
-         return fieldDescriptions.reduce((accu, descr) => {
-            accu[descr.name] = descr.type
-            return accu
-         }, {})
-      }
-
-
-      app.post(path, async (req, res) => {
-         app.log('verbose', `http request POST ${req.url}`)
-         context.req = req
-         try {
-            const value = await service.__create(context, { data: req.body })
-            res.json(value)
-         } catch(err) {
-            app.log('error', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.get(path, async (req, res) => {
-         app.log('verbose', `http request GET ${req.url}`)
-         context.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) {
-               const typesDict = getTypesMap()
-               const fieldType = typesDict[fieldName]
-
-               if (fieldType === 'Int') {
-                  query[fieldName] = parseInt(query[fieldName])
-               } else if (fieldType === 'Float') {
-                  query[fieldName] = parseFloat(query[fieldName])
-               } else if (fieldType === 'Boolean') {
-                  query[fieldName] = (query[fieldName] === 't') ? true : false
-               } else if (fieldType === 'String') {
-                  query[fieldName] = query[fieldName]
-               } else {
-                  // ?
-                  query[fieldName] = query[fieldName]
-               }
-            }
-            // call __findMany
-            const values = await service.__findMany(context, {
-               where: query,
-            })
-            res.json(values)
-         } catch(err) {
-            app.log('error', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.get(`${path}/:id`, async (req, res) => {
-         app.log('verbose', `http request GET ${req.url}`)
-         context.req = req
-         try {
-            const value = await service.__findUnique(context, {
-               where: {
-                  id: parseInt(req.params.id)
-               }
-            })
-            res.json(value)
-         } catch(err) {
-            app.log('error', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.patch(`${path}/:id`, async (req, res) => {
-         app.log('verbose', `http request PATCH ${req.url}`)
-         context.req = req
-         try {
-            const value = await service.__update(context, {
-               where: {
-                  id: parseInt(req.params.id),
-               },
-               data: req.body,
-            })
-            res.json(value)
-         } catch(err) {
-            app.log('error', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.delete(`${path}/:id`, async (req, res) => {
-         app.log('verbose', `http request DELETE ${req.url}`)
-         context.req = req
-         try {
-            const value = await service.__delete(context, {
-               where: {
-                  id: parseInt(req.params.id)
-               }
-            })
-            res.json(value)
-         } catch(err) {
-            app.log('error', err)
-            res.status(500).send(err.toString())
-         }
-      })
-
-      app.log('info', `added HTTP endpoints for service '${service._name}' at path '${path}'`)
+   // `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')
    }
 
-   /*
-    * Create HTTP server
-   */
-   const httpServer = new http.Server(app)
-
-   if (config.WS_TRANSPORT) {
-      /*
-      * Add websocket transport
-      */
-      const io = new Server(httpServer, {
-         path: config.WS_PATH || '/socket.io/',
-      })
-      
-      
-      io.on('connection', async function(socket) {
-         const clientIP = socket.request?.connection?.remoteAddress || 'unknown'
-         const connection = await createConnection(clientIP)
-         app.log('verbose', `Client connected ${connection.id} from IP ${clientIP}`)
-
-         setSocket(connection.id, socket)
-
-         // 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', () => {
-            app.log('verbose', `Client disconnected ${connection.id}`)
-
-            // remove connection record after expiration delay, if it still exists
-            setTimeout(async () => {
-               const connectionId = connection.id
-               // check if connection still exists
-               const cnx = await getConnection(connectionId)
-               if (cnx) {
-                  app.log('verbose', `Delete connection ${connectionId}`)
-                  await deleteConnection(connectionId)
-               }
-            }, config.SESSION_EXPIRE_DELAY || 24*60*60000)
-         })
-
-         
-         // handle connection data transfer caused by a disconnection/reconnection (page reload, network issue, etc.)
-         socket.on('cnx-transfer', async ({ from, to }) => {
-            app.log('verbose', `cnx-transfer from ${from} to ${to}`)
-            // copy connection data from 'from' to 'to'
-            const fromConnection = await getConnection(from)
-            if (!fromConnection) return
-            const toConnection = await cloneConnection(to, fromConnection)
-            // associate socket to 'to'
-            setSocket(to, socket)
-            // delete 'from'
-            await deleteConnection(from)
-            // send acknowledge to client
-            socket.emit('cnx-transfer-ack', toConnection)
-         })
-
-         /*
-         * 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 ${connection.id} ${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',
-                        connectionId: connection.id,
-                        serviceName: name,
-                        methodName: action,
-                        args,
-
-                        // params: { connectionId: connection.id, name, action, args },
-                     }
-
-                     try {
-                        const result = await serviceMethod(context, ...args)
-
-                        const trimmedResult = result ? JSON.stringify(result).slice(0, 300) : ''
-                        app.log('verbose', `client-response ${connection.id} ${uid} ${trimmedResult}`)
-                        socket.emit('client-response', {
-                           uid,
-                           result,
-                        })
-                     } catch(err) {
-                        console.log('!!!!!!error', err.code, err)
-                        app.log('verbose', err.stack)
-                        socket.emit('client-response', {
-                           uid,
-                           error: {
-                              code: err.code || 'unknown-error',
-                              message: err.stack,
-                           }
-                        })
-                     }
-                  } else {
-                     socket.emit('client-response', {
-                        uid,
-                        error: {
-                           code: 'missing-method',
-                           message: `there is no method named '${action}' for service '${name}'`,
-                        }
-                     })
-                  }
-               } catch(error) {
-                  console.log('err', err)
-                  app.log('verbose', error.stack)
-                  socket.emit('client-response', {
-                     uid,
-                     error: {
-                        code: err.code || 'unknown-error',
-                        message: error.stack,
-                     }
-                  })
-               }
-            } else {
-               socket.emit('client-response', {
-                  uid,
-                  error: {
-                     code: 'missing-service',
-                     message: `there is no service named '${name}'`,
-                  }
-               })
-            }
-         })
-      })      
-   }
-   
-   async function joinChannel(channelName, connection) {
-      app.log('verbose', `Joining channel ${channelName} ${connection.id}`)
-      const channelNames = JSON.parse(connection.channelNames)
-      if (!channelNames.includes(channelName)) channelNames.push(channelName)
-      await app.prisma.Connection.update({
-         where: { id: connection.id },
-         data: { channelNames: JSON.stringify(channelNames) },
-      })
+   async function joinChannel(channelName, socket) {
+      app.log('verbose', `joining ${channelName}, ${JSON.stringify(socket.data)}`)
+      socket.join(channelName)
    }
 
-   async function leaveChannel(channelName, connection) {
-      app.log('verbose', `Leaving channel ${channelName} ${connection.id}`)
-      const channelNames = JSON.parse(connection.channelNames).filter(name => name !== channelName)
-      await app.prisma.Connection.update({
-         where: { id },
-         data: { channelNames: JSON.stringify(channelNames) },
-      })
+   async function leaveChannel(channelName, socket) {
+      app.log('verbose', `leaving ${channelName}, ${JSON.stringify(socket.data)}`)
+      socket.leave(channelName)
    }
 
-
    // enhance `app` with objects and methods
    return Object.assign(app, {
-      prisma,
-      getSocket, setSocket,
-      createDatabaseService,
+      io,
+      httpServer,
       createService,
       service,
       configure,
       hooks,
-      addHttpRest,
-      httpServer,
       joinChannel,
       leaveChannel,
    })
+
 }

package/src/context.mjs

@@ -1,62 +0,0 @@
-
-export async function getContextConnection(context) {
-   const id = context.connectionId
-   const connection = await context.app.prisma.Connection.findUnique({ where: { id }})
-   return connection
-}
-
-export async function resetConnection(context) {
-   const id = context.connectionId
-   // by using updateMany, we cover the case where the connection `id` no longer exists
-   await context.app.prisma.Connection.updateMany({
-      where: { id },
-      data: {
-         data: '{}',
-         channelNames: '[]',
-      }
-   })
-}
-
-export async function getConnectionDataItem(context, key) {
-   const id = context.connectionId
-   const connection = await context.app.prisma.Connection.findUnique({ where: { id }})
-   const data = JSON.parse(connection.data)
-   return data[key]
-}
-
-export async function setConnectionDataItem(context, key, value) {
-   const id = context.connectionId
-   const connection = await context.app.prisma.Connection.findUnique({ where: { id }})
-   const data = JSON.parse(connection.data)
-   data[key] = value
-   await context.app.prisma.Connection.update({
-      where: { id },
-      data: {
-         data: JSON.stringify(data)
-      }
-   })
-}
-
-export async function removeConnectionDataItem(context, key) {
-   const id = context.connectionId
-   const connection = await context.app.prisma.Connection.findUnique({ where: { id }})
-   const data = JSON.parse(connection.data)
-   delete data[key]
-   await context.app.prisma.Connection.update({
-      where: { id },
-      data: {
-         data: JSON.stringify(data)
-      }
-   })
-}
-
-export async function sendServiceEventToClient(context, name, action, result) {
-   const id = context.connectionId
-   const socket = context.app.cnx2Socket[id]
-   socket.emit('service-event', {
-      name,
-      action,
-      result,
-   })
-
-}