@mixd-id/web-scaffold 0.1.240411106 → 0.1.240411108

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mixd-id/web-scaffold",
   "private": false,
-  "version": "0.1.240411106",
+  "version": "0.1.240411108",
   "scripts": {
     "dev": "vite serve",
     "build": "vite build",

package/src/components/List.vue

@@ -785,7 +785,7 @@ export default{
           const key = kk.substring(1)
           const presetColumn = this.preset.columns.find(_ => _.key === key)
           let value = vv
-          switch(presetColumn.type){
+          switch(presetColumn?.type){
 
             case 'bool':
             case 'boolean':

package/src/utils/wss.js

@@ -63,6 +63,22 @@ const revertDataUrlObj = (obj) => {
   return output
 }
 
+// Expected rejections when a redis client is torn down while commands are
+// still queued (e.g. socket closes mid-subscribe) — safe to ignore.
+const isClosedError = (e) =>
+  e && (e.message === 'Disconnects client' || e.message === 'The client is closed')
+
+const reportError = (e) => {
+  if(isClosedError(e)) return
+  '$report' in process ? process.$report(e) : console.error(e)
+}
+
+const disconnectQuietly = (client) => {
+  if(client && client.isOpen){
+    client.disconnect().catch(reportError)
+  }
+}
+
 class WSS extends EventEmitter2{
 
   _instance
@@ -104,11 +120,23 @@ class WSS extends EventEmitter2{
         port: process.env.REDIS_PORT ?? 6379
       }
     })
-    this._client.connect().then()
+    // Without an 'error' listener node-redis errors crash the process
+    this._client.on('error', reportError)
+    this._client.connect().catch(reportError)
+
+    this._instance.on('error', reportError)
 
     this._instance.on('connection', async (socket, req) => {
       socket.id = `${++this._connectionId}`
       socket._retryCount = 0
+      socket.path = req.url
+      socket.headers = req.headers
+
+      // Protocol errors (e.g. invalid close codes) emit 'error'; without a
+      // listener they crash the process. ws closes the socket afterwards.
+      socket.on('error', reportError)
+
+      let closed = false
 
       if(`${req.url}`.indexOf('debug-ws') > 0){
         this._debugIds[socket.id] = {}
@@ -117,9 +145,17 @@ class WSS extends EventEmitter2{
       let subscriber
 
       const listener = (message) => {
-        const { model, event, items } = JSON.parse(message)
+        let payload
+        try{
+          payload = JSON.parse(message)
+        }
+        catch(e){
+          return reportError(e)
+        }
+        const { model, event, items } = payload ?? {}
         this.toBinaryData({ data:{ model, event, items } }, !!this._debugIds[socket.id])
           .then(data => socket.send(data))
+          .catch(reportError)
       }
 
       socket.leave = (channel) => {
@@ -128,7 +164,7 @@ class WSS extends EventEmitter2{
         }*/
 
         if(subscriber){
-          subscriber.unsubscribe(channel, listener)
+          subscriber.unsubscribe(channel, listener).catch(reportError)
         }
       }
 
@@ -139,83 +175,25 @@ class WSS extends EventEmitter2{
         socket.channels[channel] = 1*/
 
         if(subscriber) {
-          subscriber.subscribe(channel, listener)
+          subscriber.subscribe(channel, listener).catch(reportError)
         }
       }
 
       socket.to = (channel) => {
         return {
           emit: (model, event, items) => {
-            this.broadcast(channel, { model, event, items }).then()
+            this.broadcast(channel, { model, event, items }).catch(reportError)
           }
         }
       }
 
-      socket.on('message', async (binaryData) => {
-        if(!socket.isAuth) return
-
-        let obj
-        try{
-          obj = await this.fromBinaryData(binaryData, !!this._debugIds[socket.id]);
-        }
-        catch(e){
-          return socket.close(1002, e.message);
-        }
-
-        const { _requestId, path, params, ping, pong } = obj
-
-        if(pong){
-          delete socket.pinging
-          socket._retryCount = 0
-        }
-        else if(ping){
-          socket.send(await this.toBinaryData({ pong: 1 }, !!this._debugIds[socket.id]))
-        }
-        else{
-          let status = 200
-          let data
-          switch(path){
-
-            default:
-              try{
-                const arr = (await Promise.all(this._reqFn.map(fn => fn({ path, params }, socket))))
-                  .filter(_ => _)
-
-                data = arr.length > 0 ? JSON.parse(JSON.stringify(arr.pop())) : data
-              }
-              catch(e){
-
-                if(e.response){
-                  '$report' in process ? process.$report(e) : console.error(e.response.status, e.response.data)
-                }
-                else{
-                  '$report' in process ? process.$report(e) : console.error(e)
-                }
-
-                status = 500
-                data = {
-                  name: e.name,
-                  message: e.message,
-                  errors: e.response ? e.response.data : e.errors,
-                  stack: process.env.APP_DEBUG === 'true' ?
-                    e.stack : undefined,
-                }
-              }
-              break
-          }
-
-          socket.send(await this.toBinaryData({
-            _requestId,
-            status,
-            data
-          }, !!this._debugIds[socket.id]))
-        }
+      socket.on('message', (binaryData) => {
+        this._onMessage(socket, binaryData).catch(reportError)
       });
 
       socket.on('close', (e) => {
-        if(subscriber){
-          subscriber.disconnect()
-        }
+        closed = true
+        disconnectQuietly(subscriber)
         if(this._debugIds[socket.id]){
           delete this._debugIds[socket.id]
         }
@@ -232,45 +210,64 @@ class WSS extends EventEmitter2{
           await fn(token, socket)
         }
 
-        subscriber = this._client.duplicate()
-        await subscriber.connect()
+        const client = this._client.duplicate()
+        client.on('error', reportError)
+        subscriber = client
+        await client.connect()
+
+        // Socket closed while authenticating/connecting: the close handler may
+        // have run before the client was open, so release it here.
+        if(closed){
+          disconnectQuietly(client)
+          return
+        }
 
         socket.isAuth = true
         socket.send(await this.toBinaryData({ auth:true }, !!this._debugIds[socket.id]))
       }
       catch(e){
+        disconnectQuietly(subscriber)
+        if(closed) return
         return socket.close(1002, (e.message ?? '').substring(0, 123));
       }
 
-      if(this._opt.ping !== false){
+      if(this._opt.ping !== false && !closed){
         let pingTimer
 
+        const schedule = (fn, ms) => {
+          if(!closed) pingTimer = setTimeout(fn, ms)
+        }
+
         const ping = async() => {
-          if(socket.readyState !== WebSocket.OPEN) return
+          if(closed || socket.readyState !== WebSocket.OPEN) return
 
-          socket.send(await this.toBinaryData({ ping:1 }, !!this._debugIds[socket.id]))
+          try{
+            socket.send(await this.toBinaryData({ ping:1 }, !!this._debugIds[socket.id]))
+          }
+          catch(e){
+            return reportError(e)
+          }
           socket.pinging = true
 
-          pingTimer = setTimeout(() => {
+          schedule(() => {
             if(socket.pinging){
               socket._retryCount++
 
               if(socket._retryCount > 10){
-                socket.close(1002, 'ping timeout')
-                if(subscriber){
-                  subscriber.disconnect()
-                }
+                // Peer is unresponsive, a close handshake would just hang;
+                // terminate so 'close' fires now and releases the subscriber.
+                socket.terminate()
               }
               else{
-                pingTimer = setTimeout(ping, 3000)
+                schedule(ping, 3000)
               }
             }
             else{
-              pingTimer = setTimeout(ping, (Math.round(Math.random() * 10) % 5) * 5000)
+              schedule(ping, (Math.round(Math.random() * 10) % 5) * 5000)
             }
           }, 3000)
         }
-        pingTimer = setTimeout(ping, (Math.round(Math.random() * 10) % 5) * 5000)
+        schedule(ping, (Math.round(Math.random() * 10) % 5) * 5000)
 
         socket.on('close', () => {
           clearTimeout(pingTimer)
@@ -279,6 +276,68 @@ class WSS extends EventEmitter2{
     })
   }
 
+  async _onMessage(socket, binaryData){
+    if(!socket.isAuth) return
+
+    let obj
+    try{
+      obj = await this.fromBinaryData(binaryData, !!this._debugIds[socket.id]);
+      if(typeof obj !== 'object' || obj === null) throw new Error('Invalid message')
+    }
+    catch(e){
+      return socket.close(1002, (e.message ?? '').substring(0, 123));
+    }
+
+    const { _requestId, path, params, ping, pong } = obj
+
+    if(pong){
+      delete socket.pinging
+      socket._retryCount = 0
+    }
+    else if(ping){
+      socket.send(await this.toBinaryData({ pong: 1 }, !!this._debugIds[socket.id]))
+    }
+    else{
+      let status = 200
+      let data
+      switch(path){
+
+        default:
+          try{
+            const arr = (await Promise.all(this._reqFn.map(fn => fn({ path, params }, socket))))
+              .filter(_ => _)
+
+            data = arr.length > 0 ? JSON.parse(JSON.stringify(arr.pop())) : data
+          }
+          catch(e){
+
+            if(e.response){
+              '$report' in process ? process.$report(e) : console.error(e.response.status, e.response.data)
+            }
+            else{
+              '$report' in process ? process.$report(e) : console.error(e)
+            }
+
+            status = 500
+            data = {
+              name: e.name,
+              message: e.message,
+              errors: e.response ? e.response.data : e.errors,
+              stack: process.env.APP_DEBUG === 'true' ?
+                e.stack : undefined,
+            }
+          }
+          break
+      }
+
+      socket.send(await this.toBinaryData({
+        _requestId,
+        status,
+        data
+      }, !!this._debugIds[socket.id]))
+    }
+  }
+
   stats(){
     let authenticated = 0
     this._instance.clients.forEach(socket => {
@@ -296,25 +355,34 @@ class WSS extends EventEmitter2{
 
   clusterStats(){
     return new Promise((resolve) => {
-      const workers = {}
-      const timeout = setTimeout(() => resolve(this._aggregateStats(workers)), 3000)
+      // Include own stats
+      const workers = { [process.pid]: this.stats() }
 
-      process.on('message', (packet) => {
-        if(packet.type === 'process:msg' && packet.data?.type === 'wss:stats:response'){
+      if(!process.send){
+        return resolve(this._aggregateStats(workers))
+      }
+
+      // Listener must be removed once done, otherwise every call leaks one
+      const finish = () => {
+        clearTimeout(timeout)
+        process.removeListener('message', onMessage)
+        resolve(this._aggregateStats(workers))
+      }
+
+      const onMessage = (packet) => {
+        if(packet?.type === 'process:msg' && packet.data?.type === 'wss:stats:response'){
           workers[packet.data.pid] = packet.data.stats
         }
 
         const expected = parseInt(process.env.instances || '0', 10)
         if(expected > 0 && Object.keys(workers).length >= expected){
-          clearTimeout(timeout)
-          resolve(this._aggregateStats(workers))
+          finish()
         }
-      })
+      }
 
+      const timeout = setTimeout(finish, 3000)
+      process.on('message', onMessage)
       process.send({ type: 'process:msg', data: { type: 'wss:stats:request' } })
-
-      // Include own stats
-      workers[process.pid] = this.stats()
     })
   }
 
@@ -331,9 +399,10 @@ class WSS extends EventEmitter2{
   }
 
   initClusterStats(){
-    if(process.send){
+    if(process.send && !this._clusterStatsInit){
+      this._clusterStatsInit = true
       process.on('message', (packet) => {
-        if(packet.type === 'process:msg' && packet.data?.type === 'wss:stats:request'){
+        if(packet?.type === 'process:msg' && packet.data?.type === 'wss:stats:request'){
           process.send({
             type: 'process:msg',
             data: { type: 'wss:stats:response', pid: process.pid, stats: this.stats() }