@jcbuisson/express-x-client 1.0.9 → 1.5.1

package/package.json

@@ -1,21 +1,25 @@
 {
   "name": "@jcbuisson/express-x-client",
-  "version": "1.0.9",
-  "description": "",
+  "version": "1.5.1",
   "type": "module",
+  "description": "Client library for ExpressX framework",
   "main": "src/index.mjs",
-  "repository": {
-    "type": "git",
-    "url": "git@gitlab.com:buisson31/express-x-client.git"
+  "test": "node --test",
+  "scripts": {
+    "test": "node --test",
+    "generate": "npx prisma generate",
+    "migrate": "npx prisma migrate dev --name init"
   },
-  "author": "Jean-Christophe Buisson <buisson@enseeiht.fr> (jcbuisson.dev)",
-  "license": "MIT",
-  "private": false,
   "keywords": [],
+  "author": "",
+  "license": "ISC",
   "dependencies": {
-    "socket.io-client": "^4.6.0",
+    "@jcbuisson/express-x": "^1.4.0",
+    "@prisma/client": "^4.16.1",
+    "axios": "^1.4.0",
+    "body-parser": "^1.20.2",
+    "prisma": "^4.16.1",
+    "socket.io-client": "^4.7.1",
     "uuid": "^9.0.0"
-  },
-  "devDependencies": {
   }
 }

package/prisma/migrations/20230629052809_init/migration.sql

@@ -0,0 +1,17 @@
+-- CreateTable
+CREATE TABLE "User" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "name" TEXT NOT NULL,
+    "email" TEXT NOT NULL
+);
+
+-- CreateTable
+CREATE TABLE "Post" (
+    "id" INTEGER NOT NULL PRIMARY KEY AUTOINCREMENT,
+    "text" TEXT NOT NULL,
+    "authorId" INTEGER NOT NULL,
+    CONSTRAINT "Post_authorId_fkey" FOREIGN KEY ("authorId") REFERENCES "User" ("id") ON DELETE CASCADE ON UPDATE CASCADE
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "User_email_key" ON "User"("email");

package/prisma/migrations/migration_lock.toml

@@ -0,0 +1,3 @@
+# Please do not edit this file manually
+# It should be added in your version-control system (i.e. Git)
+provider = "sqlite"

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

@@ -1,7 +1,8 @@
 
 import { v4 } from 'uuid'
 
-function expressxClient(socket) {
+export default function expressXClient(socket, options={}) {
+   if (options.debug === undefined) options.debug = false
 
    const waitingPromisesByUid = {}
    const action2service2handlers = {}
@@ -18,13 +19,66 @@ function expressxClient(socket) {
 
    // on connection
    socket.on("connected", async (connectionId) => {
-      console.log('connected', connectionId)
+      if (options.debug) console.log('connected', connectionId)
+      // look in sessionStorage for a previously stored connection id
+      const prevConnectionId = sessionStorage.getItem('expressx-cnx-id')
+      if (prevConnectionId) {
+         // it's a reconnection
+         if (prevConnectionId < 0) {
+            // ask server to transfer all data from connection `prevConnectionId` to connection `connectionId`
+            if (options.debug) console.log('cnx-transfer', -prevConnectionId, 'to', connectionId)
+            socket.emit('cnx-transfer', {
+               from: -prevConnectionId,
+               to: connectionId,
+            })
+         } else {
+            if (options.debug) console.log('Error, previous connection id should be negative', prevConnectionId)
+         }
+
+      } else {
+         // set/update connection id in sessionStorage
+         sessionStorage.setItem('expressx-cnx-id', connectionId)
+      }
+      // call user-defined connection callback
       if (onConnectionCallback) onConnectionCallback(connectionId)
    })
 
+   socket.on("cnx-transfer-ack", async (connectionId) => {
+      if (options.debug) console.log('cnx-transfer-ack', connectionId)
+      sessionStorage.setItem('expressx-cnx-id', connectionId)
+   })
+
+
+   // A negative value for session storage 'expressx-cnx-id' means that the connection with the server has been lost
+   // Requests must wait until it goes positive again
+
+   // disconnection due to network issues
+   socket.on("disconnect", async (cause) => {
+      // alert('disconnect')
+      const id = sessionStorage.getItem('expressx-cnx-id')
+      if (id > 0) {
+         sessionStorage.setItem('expressx-cnx-id', -id)
+         sessionStorage.setItem('cause1', 'disconnect')
+      } else {
+         if (options.debug) console.log('Error (disconnect), connection id should be negative', id)
+      }
+   })
+
+   // disconnection due to a page reload
+   window.addEventListener('unload', () => {
+      const id = sessionStorage.getItem('expressx-cnx-id')
+      if (id > 0) {
+         sessionStorage.setItem('expressx-cnx-id', -id)
+         sessionStorage.setItem('cause2', 'unload')
+      } else {
+         if (options.debug) console.log('Error (unload), connection id should be negative', id)
+      }
+   })
+
+
    // on receiving response from service request
    socket.on('client-response', ({ uid, error, result }) => {
-      console.log('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) {
@@ -43,18 +97,32 @@ function expressxClient(socket) {
       if (handler) handler(result)
    })
 
+   function wait(ms) {
+      return new Promise(resolve => setTimeout(resolve, ms));
+   }
+
    async function serviceMethodRequest(name, action, ...args) {
-      const uid = v4()
+      // wait while session storage 'expressx-cnx-id' is negative (= connection is lost with server)
+      let retries = 10
+      while (retries-- > 0) {
+         const id = sessionStorage.getItem('expressx-cnx-id')
+         if (id > 0) break
+         await wait(200)
+      }
+      if (retries === 0) throw new Error(`Timeout waiting for reconnection`)
+
       // create a promise which will resolve or reject by an event 'client-response'
+      const uid = v4()
       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}`)
+            reject(`Error: timeout on service '${name}', action '${action}', args: ${JSON.stringify(args)}`)
          }, 5000)
       })
       // send request to server through websocket
+      if (options.debug) console.log('client-request', uid, name, action, args)
       socket.emit('client-request', {
          uid,
          name,
@@ -92,5 +160,3 @@ function expressxClient(socket) {
       service,
    }
 }
-
-export default expressxClient

package/test/index.test.js

@@ -0,0 +1,136 @@
+
+import bodyParser from 'body-parser'
+import axios from 'axios'
+import io from 'socket.io-client'
+import { PrismaClient } from '@prisma/client'
+
+
+import { describe, it, before, after } from 'node:test'
+import { strict as assert } from 'node:assert'
+
+import { expressX } from '@jcbuisson/express-x'
+import expressXClient from '../src/index.mjs'
+
+const prisma = new PrismaClient({
+   datasources: {
+      db: {
+         url: "file:./dev.db",
+      },
+   },
+})
+
+// `app` is a regular express application, enhanced with services and real-time features
+const app = expressX(prisma)
+
+
+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()
+   })
+})
+
+
+// test compatibility with client API
+describe('Client API', () => {
+
+   let clientApp, socket
+
+   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: {
+            name: "chris",
+            email: 'chris@mail.fr'
+         },
+      })
+      assert(user.name === 'chris')
+   })
+
+   after(async () => {
+      await socket.close()
+      await app.server.close()
+   })
+})