@jcbuisson/express-x-client 1.6.1 → 2.0.0

package/package.json

@@ -1,25 +1,15 @@
 {
   "name": "@jcbuisson/express-x-client",
-  "version": "1.6.1",
+  "version": "2.0.0",
   "type": "module",
   "description": "Client library for ExpressX framework",
   "main": "src/index.mjs",
   "test": "node --test",
   "scripts": {
-    "test": "node --test",
-    "generate": "npx prisma generate",
-    "migrate": "npx prisma migrate dev --name init"
   },
   "keywords": [],
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@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"
   }
 }

package/src/index.mjs

@@ -1,102 +1,51 @@
- 
-export default function expressXClient(socket, options={}) {
-   if (options.debug === undefined) options.debug = false
-   if (options.timeout === undefined) options.timeout = 5000
-
-   const waitingPromisesByUid = {}
-   const action2service2handlers = {}
-   const type2appHandlers = {}
-   let onConnectionCallback = null
-   let onReconnectionCallback = null
-   let onDisconnectionCallback = null
-   let nodeCnxId
-
-   const setConnectionCallback = (callback) => {
-      onConnectionCallback = callback
-   }
 
-   const setReconnectionCallback = (callback) => {
-      onReconnectionCallback = callback
-   }
+function generateUID(length) {
+   const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
+   let uid = '';
 
-   const setDisconnectionCallback = (callback) => {
-      onDisconnectionCallback = callback
+   for (let i = 0; i < length; i++) {
+     const randomIndex = Math.floor(Math.random() * characters.length)
+     uid += characters.charAt(randomIndex)
    }
+   return uid
+}
 
-   function _getCnxId() {
-      if (typeof sessionStorage !== 'undefined') return sessionStorage.getItem('expressx-cnx-id')
-      return nodeCnxId
-   }
 
-   function _setCnxId(id) {
-      if (typeof sessionStorage !== 'undefined') {
-         sessionStorage.setItem('expressx-cnx-id', id)
-      } else {
-         nodeCnxId = id
-      }
-   }
+export default function expressXClient(socket, options={}) {
+   if (options.debug === undefined) options.debug = false
+   if (options.timeout === undefined) options.timeout = 5000
 
-   // on connection
-   socket.on("connected", async (connectionId) => {
-      if (options.debug) console.log('connected', connectionId)
-      // look for a previously stored connection id
-      const prevConnectionId = _getCnxId()
-      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,
-            })
-            // set/update connection id
-            _setCnxId(connectionId)
-         } else {
-            if (options.debug) console.log('Error, previous connection id should be negative', prevConnectionId)
-         }
+   const waitingPromisesByUid = {}
+   const action2service2handlers = {}
+   const socketConnectionState = {}
 
-      } else {
-         // set/update connection id
-         _setCnxId(connectionId)
+   socket.on("connect", async () => {
+      console.log("socket connected", socket.id)
+      if (socketConnectionState.resolve) {
+         socketConnectionState.resolve('ok')
+         socketConnectionState.status = 'connected'
       }
-      // call user-defined connection callback
-      if (onConnectionCallback) onConnectionCallback(connectionId)
    })
 
-   socket.on("cnx-transfer-ack", async (connection) => {
-      if (options.debug) console.log('cnx-transfer-ack', connection)
-      _setCnxId(connection.id)
-      // call user-defined reconnection callback
-      if (onReconnectionCallback) onReconnectionCallback(connection)
-   })
-
-
-   // A negative value for the connexion 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) => {
-      const id = _getCnxId()
-      if (id > 0) {
-         _setCnxId(-id)
-      } else {
-         if (options.debug) console.log('Error (disconnect), connection id should be negative', id)
+   socket.on("error", async () => {
+      console.log("socket connection error", socket.id)
+      if (socketConnectionState.reject) {
+         socketConnectionState.reject(err)
+         socketConnectionState.status = 'error'
       }
    })
 
-   // disconnection due to a page reload
-   if (typeof window !== 'undefined' && 'addEventListener' in window) {
-      window.addEventListener('unload', () => {
-         const id = _getCnxId()
-         if (id > 0) {
-            _setCnxId(-id)
-         } else {
-            if (options.debug) console.log('Error (unload), connection id should be negative', id)
-         }
+   async function socketConnection() {
+      const promise = new Promise((resolve, reject) => {
+         socketConnectionState.resolve = resolve
+         socketConnectionState.reject = reject
       })
+      return promise
    }
 
+   function socketStatus() {
+      return socketConnectionState.status
+   }
 
    // on receiving response from service request
    socket.on('client-response', ({ uid, error, result }) => {
@@ -127,21 +76,8 @@ export default function expressXClient(socket, options={}) {
       const handler = type2appHandlers[type]
       if (handler) handler(value)
    })
-
-   function wait(ms) {
-      return new Promise(resolve => setTimeout(resolve, ms));
-   }
-
+   
    async function serviceMethodRequest(name, action, ...args) {
-      // wait while stored connexion id is negative (= connection is lost with server)
-      let retries = 10
-      while (retries-- > 0) {
-         const id = _getCnxId()
-         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 = generateUID(20)
       const promise = new Promise((resolve, reject) => {
@@ -163,12 +99,6 @@ export default function expressXClient(socket, options={}) {
       return promise
    }
 
-   // define application events handlers
-   function on(type, handler) {
-      if (!type2appHandlers[type]) type2appHandlers[type] = {}
-      type2appHandlers[type] = handler
-   }
-
    function service(name) {
       const service = {
          // associate a handler to a pub/sub event for this service
@@ -192,22 +122,9 @@ export default function expressXClient(socket, options={}) {
    }
 
    return {
-      setConnectionCallback,
-      setReconnectionCallback,
-      setDisconnectionCallback,
+      socketConnection,
+      socketStatus,
       service,
-      on,
    }
 }
 
-
-function generateUID(length) {
-   const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789'
-   let uid = '';
-
-   for (let i = 0; i < length; i++) {
-     const randomIndex = Math.floor(Math.random() * characters.length)
-     uid += characters.charAt(randomIndex)
-   }
-   return uid
-}

package/test/index.test.js

@@ -1,130 +0,0 @@
-
-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()
-
-// `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()
-   })
-})