@jcbuisson/express-x 1.7.10 → 1.7.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.7.10",
+  "version": "1.7.12",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",
@@ -12,14 +12,12 @@
   "license": "MIT",
   "private": false,
   "scripts": {
-    "test": "node --test",
     "generate": "npx prisma generate",
     "migrate": "npx prisma migrate dev --name init"
   },
   "keywords": [],
   "dependencies": {
     "@prisma/client": "^4.10.1",
-    "axios": "^1.4.0",
     "bcryptjs": "^2.4.3",
     "config": "^3.3.9",
     "express": "^4.18.2",

package/src/common-hooks.mjs

@@ -4,14 +4,20 @@ import bcrypt from 'bcryptjs'
 import { getConnectionDataItem } from './context.mjs'
 
 
-// hash password of user record
+/*
+ * Hash password of user record
+ * To be used as an 'after' hook for users service methods
+*/
 export const hashPassword = (passwordField) => async (context) => {
-   // context.result is a user
-   context.result[passwordField] = await bcrypt.hash(context.result[passwordField], 5)
+   const user = context.result
+   user[passwordField] = await bcrypt.hash(user[passwordField], 5)
    return context
 }
 
-// remove `field` from `result`
+
+/*
+ * Remove `field` from `context.result`
+*/
 export function protect(field) {
    return async (context) => {
       if (Array.isArray(context.result)) {
@@ -25,13 +31,11 @@ export function protect(field) {
    }
 }
 
-
-export async function isAuthenticated(context) {
-   // extract sessionId from connection data
-   const sessionId = await getConnectionDataItem(context, 'sessionId')
-   if (!sessionId) throw new Error('not-authenticated')
-}
-
+/*
+ * 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
+ * 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) => {
    const expireAt = await getConnectionDataItem(context, 'expireAt')
    if (expireAt) {

package/src/index.mjs

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

package/src/server.mjs

@@ -97,12 +97,13 @@ export function expressX(prisma, config) {
          // `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'` (ws)
             // or by express (http) and the client will get a rejected promise
 
-            // call 'before' hooks, modifying `context`
+            // call 'before' hooks, possibly modifying `context`
             const beforeAppHooks = appHooks?.before || []
             const beforeMethodHooks = service?.hooks?.before && service.hooks.before[methodName] || []
             const beforeAllHooks = service?.hooks?.before?.all || []
@@ -115,7 +116,7 @@ export function expressX(prisma, config) {
             // put result into context
             context.result = result
 
-            // call 'after' hooks, modifying `context`
+            // call 'after' hooks, possibly modifying `context`
             const afterMethodHooks = service?.hooks?.after && service.hooks.after[methodName] || []
             const afterAllHooks = service?.hooks?.after?.all || []
             const afterAppHooks = appHooks?.after || []
@@ -125,7 +126,7 @@ export function expressX(prisma, config) {
 
             // publish event (websocket transport)
             if (config.WS_TRANSPORT && service.publishFunction) {
-               const channelNames = await service.publishFunction(result, methodName)
+               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) {

package/prisma/schema.prisma

@@ -1,22 +0,0 @@
-generator client {
-   provider = "prisma-client-js"
-}
-
-model User {
-   id          Int       @default(autoincrement()) @id
-   name        String
-   email       String    @unique
-   posts       Post[]
-}
-
-model Post {
-   id          Int       @default(autoincrement()) @id
-   text        String
-   author      User      @relation(fields: [authorId], references: [id], onDelete: Cascade)
-   authorId    Int
-}
-
-datasource db {
-   provider = "sqlite"
-   url      = "file:./dev.db"
-}

package/test/index.test.js

@@ -1,169 +0,0 @@
-
-import bodyParser from 'body-parser'
-import axios from 'axios'
-import { PrismaClient } from '@prisma/client'
-
-
-import { describe, it, before, after, beforeEach, afterEach } from 'node:test'
-import { strict as assert } from 'node:assert'
-
-import { expressX } from '../src/index.mjs'
-
-const prisma = new PrismaClient()
-
-// `app` is a regular express application, enhanced with services and real-time features
-const app = expressX(prisma)
-
-
-
-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)
-      assert(res.count >= 0)
-   })
-
-   it("can create a user", async () => {
-      const user = await app.service('User').create({
-         data: {
-            name: "chris",
-            email: 'chris@mail.fr'
-         },
-      })
-      assert(user.name === 'chris')
-   })
-
-   it("can find a user by name", async () => {
-      const users = await app.service('User').findMany({
-         where: {
-            name: {
-               startsWith: "ch"
-            }
-         }
-      })
-      assert(users.length > 0)
-   })
-
-   it("can find a unique user by email", async () => {
-      const chris = await app.service('User').findUnique({
-         where: {
-            email: "chris@mail.fr"
-         }
-      })
-      assert(chris.name === 'chris')
-   })
-})
-
-
-describe('HTTP/REST API', () => {
-
-   let chris
-
-   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'))
-
-      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: "chris",
-         email: 'chris@mail.fr'
-      })
-      assert(res?.data?.name === 'chris')
-   })
-
-   it("can find users", async () => {
-      const res = await axios.get('http://localhost:8008/api/user')
-      assert(res?.data?.length > 0)
-   })
-
-   it("can find a user by name", async () => {
-      const res = await axios.get('http://localhost:8008/api/user?name=chris')
-      assert(res?.data?.length > 0)
-      chris = res.data[0]
-   })
-
-   it("can find a user by id", async () => {
-      const res = await axios.get(`http://localhost:8008/api/user/${chris.id}`)
-      assert(res?.data?.id === chris.id)
-   })
-
-   it("can patch a user", async () => {
-      const res = await axios.patch(`http://localhost:8008/api/user/${chris.id}`, {
-         name: "Christophe",
-      })
-      assert(res?.data?.name === "Christophe")
-   })
-
-   it("can delete a user", async () => {
-      const res = await axios.delete(`http://localhost:8008/api/user/${chris.id}`)
-      assert(res?.data?.name === "Christophe")
-   })
-
-   after(async () => {
-      app.server.close()
-   })
-})
-
-
-describe('Error codes', () => {
-
-   before(async () => {
-      app.createDatabaseService('User')
-      app.createDatabaseService('Post')
-
-      await app.service('User').deleteMany()
-      await app.service('Post').deleteMany()
-   })
-
-   it("can detect 'missing-service' error", async () => {
-      try {
-         await app.service('users').findMany({})
-      } catch(err) {
-         assert(err.code === 'missing-service')
-      }
-   })
-
-   // it("can detect 'missing-method' error", async () => {
-   //    try {
-   //       await app.service('User').dummyMethod({})
-   //    } catch(err) {
-   //       console.log('err', err)
-   //       assert(err.code === 'missing-method')
-   //    }
-   // })
-
-})