@jsenv/core 27.5.3 → 27.7.0

package/src/plugins/server_events/client/events_manager.js

@@ -0,0 +1,75 @@
+export const createEventsManager = ({ effect = () => {} } = {}) => {
+  const callbacksMap = new Map()
+  let cleanup
+  const addCallbacks = (namedCallbacks) => {
+    let callbacksMapSize = callbacksMap.size
+    Object.keys(namedCallbacks).forEach((eventName) => {
+      const callback = namedCallbacks[eventName]
+      const existingCallbacks = callbacksMap.get(eventName)
+      let callbacks
+      if (existingCallbacks) {
+        callbacks = existingCallbacks
+      } else {
+        callbacks = []
+        callbacksMap.set(eventName, callbacks)
+      }
+      callbacks.push(callback)
+    })
+    if (effect && callbacksMapSize === 0 && callbacksMapSize.size > 0) {
+      cleanup = effect()
+    }
+
+    let removed = false
+    return () => {
+      if (removed) return
+      removed = true
+      callbacksMapSize = callbacksMap.size
+      Object.keys(namedCallbacks).forEach((eventName) => {
+        const callback = namedCallbacks[eventName]
+        const callbacks = callbacksMap.get(eventName)
+        if (callbacks) {
+          const index = callbacks.indexOf(callback)
+          if (index > -1) {
+            callbacks.splice(index, 1)
+            if (callbacks.length === 0) {
+              callbacksMap.delete(eventName)
+            }
+          }
+        }
+      })
+      namedCallbacks = null // allow garbage collect
+      if (
+        cleanup &&
+        typeof cleanup === "function" &&
+        callbacksMapSize > 0 &&
+        callbacksMapSize.size === 0
+      ) {
+        cleanup()
+        cleanup = null
+      }
+    }
+  }
+
+  const triggerCallbacks = (event) => {
+    const callbacks = callbacksMap.get(event.type)
+    if (callbacks) {
+      callbacks.forEach((callback) => {
+        callback(event)
+      })
+    }
+  }
+
+  const destroy = () => {
+    callbacksMap.clear()
+    if (cleanup) {
+      cleanup()
+      cleanup = null
+    }
+  }
+
+  return {
+    addCallbacks,
+    triggerCallbacks,
+    destroy,
+  }
+}

package/src/plugins/server_events/client/server_events_client.js

@@ -1,17 +1,18 @@
-import { createEventSourceConnection } from "./event_source_connection.js"
+/* globals self */
 
-const eventsourceConnection = createEventSourceConnection(
-  document.location.href,
-  {
-    retryMaxAttempt: Infinity,
-    retryAllocatedMs: 20 * 1000,
-  },
-)
-const { status, connect, addEventCallbacks, disconnect } = eventsourceConnection
+import { createWebSocketConnection } from "./web_socket_connection.js"
+
+const websocketScheme = self.location.protocol === "https" ? "wss" : "ws"
+const websocketUrl = `${websocketScheme}://${self.location.host}${self.location.pathname}${self.location.search}`
+const websocketConnection = createWebSocketConnection(websocketUrl, {
+  retry: true,
+  retryAllocatedMs: 10_000,
+})
+const { readyState, connect, disconnect, listenEvents } = websocketConnection
 window.__server_events__ = {
-  addEventCallbacks,
-  status,
+  readyState,
   connect,
   disconnect,
+  listenEvents,
 }
 connect()

package/src/plugins/server_events/client/web_socket_connection.js

@@ -0,0 +1,81 @@
+import { createConnectionManager } from "./connection_manager.js"
+import { createEventsManager } from "./events_manager.js"
+
+export const createWebSocketConnection = (
+  websocketUrl,
+  {
+    protocols = ["jsenv"],
+    useEventsToManageConnection = true,
+    retry = false,
+    retryAfter = 1000,
+    retryMaxAttempt = Infinity,
+    retryAllocatedMs = Infinity,
+  } = {},
+) => {
+  const connectionManager = createConnectionManager(
+    ({ onClosed, onOpen }) => {
+      let socket = new WebSocket(websocketUrl, protocols)
+      let interval
+      const cleanup = () => {
+        if (socket) {
+          socket.onerror = null
+          socket.onopen = null
+          socket.onclose = null
+          socket.onmessage = null
+          socket = null
+          clearInterval(interval)
+        }
+      }
+      socket.onerror = () => {
+        cleanup()
+        onClosed()
+      }
+      socket.onopen = () => {
+        socket.onopen = null
+        onOpen()
+        interval = setInterval(() => {
+          socket.send('{"type":"ping"}')
+        }, 30_000)
+      }
+      socket.onclose = () => {
+        cleanup()
+        onClosed()
+      }
+      socket.onmessage = (messageEvent) => {
+        const event = JSON.parse(messageEvent.data)
+        eventsManager.triggerCallbacks(event)
+      }
+      return () => {
+        if (socket) {
+          socket.close()
+          cleanup()
+        }
+      }
+    },
+    { retry, retryAfter, retryMaxAttempt, retryAllocatedMs },
+  )
+  const eventsManager = createEventsManager({
+    effect: () => {
+      if (useEventsToManageConnection) {
+        connectionManager.connect()
+        return () => {
+          connectionManager.disconnect()
+        }
+      }
+      return null
+    },
+  })
+
+  return {
+    readyState: connectionManager.readyState,
+    connect: connectionManager.connect,
+    disconnect: connectionManager.disconnect,
+    listenEvents: (namedCallbacks) => {
+      return eventsManager.addCallbacks(namedCallbacks)
+    },
+    destroy: () => {
+      connectionManager.destroy()
+      eventsManager.destroy()
+    },
+  }
+}

