@krisanalfa/bunest-adapter 0.1.0 → 0.3.0

package/dist/index.js

@@ -15,10 +15,10 @@ var __legacyMetadataTS = (k, v) => {
 };
 
 // lib/bun.adapter.ts
+var {randomUUIDv7 } = globalThis.Bun;
 import {
   Logger
 } from "@nestjs/common";
-var {randomUUIDv7 } = globalThis.Bun;
 import { AbstractHttpAdapter } from "@nestjs/core";
 
 // lib/bun.body-parser.middleware.ts
@@ -367,6 +367,59 @@ class BunMiddlewareEngine {
   }
 }
 
+// lib/bun.preflight-http-server.ts
+class BunPreflightHttpServer {
+  adapter;
+  constructor(adapter) {
+    this.adapter = adapter;
+  }
+  on(event, callback) {}
+  once() {}
+  removeListener() {}
+  async stop(force) {
+    const server = this.adapter.getBunHttpServerInstance();
+    if (server instanceof BunPreflightHttpServer) {
+      return;
+    }
+    await server.stop(force);
+  }
+  address() {
+    const server = this.adapter.getBunHttpServerInstance();
+    if (server instanceof BunPreflightHttpServer) {
+      const options = this.adapter.getBunServerOptions();
+      return {
+        address: options.hostname ?? "127.0.0.1",
+        port: options.port ?? 3000
+      };
+    }
+    return {
+      address: server.hostname,
+      port: server.port
+    };
+  }
+  setWsOptions(options) {
+    this.adapter.setWsOptions(options);
+  }
+  registerWsOpenHandler(handler) {
+    this.adapter.getWsHandlers().onOpen = handler;
+  }
+  registerWsMessageHandler(handler) {
+    this.adapter.getWsHandlers().onMessage = handler;
+  }
+  registerWsCloseHandler(handler) {
+    this.adapter.getWsHandlers().onClose = handler;
+  }
+  getWsHandlers() {
+    return this.adapter.getWsHandlers();
+  }
+  getBunServer() {
+    return this.adapter.getBunHttpServerInstance();
+  }
+  async close() {
+    await this.stop(true);
+  }
+}
+
 // lib/bun.request.ts
 import { parse } from "qs";
 var NULL_PROTO = Object.getPrototypeOf(Object.create(null));
@@ -926,6 +979,16 @@ class BunAdapter extends AbstractHttpAdapter {
     res.setStatus(404);
     res.end({ message: "Not Found" });
   };
