dialogue-ts 0.0.2 → 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");
 
@@ -751,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;
@@ -811,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();
@@ -820,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);
   };
@@ -1202,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();
       }
@@ -1253,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
@@ -1317,6 +1405,7 @@ function createDialogue(config) {
     onCleanup: config.hooks?.events?.onCleanup,
     onLoad: config.hooks?.events?.onLoad
   });
+  const adapter = createRuntimeAdapter(config.runtime);
   const {
     io,
     roomManager,
@@ -1327,7 +1416,7 @@ function createDialogue(config) {
     getClientsByUserId,
     getClientRooms: getClientRoomIds,
     isUserInRoom
-  } = setupServer(app, config, historyManager);
+  } = setupServer(app, config, adapter, historyManager);
   const dialogue = {
     app,
     io,
@@ -1437,8 +1526,10 @@ function createDialogue(config) {
   createDialogue,
   createHistoryManager,
   createRateLimiter,
+  createRuntimeAdapter,
   createSilentLogger,
   defineEvent,
+  detectRuntime,
   getEventByName,
   isEventAllowed,
   validateEventData