package/src/plugins/server_events/server_events_dispatcher.js

@@ -1,69 +1,85 @@
-import { createSSERoom } from "@jsenv/server"
-import { createCallbackListNotifiedOnce } from "@jsenv/abort"
-
 export const createServerEventsDispatcher = () => {
-  const destroyCallbackList = createCallbackListNotifiedOnce()
-  const rooms = []
-  const sseRoomLimit = 100
+  const clients = []
+  const MAX_CLIENTS = 100
 
-  destroyCallbackList.add(() => {
-    rooms.forEach((room) => {
-      room.close()
-    })
-  })
+  const addClient = (client) => {
+    clients.push(client)
+    if (clients.length >= MAX_CLIENTS) {
+      const firstClient = clients.shift()
+      firstClient.close()
+    }
+    return () => {
+      client.close()
+      const index = clients.indexOf(client)
+      if (index > -1) {
+        clients.splice(index, 1)
+      }
+    }
+  }
 
   return {
-    addRoom: (request) => {
-      const existingRoom = rooms.find(
-        (roomCandidate) =>
-          roomCandidate.request.ressource === request.ressource,
-      )
-      if (existingRoom) {
-        return existingRoom
-      }
-      const room = createSSERoom({
-        retryDuration: 2000,
-        historyLength: 100,
-        welcomeEventEnabled: true,
-        effect: () => {
-          rooms.push(room)
-          if (rooms.length >= sseRoomLimit) {
-            const firstRoom = rooms.shift()
-            firstRoom.close()
-          }
-          return () => {
-            // when the last client leaves the room it is closed and removed from the list
-            room.close()
-            const index = rooms.indexOf(room)
-            if (index > -1) {
-              rooms.splice(index, 1)
+    addWebsocket: (websocket, request) => {
+      const client = {
+        request,
+        getReadystate: () => {
+          return websocket.readyState
+        },
+        sendEvent: (event) => {
+          websocket.send(JSON.stringify(event))
+        },
+        close: (reason) => {
+          const closePromise = new Promise((resolve, reject) => {
+            websocket.onclose = () => {
+              websocket.onclose = null
+              websocket.onerror = null
+              resolve()
+            }
+            websocket.onerror = (e) => {
+              websocket.onclose = null
+              websocket.onerror = null
+              reject(e)
             }
-          }
+          })
+          websocket.close(reason)
+          return closePromise
         },
-      })
-      room.request = request
-      return room
+        destroy: () => {
+          websocket.terminate()
+        },
+      }
+      client.sendEvent({ type: "welcome" })
+      return addClient(client)
     },
-    dispatch: ({ type, data }) => {
-      rooms.forEach((room) =>
-        room.sendEventToAllClients({
-          type,
-          data: JSON.stringify(data),
-        }),
-      )
+    // we could add "addEventSource" and let clients connect using
+    // new WebSocket or new EventSource
+    // in practice the new EventSource won't be used
+    // so "serverEventsDispatcher.addEventSource" is not implemented
+    // addEventSource: (request) => {},
+    dispatch: (event) => {
+      clients.forEach((client) => {
+        if (client.getReadystate() === 1) {
+          client.sendEvent(event)
+        }
+      })
     },
-    dispatchToRoomsMatching: ({ type, data }, predicate) => {
-      rooms.forEach((room) => {
-        if (predicate(room)) {
-          room.sendEventToAllClients({
-            type,
-            data: JSON.stringify(data),
-          })
+    dispatchToClientsMatching: (event, predicate) => {
+      clients.forEach((client) => {
+        if (client.getReadystate() === 1 && predicate(client)) {
+          client.sendEvent(event)
         }
       })
     },
+    close: async (reason) => {
+      await Promise.all(
+        clients.map(async (client) => {
+          await client.close(reason)
+        }),
+      )
+    },
     destroy: () => {
-      destroyCallbackList.notify()
+      clients.forEach((client) => {
+        client.destroy()
+      })
     },
   }
 }