fix some types and exports

Author: eslym

src/files/handle.ts

@@ -71,7 +71,7 @@ function resolve_xff_ip(request: Request, depth: number) {
     return ips.at(-depth) || undefined;
 }
 
-export async function create_fetch({
+export function create_fetch({
     overrideOrigin,
     hostHeader,
     protocolHeader,
@@ -98,7 +98,7 @@ export async function create_fetch({
     if (SERVE_STATIC) {
         resolvers.push(serve_static);
     }
-    return (request: Request, srv: Server) => {
+    return (request: Request, srv: Bun.Server<unknown>) => {
         const request_ip = srv.requestIP(request)?.address;
         const try_get_ip = getIp ? () => getIp(request, request_ip) : () => request_ip;
         return first_resolve(request, [

src/files/index.ts

@@ -4,20 +4,29 @@ import type { WebSocketHandler } from '../types';
 import { create_fetch } from './handle';
 import type { WebSocketHandler as BunWSHandler } from 'bun';
 import { bool_env, bytes_env, duration_env, get_env, int_env } from './env';
-import { resolve } from 'path';
 
-Bun.plugin({
-    name: 'asset-module',
-    target: 'bun',
-    setup(build) {
-        build.module('sveltekit-adapter-bun:assets', async () => ({
-            loader: 'object',
-            exports: await import(resolve(import.meta.dir, './assets'))
-        }));
+export const websocketHandler = {
+    message(ws, message) {
+        return ws.data.message(ws, message);
+    },
+    open(ws) {
+        return ws.data.open?.(ws);
+    },
+    close(ws, code, reason) {
+        return ws.data.close?.(ws, code, reason);
+    },
+    ping(ws, data) {
+        return ws.data.ping?.(ws, data);
+    },
+    pong(ws, data) {
+        return ws.data.pong?.(ws, data);
+    },
+    drain(ws) {
+        return ws.data.drain?.(ws);
     }
-});
+} as BunWSHandler<WebSocketHandler>;
 
-async function serve() {
+export function serveOptions() {
     const socket = get_env('HTTP_SOCKET');
     const serverOptions = socket
         ? {
@@ -28,41 +37,36 @@ async function serve() {
               port: get_env('HTTP_PORT', '3000')
           };
 
-    const server = Bun.serve({
+    return {
         ...serverOptions,
         idleTimeout: duration_env('HTTP_IDLE_TIMEOUT', 30),
-        maxRequestBodySize: bytes_env('HTTP_MAX_BODY', 128 * 1024 * 1024),
-        fetch: await create_fetch({
+        maxRequestBodySize: bytes_env('HTTP_MAX_BODY', 128 * 1024 * 1024)
+    };
+}
+
+export function websocketOptions() {
+    return {
+        idleTimeout: duration_env('WS_IDLE_TIMEOUT', 120),
+        maxPayloadLength: bytes_env('WS_MAX_PAYLOAD', 16 * 1024 * 1024),
+        sendPings: !bool_env('WS_NO_PING')
+    };
+}
+
+export function serve() {
+    const server = Bun.serve({
+        ...serveOptions(),
+        fetch: create_fetch({
             overrideOrigin: get_env('HTTP_OVERRIDE_ORIGIN'),
             hostHeader: get_env('HTTP_HOST_HEADER'),
             protocolHeader: get_env('HTTP_PROTOCOL_HEADER'),
             ipHeader: get_env('HTTP_IP_HEADER'),
             xffDepth: int_env('HTTP_XFF_DEPTH', 1)
         }),
         websocket: {
-            idleTimeout: duration_env('WS_IDLE_TIMEOUT', 120),
-            maxPayloadLength: bytes_env('WS_MAX_PAYLOAD', 16 * 1024 * 1024),
-            sendPings: !bool_env('WS_NO_PING'),
-            message(ws, message) {
-                return ws.data.message(ws, message);
-            },
-            open(ws) {
-                return ws.data.open?.(ws);
-            },
-            close(ws, code, reason) {
-                return ws.data.close?.(ws, code, reason);
-            },
-            ping(ws, data) {
-                return ws.data.ping?.(ws, data);
-            },
-            pong(ws, data) {
-                return ws.data.pong?.(ws, data);
-            },
-            drain(ws) {
-                return ws.data.drain?.(ws);
-            }
-        } as BunWSHandler<WebSocketHandler>
-    });
+            ...websocketOptions(),
+            ...websocketHandler
+        }
+    } as any);
     console.log(`Serving on ${server.url}`);
 }