+  wsHandlers = {
+    onOpen: undefined,
+    onMessage: undefined,
+    onClose: undefined
+  };
+  wsMiddlewareEngine = new BunMiddlewareEngine;
+  wsOptions = {};
+  useWs = false;
+  useWsCors = false;
+  wsCorsHeaders;
   constructor(bunServeOptions = {
     development: false,
     id: randomUUIDv7()
@@ -955,60 +1018,64 @@ class BunAdapter extends AbstractHttpAdapter {
   use(middleware) {
     this.middlewareEngine.useGlobal(middleware);
   }
+  createHttpMethodHandler(httpMethod) {
+    return (pathOrHandler, maybeHandler) => {
+      const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
+      this.delegateRouteHandler(httpMethod, path, handler);
+    };
+  }
   get(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("GET", path, handler);
+    this.createHttpMethodHandler("GET")(pathOrHandler, maybeHandler);
   }
   post(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("POST", path, handler);
+    this.createHttpMethodHandler("POST")(pathOrHandler, maybeHandler);
   }
   put(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("PUT", path, handler);
+    this.createHttpMethodHandler("PUT")(pathOrHandler, maybeHandler);
   }
   patch(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("PATCH", path, handler);
+    this.createHttpMethodHandler("PATCH")(pathOrHandler, maybeHandler);
   }
   delete(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("DELETE", path, handler);
+    this.createHttpMethodHandler("DELETE")(pathOrHandler, maybeHandler);
   }
   head(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("HEAD", path, handler);
+    this.createHttpMethodHandler("HEAD")(pathOrHandler, maybeHandler);
   }
   options(pathOrHandler, maybeHandler) {
-    const { path, handler } = this.parseRouteHandler(pathOrHandler, maybeHandler);
-    this.delegateRouteHandler("OPTIONS", path, handler);
+    this.createHttpMethodHandler("OPTIONS")(pathOrHandler, maybeHandler);
+  }
+  createUnsupportedMethod() {
+    return (pathOrHandler, maybeHandler) => {
+      throw new Error("Not supported.");
+    };
   }
   all(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   propfind(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   proppatch(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   mkcol(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   copy(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   move(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   lock(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   unlock(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   search(pathOrHandler, maybeHandler) {
-    throw new Error("Not supported.");
+    this.createUnsupportedMethod()(pathOrHandler, maybeHandler);
   }
   useStaticAssets(...args) {
     throw new Error("Not supported.");
@@ -1023,12 +1090,15 @@ class BunAdapter extends AbstractHttpAdapter {
     await this.httpServer.stop();
   }
   initHttpServer(options) {
-    this.setHttpServer({
-      once: () => {},
-      address: () => ({ address: "0.0.0.0", port: 0 }),
-      removeListener: () => {},
-      stop: () => {}
+    const preflightServer = new BunPreflightHttpServer({
+      getBunHttpServerInstance: () => this.getHttpServer(),
+      getBunServerOptions: () => this.bunServeOptions,
+      getWsHandlers: () => this.wsHandlers,
+      setWsOptions: (wsOptions) => {
+        this.wsOptions = wsOptions;
+      }
     });
+    this.setHttpServer(preflightServer);
     if (options.httpsOptions) {
       this.bunServeOptions.tls = {
         key: options.httpsOptions.key,
@@ -1041,6 +1111,7 @@ class BunAdapter extends AbstractHttpAdapter {
         requestCert: options.httpsOptions.requestCert
       };
     }
+    return preflightServer;
   }
   getRequestHostname(request) {
     return request.hostname;
@@ -1115,11 +1186,17 @@ class BunAdapter extends AbstractHttpAdapter {
     return BunVersionFilterMiddleware.createFilter(handler, version, versioningOptions);
   }
   listen(port, hostnameOrCallback, maybeCallback) {
-    const hostname = typeof hostnameOrCallback === "string" ? hostnameOrCallback : "localhost";
+    const hostname = typeof hostnameOrCallback === "string" ? hostnameOrCallback : this.bunServeOptions.hostname ?? "127.0.0.1";
     const callback = typeof hostnameOrCallback === "function" ? hostnameOrCallback : maybeCallback;
     const middlewareEngine = this.middlewareEngine;
     const notFoundHandler = this.notFoundHandler;
-    const fetch = async (request) => {
+    const wsHandlers = this.wsHandlers;
+    const bunServeOptions = this.bunServeOptions;
+    this.setupWebSocketIfNeeded(wsHandlers, bunServeOptions);
+    const fetch = async (request, server2) => {
+      if (await this.upgradeWebSocket(request, server2)) {
+        return;
+      }
       const bunRequest = new BunRequest(request);
       const bunResponse = new BunResponse;
       const routeHandler = middlewareEngine.findRouteHandler(bunRequest.method, bunRequest.pathname) ?? notFoundHandler;
@@ -1132,42 +1209,127 @@ class BunAdapter extends AbstractHttpAdapter {
       });
       return bunResponse.res();
     };
-    const omit = (obj, ...keys) => {
-      const result = { ...obj };
-      for (const key of keys) {
-        Reflect.deleteProperty(result, key);
+    const server = this.createServer(port, hostname, bunServeOptions, fetch);
+    callback?.();
+    this.setHttpServer(server);
+  }
+  static isNumericPort(value) {
+    return typeof value === "number" || !isNaN(Number(value));
+  }
+  static omitKeys(obj, ...keys) {
+    const result = { ...obj };
+    for (const key of keys) {
+      Reflect.deleteProperty(result, key);
+    }
+    return result;
+  }
+  isWebSocketUpgradeRequest(request) {
+    const upgradeHeader = request.headers.get("upgrade");
+    const connectionHeader = request.headers.get("connection");
+    return !!(upgradeHeader?.toLowerCase() === "websocket" && connectionHeader?.toLowerCase().includes("upgrade"));
+  }
+  async handleWebSocketCors(request) {
+    if (this.wsCorsHeaders) {
+      return this.wsCorsHeaders;
+    }
+    const bunRequest = new BunRequest(request);
+    const bunResponse = new BunResponse;
+    await this.wsMiddlewareEngine.run({
+      req: bunRequest,
+      res: bunResponse,
+      method: bunRequest.method,
+      path: bunRequest.pathname,
+      requestHandler: (req, res) => {
+        res.end();
       }
-      return result;
-    };
-    const server = typeof port === "number" || !isNaN(Number(port)) ? Bun.serve({
-      ...this.bunServeOptions,
+    });
+    const response = await bunResponse.res();
+    this.wsCorsHeaders = response.headers;
+    return this.wsCorsHeaders;
+  }
+  async upgradeWebSocket(request, server) {
+    if (!this.useWs || !this.isWebSocketUpgradeRequest(request)) {
+      return false;
+    }
+    if (!this.useWsCors) {
+      return server.upgrade(request, {
+        data: this.wsOptions.clientDataFactory ? this.wsOptions.clientDataFactory(new BunRequest(request)) : {}
+      });
+    }
+    const headers = await this.handleWebSocketCors(request);
+    return server.upgrade(request, {
+      headers,
+      data: this.wsOptions.clientDataFactory ? this.wsOptions.clientDataFactory(new BunRequest(request)) : {}
+    });
+  }
+  setupWebSocketIfNeeded(wsHandlers, bunServeOptions) {
+    const useWs = !!wsHandlers.onOpen && !!wsHandlers.onMessage && !!wsHandlers.onClose;
+    this.useWs = useWs;
+    if (useWs) {
+      const getServer = this.getHttpServer.bind(this);
+      const onMessage = wsHandlers.onMessage;
+      const onOpen = wsHandlers.onOpen;
+      const onClose = wsHandlers.onClose;
+      bunServeOptions.websocket = {
+        ...this.wsOptions,
+        message: (ws, message) => {
+          ws.data.onMessageInternal?.(message);
+          onMessage?.(ws, message, getServer());
+        },
+        open: (ws) => {
+          onOpen?.(ws);
+        },
+        close: (ws, code, reason) => {
+          ws.data.onCloseInternal?.();
+          ws.data.onDisconnect?.(ws);
+          onClose?.(ws, code, reason);
+        }
+      };
+    }
+    const useWsCors = typeof this.wsOptions.cors !== "undefined";
+    this.useWsCors = useWsCors;
+    if (useWsCors) {
+      const corsMiddleware = new BunCorsMiddleware({
+        corsOptions: this.wsOptions.cors === true ? undefined : this.wsOptions.cors
+      });
+      this.wsMiddlewareEngine.useGlobal(corsMiddleware.run.bind(corsMiddleware));
+    }
+  }
+  createServer(port, hostname, bunServeOptions, fetch) {
+    return BunAdapter.isNumericPort(port) ? Bun.serve({
+      ...bunServeOptions,
       hostname,
       port,
       routes: this.routes,
       fetch
     }) : Bun.serve({
-      ...omit(this.bunServeOptions, "idleTimeout"),
+      ...BunAdapter.omitKeys(bunServeOptions, "idleTimeout", "port", "hostname"),
       unix: port,
       routes: this.routes,
       fetch
     });
-    if (typeof port === "string" && isNaN(Number(port))) {
-      this.logger.log(`Bun server listening on unix socket: ${port}`);
-    }
-    callback?.();
-    Object.defineProperty(server, "address", {
-      configurable: true,
-      enumerable: true,
-      get: () => ({ address: server.hostname, port: server.port })
-    });
-    this.setHttpServer(server);
   }
   delegateRouteHandler(method, path, handler) {
+    this.ensureRouteExists(path);
+    const requestHandler = this.prepareRequestHandler(method, path, handler);
+    this.routes[path][method] = this.createRouteFetchHandler(path, method, requestHandler);
+  }
+  ensureRouteExists(path) {
     if (!(path in this.routes)) {
       this.routes[path] = Object.create(null);
     }
-    const requestHandler = !this.useVersioning ? handler : this.createChainedHandlerForVersioningResolution(this.createVersioningHandlers(method, path, handler), this.notFoundHandler);
-    this.routes[path][method] = async (request) => {
+  }
+  prepareRequestHandler(method, path, handler) {
+    if (!this.useVersioning) {
+      return handler;
+    }
+    return this.createChainedHandlerForVersioningResolution(this.createVersioningHandlers(method, path, handler), this.notFoundHandler);
+  }
+  createRouteFetchHandler(path, method, requestHandler) {
+    return async (request, server) => {
+      if (path === "/" && await this.upgradeWebSocket(request, server)) {
+        return;
+      }
       const bunRequest = new BunRequest(request);
       const bunResponse = new BunResponse;
       await this.middlewareEngine.run({
@@ -1263,12 +1425,159 @@ BunFileInterceptor = __legacyDecorateClassTS([
     typeof HttpAdapterHost === "undefined" ? Object : HttpAdapterHost
   ])
 ], BunFileInterceptor);
+// lib/bun.ws-adapter.ts
+import {
+  AbstractWsAdapter
+} from "@nestjs/websockets";
+import { EMPTY, Subject, mergeMap } from "rxjs";
+import { Logger as Logger2 } from "@nestjs/common";
+import { isNil } from "@nestjs/common/utils/shared.utils.js";
+var WS_READY_STATE_OPEN = 1;
+var defaultMessageParser = (data) => {
+  if (typeof data === "string") {
+    return JSON.parse(data);
+  }
+  if (data instanceof ArrayBuffer) {
+    return JSON.parse(new TextDecoder().decode(data));
+  }
+  if (Buffer.isBuffer(data)) {
+    return JSON.parse(data.toString("utf8"));
+  }
+  return JSON.parse(Buffer.concat(data).toString("utf8"));
+};
+
+class BunWsAdapter extends AbstractWsAdapter {
+  logger = new Logger2(BunWsAdapter.name);
+  nestApp;
+  messageParser = defaultMessageParser;
+  onOpenHandler;
+  globalHandlersInitialized = false;
+  constructor(appOrHttpServer) {
+    super(appOrHttpServer);
+    if (!appOrHttpServer || !("getHttpAdapter" in appOrHttpServer)) {
+      throw new Error("BunWsAdapter requires a NestApplication instance in the constructor.");
+    }
+    this.nestApp = appOrHttpServer;
+  }
+  create(_port, options) {
+    if (options?.messageParser) {
+      this.messageParser = options.messageParser;
+    }
+    const server = this.nestApp.getHttpAdapter().getHttpServer();
+    const wsOptions = this.extractWsOptions(options);
+    server.setWsOptions(wsOptions);
+    this.initializeGlobalHandlers(server);
+    return server;
+  }
+  extractWsOptions(options) {
+    if (!options) {
+      return {};
+    }
+    const wsOptions = { ...options };
+    delete wsOptions.messageParser;
+    return wsOptions;
+  }
+  async close(server) {
+    await server.close();
+  }
+  bindClientConnect(server, callback) {
+    this.onOpenHandler = callback;
+  }
+  bindClientDisconnect(client, callback) {
+    const existingHandler = client.data.onDisconnect;
+    client.data.onDisconnect = (ws) => {
+      existingHandler?.(ws);
+      callback(client);
+    };
+  }
+  bindMessageHandlers(client, handlers, transform) {
+    const handlerMap = this.buildHandlerMap(handlers);
+    const message$ = new Subject;
+    let isActive = true;
+    const existingOnMessage = client.data.onMessageInternal;
+    client.data.onMessageInternal = (data) => {
+      existingOnMessage?.(data);
+      if (isActive) {
+        message$.next(data);
+      }
+    };
+    const subscription = message$.pipe(mergeMap((data) => this.processMessage(data, handlerMap, transform))).subscribe({
+      next: (response) => {
+        this.sendResponse(client, response, isActive);
+      },
+      error: (err) => {
+        this.logger.error("Message processing error", err instanceof Error ? err.stack : err);
+      }
+    });
+    const existingOnClose = client.data.onCloseInternal;
+    client.data.onCloseInternal = () => {
+      existingOnClose?.();
+      isActive = false;
+      this.cleanupClient(message$, subscription);
+    };
+  }
+  initializeGlobalHandlers(server) {
+    if (this.globalHandlersInitialized) {
+      return;
+    }
+    this.globalHandlersInitialized = true;
+    server.registerWsOpenHandler((ws) => {
+      this.onOpenHandler?.(ws);
+    });
+    server.registerWsMessageHandler(() => {});
+    server.registerWsCloseHandler(() => {});
+  }
+  buildHandlerMap(handlers) {
+    const map = new Map;
+    for (const handler of handlers) {
+      map.set(handler.message, handler);
+    }
+    return map;
+  }
+  processMessage(data, handlerMap, transform) {
+    try {
+      const parsed = this.messageParser(data);
+      if (typeof parsed.event !== "string") {
+        return EMPTY;
+      }
+      const handler = handlerMap.get(parsed.event);
+      if (!handler) {
+        return EMPTY;
+      }
+      const result = handler.callback(parsed.data, parsed.event);
+      return transform(result).pipe(mergeMap((value) => isNil(value) ? EMPTY : [value]));
+    } catch (error) {
+      this.logger.warn("Failed to parse WebSocket message", error instanceof Error ? error.message : String(error));
+      return EMPTY;
+    }
+  }
+  sendResponse(client, response, isActive) {
+    if (!isActive || client.readyState !== WS_READY_STATE_OPEN) {
+      return;
+    }
+    if (response instanceof ArrayBuffer) {
+      client.send(response);
+      return;
+    }
+    if (ArrayBuffer.isView(response)) {
+      client.send(response.buffer);
+      return;
+    }
+    client.send(JSON.stringify(response));
+  }
+  cleanupClient(message$, subscription) {
+    message$.complete();
+    subscription.unsubscribe();
+  }
+}
 export {
+  BunWsAdapter,
   BunResponse,
   BunRequest,
+  BunPreflightHttpServer,
   BunFileInterceptor,
   BunAdapter
 };
 
-//# debugId=43ACC6E0AFE16AD764756E2164756E21
+//# debugId=1BD5D75380392B3E64756E2164756E21
 //# sourceMappingURL=index.js.map