@jcbuisson/express-x 1.3.3 → 1.3.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.3.3",
+  "version": "1.3.5",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",
@@ -12,7 +12,7 @@
   "license": "MIT",
   "private": false,
   "scripts": {
-    "test": "mocha --require esm 'test/**/*.test.js'",
+    "test": "node --test",
     "generate": "npx prisma generate",
     "migrate": "npx prisma migrate dev --name init"
   },
@@ -23,12 +23,7 @@
     "axios": "^1.4.0",
     "bcrypt": "^5.1.0",
     "config": "^3.3.9",
-    "esm": "^3.2.25",
     "express": "^4.18.2",
     "socket.io": "^4.6.0"
-  },
-  "devDependencies": {
-    "chai": "^4.3.7",
-    "mocha": "^10.2.0"
   }
 }

package/src/server.mjs

@@ -19,9 +19,9 @@ export function expressX(options = {}) {
    let lastConnectionId = 1
 
    // logging function - a winston logger must be configured first
-   app.log = (severity, ...messages) => {
+   app.log = (severity, message) => {
       const logger = app.get('logger')
-      if (logger) logger.log(severity, ...messages)
+      if (logger) logger.log(severity, message)
    }
 
    /*
@@ -74,8 +74,8 @@ export function expressX(options = {}) {
 
             // call method
             const result = await method(...context.args)
-            app.log('debug', 'result', result)
-
+            app.log('debug', `result ${result}`)
+   
             // call 'after' hooks
             const afterMethodHooks = service?.hooks?.after && service.hooks.after[methodName] || []
             const afterAllHooks = service?.hooks?.after?.all || []
@@ -127,81 +127,68 @@ export function expressX(options = {}) {
          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
+      // introspect schema
+      async function getTypesMap() {
+         const dmmf = await service.prisma._getDmmf()
+         const fieldDescriptions = dmmf.modelMap[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)
+         app.log('verbose', `http request POST ${req.url}`)
          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)
+            app.log('error', err)
             res.status(500).send(err.toString())
          }
       })
 
       app.get(path, async (req, res) => {
-         app.log('verbose', "http request GET", req.url)
+         app.log('verbose', `http request GET ${req.url}`)
          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]
+               const typesDict = await getTypesMap()
+               const fieldType = typesDict[fieldName]
 
-               if (fieldType === 'integer') {
+               if (fieldType === 'Int') {
                   query[fieldName] = parseInt(query[fieldName])
-               } else if (fieldType === 'numeric') {
+               } else if (fieldType === 'Float') {
                   query[fieldName] = parseFloat(query[fieldName])
-               } else if (fieldType === 'boolean') {
+               } else if (fieldType === 'Boolean') {
                   query[fieldName] = (query[fieldName] === 't') ? true : false
-               } else if (fieldType === 'text' || fieldType === 'character varying') {
+               } else if (fieldType === 'String') {
                   query[fieldName] = query[fieldName]
                } else {
                   // ?
                   query[fieldName] = query[fieldName]
                }
             }
-
+            // call __findMany
             const values = await service.__findMany(context, {
                where: query,
             })
             publish(service, 'findMany', values)
             res.json(values)
          } catch(err) {
-            console.log('callErr', 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)
+         app.log('verbose', `http request GET ${req.url}`)
          context.http.req = req
          try {
             const value = await service.__findUnique(context, {
@@ -212,13 +199,13 @@ export function expressX(options = {}) {
             publish(service, 'findUnique', value)
             res.json(value)
          } catch(err) {
-            console.log('callErr', 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)
+         app.log('verbose', `http request PATCH ${req.url}`)
          context.http.req = req
          try {
             const value = await service.__update(context, {
@@ -230,13 +217,13 @@ export function expressX(options = {}) {
             publish(service, 'update', value)
             res.json(value)
          } catch(err) {
-            console.log('callErr', 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)
+         app.log('verbose', `http request DELETE ${req.url}`)
          context.http.req = req
          try {
             const value = await service.__delete(context, {
@@ -247,7 +234,7 @@ export function expressX(options = {}) {
             publish(service, 'delete', value)
             res.json(value)
          } catch(err) {
-            console.log('callErr', err)
+            app.log('error', err)
             res.status(500).send(err.toString())
          }
       })
@@ -275,7 +262,7 @@ export function expressX(options = {}) {
          }
          // store connection in cache 
          connections[connection.id] = connection
-         app.log('verbose', 'active connections', Object.keys(connections))
+         app.log('verbose', `active connections ${Object.keys(connections)}`)
 
          // emit 'connection' event for app (expressjs extends EventEmitter)
          app.emit('connection', connection)
@@ -284,7 +271,7 @@ export function expressX(options = {}) {
          socket.emit('connected', connection.id)
 
          socket.on('disconnect', () => {
-            app.log('verbose', 'Client disconnected', connection.id)
+            app.log('verbose', `Client disconnected ${connection.id}`)
             delete connections[connection.id]
          })
 
@@ -294,7 +281,7 @@ export function expressX(options = {}) {
          * Emit in return a 'client-response' message
          */
          socket.on('client-request', async ({ uid, name, action, args }) => {
-            app.log('verbose', "client-request", uid, name, action, args)
+            app.log('verbose', `client-request ${uid} ${name} ${action} ${args}`)
             if (name in services) {
                const service = services[name]
                try {
@@ -314,7 +301,7 @@ export function expressX(options = {}) {
                         // pub/sub: send event on associated channels
                         publish(service, action, result)
                      } catch(err) {
-                        console.log('callErr', err)
+                        app.log('error', err)
                         io.emit('client-response', {
                            uid,
                            error: err.toString(),
@@ -347,12 +334,12 @@ export function expressX(options = {}) {
       const publishFunc = service.publishCallback
       if (publishFunc) {
          const channelNames = await publishFunc(result, app)
-         app.log('verbose', 'publish channels', service.name, action, channelNames)
+         app.log('verbose', `publish channels ${service.name} ${action} ${channelNames}`)
          for (const channelName of channelNames) {
-            app.log('verbose', 'service-event', service.name, action, channelName)
+            app.log('verbose', `service-event ${service.name} ${action} ${channelName}`)
             const connectionList = Object.values(connections).filter(cnx => cnx.channelNames.has(channelName))
             for (const connection of connectionList) {
-               app.log('verbose', 'emit to', connection.id, service.name, action, result)
+               app.log('verbose', `emit to ${connection.id} ${service.name} ${action} ${result}`)
                connection.socket.emit('service-event', {
                   name: service.name,
                   action,

package/test/index.test.js

@@ -4,7 +4,9 @@ import axios from 'axios'
 import io from 'socket.io-client'
 
 
-import { assert } from 'chai'
+// import { assert } from 'chai'
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test'
+import { strict as assert } from 'node:assert'
 
 import { expressX, expressXClient } from '../src/index.mjs'
 
@@ -12,13 +14,18 @@ import { expressX, expressXClient } from '../src/index.mjs'
 // `app` is a regular express application, enhanced with services and real-time features
 const app = expressX()
 
-app.createDatabaseService('User')
-app.createDatabaseService('Post')
-
 
 
 describe('ExpressX API (no running server)', () => {
 
+   before(async () => {
+      app.createDatabaseService('User')
+      app.createDatabaseService('Post')
+
+      await app.service('User').deleteMany()
+      await app.service('Post').deleteMany()
+   })
+
    it("can delete all users", async () => {
       const res = await app.service('User').deleteMany()
       console.log('res delete', res)
@@ -61,24 +68,41 @@ describe('HTTP/REST API', () => {
 
    let chris
 
-   before(() => {
+   before(async () => {
+      console.log("before")
       // add body parsers for http requests
       app.use(bodyParser.json())
       app.use(bodyParser.urlencoded({ extended: false }))
 
+      app.createDatabaseService('User')
+      app.createDatabaseService('Post')
+
+      await app.service('User').deleteMany()
+      await app.service('Post').deleteMany()
+
       // add http/rest endpoints
       app.addHttpRest('/api/user', app.service('User'))
       app.addHttpRest('/api/post', app.service('Post'))
 
-      app.server.listen(8008, () => console.log(`App listening at http://localhost:8008`))
+      await new Promise((resolve) => {
+         app.server.listen(8008, () => {
+            console.log(`App listening at http://localhost:8008`)
+            resolve()
+         })
+      })
+   })
+
+   after(() => {
+      console.log("after")
+      app.server.close()
    })
 
    it("can create a user", async () => {
       const res = await axios.post('http://localhost:8008/api/user', {
-         name: "carole",
-         email: 'carole@mail.fr'
+         name: "chris",
+         email: 'chris@mail.fr'
       })
-      assert(res?.data?.name === 'carole')
+      assert(res?.data?.name === 'chris')
    })
 
    it("can find users", async () => {
@@ -110,23 +134,32 @@ describe('HTTP/REST API', () => {
    })
 
    after(async () => {
-      await app.server.close()
+      app.server.close()
    })
 })
 
 
-// test compatibility with `express-x-client`
+// test compatibility with client API
 describe('Client API', () => {
 
    let clientApp, socket
 
-   before(() => {
-      app.server.listen(8008, () => console.log(`App listening at http://localhost:8008`))
+   before(async () => {
+      await new Promise((resolve) => {
+         app.server.listen(8008, () => {
+            console.log(`App listening at http://localhost:8008`)
+            resolve()
+         })
+      })
 
       socket = io('http://localhost:8008', { transports: ["websocket"] })
       clientApp = expressXClient(socket)
    })
 
+   after(async () => {
+      app.server.close()
+   })
+
    it("can create a user", async () => {
       const user = await clientApp.service('User').create({
          data: {