dialogue-ts 0.0.2 → 0.0.4

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 import { Hono } from 'hono';
-import { Result } from 'slang-ts';
 import { Socket, Server } from 'socket.io';
+import { Result } from 'slang-ts';
 import { z } from 'zod';
 
 /**
@@ -247,6 +247,14 @@ interface DialogueConfig {
     logger?: Logger;
     /** CORS configuration. Defaults to allowing all origins in development. */
     cors?: CorsConfig | boolean;
+    /**
+     * Runtime to use for the HTTP server and Socket.IO engine.
+     * - "bun": Uses Bun.serve() with @socket.io/bun-engine
+     * - "node": Uses Node.js http.createServer() with Socket.IO's built-in engine
+     *
+     * Auto-detected if not specified (checks for Bun globals, falls back to Node).
+     */
+    runtime?: "bun" | "node";
 }
 /**
  * Message envelope - the shape of all messages sent between clients and server.
@@ -436,6 +444,56 @@ interface RoomManager {
     removeParticipant(roomId: string, clientId: string): void;
 }
 
+/** Supported runtime environments */
+type Runtime = "bun" | "node";
+/**
+ * Runtime adapter interface that abstracts the HTTP server and Socket.IO engine
+ * binding for different JavaScript runtimes (Bun, Node.js).
+ *
+ * Each adapter handles:
+ * - Binding the Socket.IO engine to the IO server
+ * - Starting/stopping the HTTP server with Hono routing and Socket.IO transport
+ */
+interface RuntimeAdapter {
+    /** The runtime this adapter targets */
+    readonly runtime: Runtime;
+    /**
+     * Bind the Socket.IO server to the runtime-specific engine.
+     * For Bun: uses @socket.io/bun-engine
+     * For Node: uses Socket.IO's built-in engine.io (attached to http.Server)
+     */
+    bind(io: Server): void;
+    /**
+     * Start the HTTP server on the given port, routing both Hono app
+     * requests and Socket.IO transport (polling + websocket).
+     */
+    start(options: RuntimeStartOptions): Promise<void>;
+    /** Stop the HTTP server and clean up resources */
+    stop(): Promise<void>;
+}
+/** Options passed to RuntimeAdapter.start() */
+interface RuntimeStartOptions {
+    port: number;
+    app: Hono;
+    io: Server;
+    corsConfig: CorsConfig | boolean | undefined;
+    logger: Logger;
+}
+
+/**
+ * Detects the current JavaScript runtime by checking for Bun globals.
+ * Falls back to "node" if Bun is not detected.
+ */
+declare function detectRuntime(): Runtime;
+/**
+ * Creates the appropriate runtime adapter based on the specified runtime.
+ * Uses auto-detection if no runtime is specified.
+ *
+ * @param runtime - Explicit runtime choice, or auto-detected if omitted
+ * @returns A RuntimeAdapter for the target runtime
+ */
+declare function createRuntimeAdapter(runtime?: Runtime): RuntimeAdapter;
+
 /**
  * Creates a Dialogue instance from configuration.
  * This is the main entry point for the library.
@@ -661,4 +719,4 @@ interface RateLimiter {
  */
 declare function createRateLimiter(config: RateLimiterConfig): RateLimiter;
 
-export { type AuthData, type AuthenticateResult, type ConnectedClient, type CorsConfig, type Dialogue, type DialogueConfig, type DialogueContext, type EventDefinition, type EventHistoryConfig, type EventMessage, type HistoryManager, type HistoryManagerConfig, type HooksConfig, type JwtClaims, type LogEntry, type Logger, type RateLimiter, type RateLimiterConfig, type Room, type RoomConfig, type RoomManager, createDefaultLogger, createDialogue, createHistoryManager, createRateLimiter, createSilentLogger, defineEvent, getEventByName, isEventAllowed, validateEventData };
+export { type AuthData, type AuthenticateResult, type ConnectedClient, type CorsConfig, type Dialogue, type DialogueConfig, type DialogueContext, type EventDefinition, type EventHistoryConfig, type EventMessage, type HistoryManager, type HistoryManagerConfig, type HooksConfig, type JwtClaims, type LogEntry, type Logger, type RateLimiter, type RateLimiterConfig, type Room, type RoomConfig, type RoomManager, type Runtime, type RuntimeAdapter, type RuntimeStartOptions, createDefaultLogger, createDialogue, createHistoryManager, createRateLimiter, createRuntimeAdapter, createSilentLogger, defineEvent, detectRuntime, getEventByName, isEventAllowed, validateEventData };

package/dist/src/index.js

@@ -1,3 +1,149 @@
+// src/adapters/bun-adapter.ts
+import { Server as BunEngine } from "@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 BunEngine();
+  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
+import { createServer } from "http";
+import { getRequestListener } from "@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 = getRequestListener(app.fetch);
+      httpServer = 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
 import { Hono } from "hono";
 import { Err as Err3 } from "slang-ts";
@@ -125,7 +271,6 @@ function createSilentLogger() {
 }
 
 // src/server.ts
-import { Server as BunEngine } from "@socket.io/bun-engine";
 import { cors as honoCors } from "hono/cors";
 import { Server } from "socket.io";
 
@@ -717,38 +862,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;
@@ -777,7 +890,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();
@@ -786,8 +899,7 @@ function setupServer(app, config, historyManager) {
   const honoCorsOptions = buildHonoCorsOptions(config.cors);
   app.use("*", honoCors(honoCorsOptions));
   const io = new Server({ cors: corsOptions });
-  const engine = new BunEngine();
-  io.bind(engine);
+  adapter.bind(io);
   const getContextForHooks = () => {
     return createDialogueContext(io, connectedClients, roomManager);
   };
@@ -1168,46 +1280,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();
       }
@@ -1219,7 +1305,7 @@ function setupServer(app, config, historyManager) {
         atFunction: "setupServer.stop",
         data: null
       });
-      return Promise.resolve();
+      return adapter.stop();
     },
     /**
      * Gets a connected client by socket ID
@@ -1283,6 +1369,7 @@ function createDialogue(config) {
     onCleanup: config.hooks?.events?.onCleanup,
     onLoad: config.hooks?.events?.onLoad
   });
+  const adapter = createRuntimeAdapter(config.runtime);
   const {
     io,
     roomManager,
@@ -1293,7 +1380,7 @@ function createDialogue(config) {
     getClientsByUserId,
     getClientRooms: getClientRoomIds,
     isUserInRoom
-  } = setupServer(app, config, historyManager);
+  } = setupServer(app, config, adapter, historyManager);
   const dialogue = {
     app,
     io,
@@ -1402,8 +1489,10 @@ export {
   createDialogue,
   createHistoryManager,
   createRateLimiter,
+  createRuntimeAdapter,
   createSilentLogger,
   defineEvent,
+  detectRuntime,
   getEventByName,
   isEventAllowed,
   validateEventData