@jcbuisson/express-x 1.0.22 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jcbuisson/express-x",
-  "version": "1.0.22",
+  "version": "1.1.2",
   "description": "",
   "type": "module",
   "main": "src/index.mjs",
@@ -12,15 +12,21 @@
   "license": "MIT",
   "private": false,
   "scripts": {
-  },
+    "test": "mocha --require esm 'test/**/*.test.js'",
+    "generate": "npx prisma generate",
+    "migrate": "npx prisma migrate dev --name init"
+},
   "keywords": [],
   "dependencies": {
     "@prisma/client": "^4.10.1",
+    "axios": "^1.4.0",
     "config": "^3.3.9",
+    "esm": "^3.2.25",
     "express": "^4.18.2",
     "socket.io": "^4.6.0"
   },
   "devDependencies": {
-    "@types/express": "^4.17.17"
+    "chai": "^4.3.7",
+    "mocha": "^10.2.0"
   }
 }

package/prisma/schema.prisma

@@ -0,0 +1,22 @@
+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/src/index.mjs

@@ -8,7 +8,7 @@ import { PrismaClient } from '@prisma/client'
  */
 function expressX(app, options={}) {
 
-   if (options.debug === undefined) options.debug = true
+   if (options.debug === undefined) options.debug = false
    if (options.ws === undefined) options.ws = { ws_prefix: "expressx" }
 
    const services = {}
@@ -19,62 +19,23 @@ function expressX(app, options={}) {
    /*
     * create a service `name` based on Prisma table `entity`
     */
-   function createDatabaseService(name, { entity=name }) {
+   function createDatabaseService(name, prismaOptions = { entity: name }) {
+
       let prisma = app.get('prisma')
       if (!prisma) {
          prisma = new PrismaClient()
          app.set('prisma', prisma)
       }
-      
-      const service = createService(name, {
-         create: (data) => {
-            if (options.debug) console.log('create', name, data)
-            return prisma[entity].create({
-               data,
-            })
-         },
-
-         get: (id) => {
-            if (options.debug) console.log('get', name, id)
-            return prisma[entity].findUnique({
-               where: {
-                  id,
-               },
-            })
-         },
-
-         patch: (id, data) => {
-            if (options.debug) console.log('patch', name, id, data)
-            return prisma[entity].update({
-               where: {
-                  id,
-               },
-               data,
-            })
-         },
-
-         remove: (id) => {
-            if (options.debug) console.log('remove', name, id)
-            return prisma[entity].delete({
-               where: {
-                  id,
-               },
-            })},
 
-         find: (options) => {
-            if (options.debug) console.log('find', name, options)
-            return prisma[entity].findMany(options)
-         },
+      // take all prisma methods on `entity` table
+      const methods = prisma[prismaOptions.entity]
 
-         upsert: (options) => {
-            if (options.debug) console.log('upsert', name, options)
-            return prisma[entity].upsert(options)
-         },
-      })
+      const service = createService(name, methods)
+      
       service.prisma = prisma
-      service.entity = entity
+      service.entity = prismaOptions.entity
       
-      if (options.debug) console.log(`created service '${name}' over table '${entity}'`)
+      if (options.debug) console.log(`created service '${name}' over table '${prismaOptions.entity}'`)
       return service
    }
 
@@ -86,6 +47,7 @@ function expressX(app, options={}) {
 
       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
@@ -151,16 +113,40 @@ function expressX(app, options={}) {
    /*
     * add an HTTP REST endpoint at `path`, based on `service`
     */
-   function addHttpRest(path, 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, req.body)
+            const value = await service.__create(context, { data: req.body })
             res.json(value)
          } catch(err) {
             console.log('callErr', err)
@@ -170,8 +156,29 @@ function expressX(app, options={}) {
 
       app.get(path, async (req, res) => {
          context.http.req = req
+         const query = { ...req.query }
          try {
-            const values = await service.__find(context, req.body)
+            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,
+            })
             res.json(values)
          } catch(err) {
             console.log('callErr', err)
@@ -182,7 +189,11 @@ function expressX(app, options={}) {
       app.get(`${path}/:id`, async (req, res) => {
          context.http.req = req
          try {
-            const value = await service.__get(context, parseInt(req.params.id))
+            const value = await service.__findUnique(context, {
+               where: {
+                  id: parseInt(req.params.id)
+               }
+            })
             res.json(value)
          } catch(err) {
             console.log('callErr', err)
@@ -193,7 +204,12 @@ function expressX(app, options={}) {
       app.patch(`${path}/:id`, async (req, res) => {
          context.http.req = req
          try {
-            const value = await service.__patch(context, parseInt(req.params.id), req.body)
+            const value = await service.__update(context, {
+               where: {
+                  id: parseInt(req.params.id),
+               },
+               data: req.body,
+            })
             res.json(value)
          } catch(err) {
             console.log('callErr', err)
@@ -204,7 +220,11 @@ function expressX(app, options={}) {
       app.delete(`${path}/:id`, async (req, res) => {
          context.http.req = req
          try {
-            const value = await service.__remove(context, parseInt(req.params.id))
+            const value = await service.__delete(context, {
+               where: {
+                  id: parseInt(req.params.id)
+               }
+            })
             res.json(value)
          } catch(err) {
             console.log('callErr', err)

package/test/index.test.js

@@ -0,0 +1,110 @@
+
+import expressX from '../src/index.mjs'
+import express from 'express'
+import bodyParser from 'body-parser'
+import axios from 'axios'
+
+import { expect, assert } from 'chai'
+
+
+// `app` is a regular express application, enhanced with express-x features
+const app = expressX(express(), { debug: false })
+
+app.createDatabaseService('User')
+app.createDatabaseService('Post')
+
+
+
+describe('ExpressX API', () => {
+
+   it("can delete all users", async () => {
+      const res = await app.service('User').deleteMany()
+      assert('chris' === 'chris')
+   })
+
+   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', () => {
+
+   // add body parsers for http requests
+   app.use(bodyParser.json())
+   app.use(bodyParser.urlencoded({ extended: false }))
+
+   // 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`))
+
+   let chris
+
+   it("can create a user", async () => {
+      const res = await axios.post('http://localhost:8008/api/user', {
+         name: "carole",
+         email: 'carole@mail.fr'
+      })
+      assert(res?.data?.name === 'carole')
+   })
+
+   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")
+   })
+
+   it("can stop server", () => {
+      app.server.close()
+   })
+})