dialogue-ts 0.0.1 → 0.0.4

package/dist/src/index.cjs

@@ -24,14 +24,162 @@ __export(src_exports, {
   createDialogue: () => createDialogue,
   createHistoryManager: () => createHistoryManager,
   createRateLimiter: () => createRateLimiter,
+  createRuntimeAdapter: () => createRuntimeAdapter,
   createSilentLogger: () => createSilentLogger,
   defineEvent: () => defineEvent,
+  detectRuntime: () => detectRuntime,
   getEventByName: () => getEventByName,
   isEventAllowed: () => isEventAllowed,
   validateEventData: () => validateEventData
 });
 module.exports = __toCommonJS(src_exports);
 
+// src/adapters/bun-adapter.ts
+var import_bun_engine = require("@socket.io/bun-engine");
+function addCorsHeaders(response, request, corsConfig) {
+  const origin = request.headers.get("Origin");
+  if (!origin) {
+    return response;
+  }
+  const headers = new Headers(response.headers);
+  if (corsConfig === void 0 || corsConfig === true) {
+    headers.set("Access-Control-Allow-Origin", origin);
+    headers.set("Access-Control-Allow-Credentials", "true");
+  } else if (corsConfig === false) {
+    return response;
+  } else {
+    const allowedOrigin = corsConfig.origin;
+    if (allowedOrigin === true) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    } else if (typeof allowedOrigin === "string" && allowedOrigin === origin) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    } else if (Array.isArray(allowedOrigin) && allowedOrigin.includes(origin)) {
+      headers.set("Access-Control-Allow-Origin", origin);
+    }
+    if (corsConfig.credentials !== false) {
+      headers.set("Access-Control-Allow-Credentials", "true");
+    }
+  }
+  headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
+  headers.set("Access-Control-Allow-Headers", "Content-Type");
+  return new Response(response.body, {
+    status: response.status,
+    statusText: response.statusText,
+    headers
+  });
+}
+function createBunAdapter() {
+  const engine = new import_bun_engine.Server();
+  let bunServer = null;
+  return {
+    runtime: "bun",
+    bind(io) {
+      io.bind(engine);
+    },
+    start({
+      port,
+      app,
+      corsConfig,
+      logger
+    }) {
+      const { websocket } = engine.handler();
+      bunServer = Bun.serve({
+        port,
+        idleTimeout: 30,
+        async fetch(req, server) {
+          const url = new URL(req.url);
+          if (url.pathname.startsWith("/socket.io")) {
+            if (req.method === "OPTIONS") {
+              return addCorsHeaders(
+                new Response(null, { status: 204 }),
+                req,
+                corsConfig
+              );
+            }
+            const response = await engine.handleRequest(req, server);
+            return addCorsHeaders(response, req, corsConfig);
+          }
+          return app.fetch(req);
+        },
+        websocket
+      });
+      logger.info({
+        message: `Server running on http://localhost:${port} (bun)`,
+        atFunction: "bunAdapter.start",
+        data: { port, runtime: "bun" }
+      });
+      return Promise.resolve();
+    },
+    stop() {
+      if (bunServer) {
+        bunServer.stop();
+        bunServer = null;
+      }
+      return Promise.resolve();
+    }
+  };
+}
+
+// src/adapters/node-adapter.ts
+var import_node_http = require("http");
+var import_node_server = require("@hono/node-server");
+function createNodeAdapter() {
+  let httpServer = null;
+  let socketIoServer = null;
+  return {
+    runtime: "node",
+    bind(io) {
+      socketIoServer = io;
+    },
+    start({ port, app, io, logger }) {
+      const requestListener = (0, import_node_server.getRequestListener)(app.fetch);
+      httpServer = (0, import_node_http.createServer)(requestListener);
+      io.attach(httpServer);
+      return new Promise((resolve) => {
+        httpServer?.listen(port, () => {
+          logger.info({
+            message: `Server running on http://localhost:${port} (node)`,
+            atFunction: "nodeAdapter.start",
+            data: { port, runtime: "node" }
+          });
+          resolve();
+        });
+      });
+    },
+    stop() {
+      return new Promise((resolve) => {
+        if (socketIoServer) {
+          socketIoServer = null;
+        }
+        if (httpServer) {
+          httpServer.close(() => {
+            httpServer = null;
+            resolve();
+          });
+        } else {
+          resolve();
+        }
+      });
+    }
+  };
+}
+
+// src/adapters/index.ts
+function detectRuntime() {
+  if (typeof globalThis.Bun !== "undefined") {
+    return "bun";
+  }
+  return "node";
+}
+function createRuntimeAdapter(runtime) {
+  const resolved = runtime ?? detectRuntime();
+  const adapters = {
+    bun: createBunAdapter,
+    node: createNodeAdapter
+  };
+  return adapters[resolved]();
+}
+
 // src/create-dialogue.ts
 var import_hono = require("hono");
 var import_slang_ts3 = require("slang-ts");
@@ -159,7 +307,6 @@ function createSilentLogger() {
 }
 
 // src/server.ts
-var import_bun_engine = require("@socket.io/bun-engine");
 var import_cors = require("hono/cors");
 var import_socket = require("socket.io");
 
@@ -369,6 +516,79 @@ function isParticipantSubscribed(participant, roomId, eventName) {
 function createRoom(id, config, _io, logger, historyManager, hooks, externalParticipants, getContext) {
   const participants = externalParticipants ?? /* @__PURE__ */ new Map();
   const eventHandlers = /* @__PURE__ */ new Map();
+  function validateEvent(event, data) {
+    if (!isEventAllowed(event.name, config.events)) {
+      const errorMsg = `Event '${event.name}' is not allowed in room '${id}'`;
+      logger.warn({
+        message: errorMsg,
+        atFunction: "room.trigger",
+        data: { eventName: event.name, roomId: id }
+      });
+      return (0, import_slang_ts2.Err)(errorMsg);
+    }
+    const eventDef = getEventByName(event.name, config.events) ?? event;
+    const validation = validateEventData(eventDef, data);
+    if (validation.isErr) {
+      logger.warn({
+        message: validation.error,
+        atFunction: "room.trigger",
+        data: {
+          eventName: event.name,
+          roomId: id,
+          validationError: validation.error
+        }
+      });
+      return (0, import_slang_ts2.Err)(validation.error);
+    }
+    return (0, import_slang_ts2.Ok)(validation.value);
+  }
+  function runBeforeEachHook(event, message) {
+    if (!(hooks?.events?.beforeEach && getContext)) {
+      return (0, import_slang_ts2.Ok)(message);
+    }
+    const context = getContext();
+    const hookResult = hooks.events.beforeEach({
+      context,
+      roomId: id,
+      message,
+      from: message.from
+    });
+    if (hookResult.isErr) {
+      logger.debug({
+        message: `Event '${event.name}' blocked by beforeEach: ${hookResult.error}`,
+        atFunction: "room.trigger.beforeEach",
+        data: {
+          eventName: event.name,
+          roomId: id,
+          reason: hookResult.error
+        }
+      });
+      return (0, import_slang_ts2.Err)(hookResult.error);
+    }
+    return (0, import_slang_ts2.Ok)(hookResult.value);
+  }
+  function broadcastToParticipants(eventName, message) {
+    let recipientCount = 0;
+    for (const [, participant] of participants) {
+      if (isParticipantSubscribed(participant, id, eventName)) {
+        participant.socket.emit("dialogue:event", message);
+        recipientCount++;
+      }
+    }
+    return recipientCount;
+  }
+  function runAfterEachHook(message, recipientCount) {
+    if (!(hooks?.events?.afterEach && getContext)) {
+      return;
+    }
+    const context = getContext();
+    hooks.events.afterEach({
+      context,
+      roomId: id,
+      message,
+      recipientCount
+    });
+  }
   function handlePostBroadcast(eventName, message) {
     const eventDef = getEventByName(eventName, config.events);
     if (eventDef?.history?.enabled && historyManager) {
@@ -405,27 +625,8 @@ function createRoom(id, config, _io, logger, historyManager, hooks, externalPart
     defaultSubscriptions: config.defaultSubscriptions ?? [],
     createdById: config.createdById,
     trigger(event, data, from, meta) {
-      if (!isEventAllowed(event.name, config.events)) {
-        const errorMsg = `Event '${event.name}' is not allowed in room '${id}'`;
-        logger.warn({
-          message: errorMsg,
-          atFunction: "room.trigger",
-          data: { eventName: event.name, roomId: id }
-        });
-        return (0, import_slang_ts2.Err)(errorMsg);
-      }
-      const eventDef = getEventByName(event.name, config.events) ?? event;
-      const validation = validateEventData(eventDef, data);
+      const validation = validateEvent(event, data);
       if (validation.isErr) {
-        logger.warn({
-          message: validation.error,
-          atFunction: "room.trigger",
-          data: {
-            eventName: event.name,
-            roomId: id,
-            validationError: validation.error
-          }
-        });
         return (0, import_slang_ts2.Err)(validation.error);
       }
       const message = {
@@ -436,46 +637,14 @@ function createRoom(id, config, _io, logger, historyManager, hooks, externalPart
         timestamp: Date.now(),
         ...meta && { meta }
       };
-      let finalMessage = message;
-      if (hooks?.events?.beforeEach && getContext) {
-        const context = getContext();
-        const hookResult = hooks.events.beforeEach({
-          context,
-          roomId: id,
-          message,
-          from: message.from
-        });
-        if (hookResult.isErr) {
-          logger.debug({
-            message: `Event '${event.name}' blocked by beforeEach: ${hookResult.error}`,
-            atFunction: "room.trigger.beforeEach",
-            data: {
-              eventName: event.name,
-              roomId: id,
-              reason: hookResult.error
-            }
-          });
-          return (0, import_slang_ts2.Err)(hookResult.error);
-        }
-        finalMessage = hookResult.value;
-      }
-      let recipientCount = 0;
-      for (const [, participant] of participants) {
-        if (isParticipantSubscribed(participant, id, event.name)) {
-          participant.socket.emit("dialogue:event", finalMessage);
-          recipientCount++;
-        }
+      const hookResult = runBeforeEachHook(event, message);
+      if (hookResult.isErr) {
+        return (0, import_slang_ts2.Err)(hookResult.error);
       }
+      const finalMessage = hookResult.value;
+      const recipientCount = broadcastToParticipants(event.name, finalMessage);
       handlePostBroadcast(event.name, finalMessage);
-      if (hooks?.events?.afterEach && getContext) {
-        const context = getContext();
-        hooks.events.afterEach({
-          context,
-          roomId: id,
-          message: finalMessage,
-          recipientCount
-        });
-      }
+      runAfterEachHook(finalMessage, recipientCount);
       return (0, import_slang_ts2.Ok)(void 0);
     },
     on(event, handler) {
@@ -729,38 +898,6 @@ function buildHonoCorsOptions(cors) {
     credentials: cors.credentials ?? true
   };
 }
-function addCorsHeaders(response, request, corsConfig) {
-  const origin = request.headers.get("Origin");
-  if (!origin) {
-    return response;
-  }
-  const headers = new Headers(response.headers);
-  if (corsConfig === void 0 || corsConfig === true) {
-    headers.set("Access-Control-Allow-Origin", origin);
-    headers.set("Access-Control-Allow-Credentials", "true");
-  } else if (corsConfig === false) {
-    return response;
-  } else {
-    const allowedOrigin = corsConfig.origin;
-    if (allowedOrigin === true) {
-      headers.set("Access-Control-Allow-Origin", origin);
-    } else if (typeof allowedOrigin === "string" && allowedOrigin === origin) {
-      headers.set("Access-Control-Allow-Origin", origin);
-    } else if (Array.isArray(allowedOrigin) && allowedOrigin.includes(origin)) {
-      headers.set("Access-Control-Allow-Origin", origin);
-    }
-    if (corsConfig.credentials !== false) {
-      headers.set("Access-Control-Allow-Credentials", "true");
-    }
-  }
-  headers.set("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-  headers.set("Access-Control-Allow-Headers", "Content-Type");
-  return new Response(response.body, {
-    status: response.status,
-    statusText: response.statusText,
-    headers
-  });
-}
 function sendHistoryOnJoin(socket, roomId, roomConfig, historyManager) {
   if (!(roomConfig?.syncHistoryOnJoin && historyManager)) {
     return;
@@ -789,7 +926,7 @@ function createDialogueContext(io, connectedClients, roomManager) {
     rooms: roomsRecord
   };
 }
-function setupServer(app, config, historyManager) {
+function setupServer(app, config, adapter, historyManager) {
   const logger = config.logger ?? createDefaultLogger();
   const hooks = config.hooks;
   const connectedClients = /* @__PURE__ */ new Map();
@@ -798,8 +935,7 @@ function setupServer(app, config, historyManager) {
   const honoCorsOptions = buildHonoCorsOptions(config.cors);
   app.use("*", (0, import_cors.cors)(honoCorsOptions));
   const io = new import_socket.Server({ cors: corsOptions });
-  const engine = new import_bun_engine.Server();
-  io.bind(engine);
+  adapter.bind(io);
   const getContextForHooks = () => {
     return createDialogueContext(io, connectedClients, roomManager);
   };
@@ -1180,46 +1316,20 @@ function setupServer(app, config, historyManager) {
       }
     });
   });
-  const { websocket } = engine.handler();
   const port = config.port ?? 3e3;
-  let bunServer = null;
   return {
     io,
-    engine,
     roomManager,
     start() {
-      bunServer = Bun.serve({
+      return adapter.start({
         port,
-        idleTimeout: 30,
-        async fetch(req, server) {
-          const url = new URL(req.url);
-          if (url.pathname.startsWith("/socket.io")) {
-            if (req.method === "OPTIONS") {
-              return addCorsHeaders(
-                new Response(null, { status: 204 }),
-                req,
-                config.cors
-              );
-            }
-            const response = await engine.handleRequest(req, server);
-            return addCorsHeaders(response, req, config.cors);
-          }
-          return app.fetch(req);
-        },
-        websocket
-      });
-      logger.info({
-        message: `Server running on http://localhost:${port}`,
-        atFunction: "setupServer.start",
-        data: { port }
+        app,
+        io,
+        corsConfig: config.cors,
+        logger
       });
-      return Promise.resolve();
     },
     stop() {
-      if (bunServer) {
-        bunServer.stop();
-        bunServer = null;
-      }
       for (const client of connectedClients.values()) {
         client.disconnect();
       }
@@ -1231,7 +1341,7 @@ function setupServer(app, config, historyManager) {
         atFunction: "setupServer.stop",
         data: null
       });
-      return Promise.resolve();
+      return adapter.stop();
     },
     /**
      * Gets a connected client by socket ID
@@ -1295,6 +1405,7 @@ function createDialogue(config) {
     onCleanup: config.hooks?.events?.onCleanup,
     onLoad: config.hooks?.events?.onLoad
   });
+  const adapter = createRuntimeAdapter(config.runtime);
   const {
     io,
     roomManager,
@@ -1305,7 +1416,7 @@ function createDialogue(config) {
     getClientsByUserId,
     getClientRooms: getClientRoomIds,
     isUserInRoom
-  } = setupServer(app, config, historyManager);
+  } = setupServer(app, config, adapter, historyManager);
   const dialogue = {
     app,
     io,
@@ -1415,8 +1526,10 @@ function createDialogue(config) {
   createDialogue,
   createHistoryManager,
   createRateLimiter,
+  createRuntimeAdapter,
   createSilentLogger,
   defineEvent,
+  detectRuntime,
   getEventByName,
   isEventAllowed,
   validateEventData