@kevisual/router 0.0.41 → 0.0.43

package/src/server/server-bun.ts

@@ -0,0 +1,244 @@
+/**
+ * @title Bun Server Implementation
+ * @description Bun 服务器实现,提供基于 Bun.serve 的 HTTP 和 WebSocket 功能
+ * @tags bun, server, websocket, http
+ * @createdAt 2025-12-20
+ */
+import { ServerType, type ServerOpts, type Cors, RouterRes, RouterReq } from './server-type.ts';
+import { ServerBase } from './server-base.ts';
+
+export class BunServer extends ServerBase implements ServerType {
+  declare _server: any;
+  declare _callback: any;
+  declare cors: Cors;
+  constructor(opts?: ServerOpts) {
+    super(opts);
+  }
+  customListen(...args: any[]): void {
+    this.listenWithBun(...args);
+  }
+  /**
+   * Bun 运行时的 listen 实现
+   */
+  private listenWithBun(...args: any[]) {
+    // @ts-ignore - Bun 全局 API
+    if (typeof Bun === 'undefined' || !Bun.serve) {
+      throw new Error('Bun runtime not detected');
+    }
+
+    let port: number = 3000;
+    let hostname: string = 'localhost';
+    let callback: (() => void) | undefined;
+
+    // 解析参数
+    if (typeof args[0] === 'number') {
+      port = args[0];
+      if (typeof args[1] === 'string') {
+        hostname = args[1];
+        callback = args[2] || args[3];
+      } else if (typeof args[1] === 'function') {
+        callback = args[1];
+      } else {
+        callback = args[2];
+      }
+    }
+
+    const requestCallback = this.createCallback() as unknown as (req: RouterReq, res: RouterRes) => void;
+    const wsPath = this.path;
+    // @ts-ignore
+    this._server = Bun.serve({
+      port,
+      hostname,
+      idleTimeout: 0, // 4 minutes idle timeout (max 255 seconds)
+      fetch: async (request: Bun.BunRequest, server: any) => {
+        const host = request.headers.get('host') || 'localhost';
+        const clientInfo = server.requestIP(request); // 返回 { address: string, port: number } 或 null
+        const url = new URL(request.url, `http://${host}`);
+        // 处理 WebSocket 升级请求
+        if (request.headers.get('upgrade') === 'websocket') {
+          const listenPath = this.listeners.map((item) => item.path).filter((item) => item);
+          if (listenPath.includes(url.pathname) || url.pathname === wsPath) {
+            const token = url.searchParams.get('token') || '';
+            const id = url.searchParams.get('id') || '';
+            const upgraded = server.upgrade(request, {
+              data: { url: url, pathname: url.pathname, token, id },
+            });
+            if (upgraded) {
+              return undefined; // WebSocket 连接成功
+            }
+          }
+          return new Response('WebSocket upgrade failed', { status: 400 });
+        }
+
+        // 将 Bun 的 Request 转换为 Node.js 风格的 req/res
+        return new Promise((resolve) => {
+          const req: RouterReq = {
+            url: url.pathname + url.search,
+            method: request.method,
+            headers: Object.fromEntries(request.headers.entries()),
+            socket: {
+              // @ts-ignore
+              remoteAddress: request?.remoteAddress || request?.ip || clientInfo?.address || '',
+              remotePort: clientInfo?.port || 0,
+            }
+          };
+
+          const res: RouterRes = {
+            statusCode: 200,
+            headersSent: false,
+            writableEnded: false,
+            _headers: {} as Record<string, string | string[]>,
+            _bodyChunks: [] as any[],
+            writeHead(statusCode: number, headers: Record<string, string | string[]>) {
+              this.statusCode = statusCode;
+              for (const key in headers) {
+                this._headers[key] = headers[key];
+              }
+              this.headersSent = true;
+            },
+            setHeader(name: string, value: string | string[]) {
+              this._headers[name] = value;
+            },
+            cookie(name: string, value: string, options?: any) {
+              let cookieString = `${name}=${value}`;
+              if (options) {
+                if (options.maxAge) {
+                  cookieString += `; Max-Age=${options.maxAge}`;
+                }
+                if (options.domain) {
+                  cookieString += `; Domain=${options.domain}`;
+                }
+                if (options.path) {
+                  cookieString += `; Path=${options.path}`;
+                }
+                if (options.expires) {
+                  cookieString += `; Expires=${options.expires.toUTCString()}`;
+                }
+                if (options.httpOnly) {
+                  cookieString += `; HttpOnly`;
+                }
+                if (options.secure) {
+                  cookieString += `; Secure`;
+                }
+                if (options.sameSite) {
+                  cookieString += `; SameSite=${options.sameSite}`;
+                }
+              }
+              this.setHeader('Set-Cookie', cookieString);
+            },
+            write(chunk: any, encoding?: string | Function, callback?: Function) {
+              if (typeof encoding === 'function') {
+                callback = encoding;
+                encoding = 'utf8';
+              }
+              if (!this._bodyChunks) {
+                this._bodyChunks = [];
+              }
+              this._bodyChunks.push(chunk);
+              if (callback) callback();
+              return true;
+            },
+            pipe(stream: any) {
+              this.writableEnded = true;
+
+              // 如果是 ReadableStream，直接使用
+              if (stream instanceof ReadableStream) {
+                resolve(
+                  new Response(stream, {
+                    status: this.statusCode,
+                    headers: this._headers as any,
+                  })
+                );
+                return;
+              }
+
+              // 如果是 Node.js 流，转换为 ReadableStream
+              const readableStream = new ReadableStream({
+                start(controller) {
+                  stream.on('data', (chunk: any) => {
+                    controller.enqueue(chunk);
+                  });
+                  stream.on('end', () => {
+                    controller.close();
+                  });
+                  stream.on('error', (err: any) => {
+                    controller.error(err);
+                  });
+                },
+                cancel() {
+                  if (stream.destroy) {
+                    stream.destroy();
+                  }
+                }
+              });
+
+              resolve(
+                new Response(readableStream, {
+                  status: this.statusCode,
+                  headers: this._headers as any,
+                })
+              );
+            },
+            end(data?: string) {
+              this.writableEnded = true;
+
+              // 合并所有写入的数据块
+              let responseData: string | Buffer = data;
+              if (this._bodyChunks && this._bodyChunks.length > 0) {
+                if (data) this._bodyChunks.push(data);
+                // 处理 Buffer 和字符串混合的情况
+                const hasBuffer = this._bodyChunks.some(chunk => chunk instanceof Buffer || chunk instanceof Uint8Array);
+                if (hasBuffer) {
+                  // 如果有 Buffer，转换所有内容为 Buffer 后合并
+                  const buffers = this._bodyChunks.map(chunk => {
+                    if (chunk instanceof Buffer) return chunk;
+                    if (chunk instanceof Uint8Array) return Buffer.from(chunk);
+                    return Buffer.from(String(chunk));
+                  });
+                  responseData = Buffer.concat(buffers);
+                } else {
+                  // 纯字符串，直接拼接
+                  responseData = this._bodyChunks.map(chunk => String(chunk)).join('');
+                }
+              }
+
+              resolve(
+                new Response(responseData as any, {
+                  status: this.statusCode,
+                  headers: this._headers as any,
+                })
+              );
+            },
+          };
+          // 处理请求体
+          if (request.method !== 'GET' && request.method !== 'HEAD') {
+            request.text().then((body) => {
+              (req as any).body = body;
+              requestCallback(req, res);
+            });
+          } else {
+            requestCallback(req, res);
+          }
+        });
+      },
+      websocket: {
+        open: (ws: any) => {
+          ws.send('connected');
+        },
+        message: async (ws: any, message: string | Buffer) => {
+          const pathname = ws.data.pathname || '';
+          const token = ws.data.token || '';
+          const id = ws.data.id || '';
+          await this.onWebSocket({ ws, message, pathname, token, id });
+        },
+        close: (ws: any) => {
+          // WebSocket 连接关闭
+        },
+      },
+    });
+
+    if (callback) {
+      callback();
+    }
+  }
+}

package/src/server/server-type.ts

@@ -0,0 +1,78 @@
+import * as http from 'http';
+
+export type Listener = {
+  id?: string;
+  io?: boolean;
+  path?: string;
+  fun: (...args: any[]) => Promise<void> | void;
+}
+export type ListenerFun = (...args: any[]) => Promise<void> | void;
+export type OnListener = Listener | ListenerFun | (Listener | ListenerFun)[];
+export type Cors = {
+  /**
+   * @default '*''
+   */
+  origin?: string | undefined;
+};
+
+export type ServerOpts<T = {}> = {
+  /**path default `/api/router` */
+  path?: string;
+  /**handle Fn */
+  handle?: (msg?: { path: string; key?: string;[key: string]: any }, ctx?: { req: http.IncomingMessage; res: http.ServerResponse }) => any;
+  cors?: Cors;
+  io?: boolean;
+} & T;
+
+export interface ServerType {
+  path?: string;
+  server?: any;
+  handle: ServerOpts['handle'];
+  setHandle(handle?: any): void;
+  listeners: Listener[];
+  listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
+  listen(port: number, hostname?: string, listeningListener?: () => void): void;
+  listen(port: number, backlog?: number, listeningListener?: () => void): void;
+  listen(port: number, listeningListener?: () => void): void;
+  listen(path: string, backlog?: number, listeningListener?: () => void): void;
+  listen(path: string, listeningListener?: () => void): void;
+  listen(handle: any, backlog?: number, listeningListener?: () => void): void;
+  listen(handle: any, listeningListener?: () => void): void;
+  /**
+   * 兜底监听，当除开 `/api/router` 之外的请求，框架只监听一个api，所以有其他的请求都执行其他的监听
+   * @description 主要是为了兼容其他的监听
+   * @param listener
+   */
+  on(listener: OnListener): void;
+  onWebSocket({ ws, message, pathname, token, id }: { ws: WS; message: string | Buffer; pathname: string, token?: string, id?: string }): void;
+}
+
+type WS = {
+  send: (data: any) => void;
+  close: () => void;
+}
+
+export type RouterReq<T = {}> = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  socket?: {
+    remoteAddress?: string;
+    remotePort?: number;
+  };
+  cookies?: Record<string, string>;
+} & T;
+
+export type RouterRes<T = {}> = {
+  statusCode: number;
+  headersSent: boolean;
+  _headers: Record<string, string | string[]>;
+  _bodyChunks: any[];
+  writableEnded: boolean;
+  writeHead: (statusCode: number, headers?: Record<string, string>) => void;
+  setHeader: (name: string, value: string | string[]) => void;
+  cookie: (name: string, value: string, options?: any) => void;
+  write: (chunk: any) => void;
+  pipe: (stream: any) => void;
+  end: (data?: any) => void;
+} & T;

package/src/server/server.ts

@@ -1,64 +1,22 @@
-import type { IncomingMessage, ServerResponse } from 'node:http';
 import http from 'node:http';
 import https from 'node:https';
 import http2 from 'node:http2';
-import { handleServer } from './handle-server.ts';
-import * as cookie from './cookie.ts';
-export type Listener = (...args: any[]) => void;
+import { isBun } from '../utils/is-engine.ts';
+import { ServerType, Listener, ServerOpts } from './server-type.ts';
+import { ServerBase } from './server-base.ts';
+import { WsServer } from './ws-server.ts';
 
-type CookieFn = (name: string, value: string, options?: cookie.SerializeOptions, end?: boolean) => void;
-
-export type HandleCtx = {
-  req: IncomingMessage & { cookies: Record<string, string> };
-  res: ServerResponse & {
-    /**
-     * cookie 函数， end 参数用于设置是否立即设置到响应头，设置了后面的cookie再设置会覆盖前面的
-     */
-    cookie: CookieFn; //
-  };
-};
-// 实现函数
-export function createHandleCtx(req: IncomingMessage, res: ServerResponse): HandleCtx {
-  // 用于存储所有的 Set-Cookie 字符串
-  const cookies: string[] = [];
-  let handReq = req as HandleCtx['req'];
-  let handRes = res as HandleCtx['res'];
-  // 扩展 res.cookie 方法
-  const cookieFn: CookieFn = (name, value, options = {}, end = true) => {
-    // 序列化新的 Cookie
-    const serializedCookie = cookie.serialize(name, value, options);
-    cookies.push(serializedCookie); // 将新的 Cookie 添加到数组
-    if (end) {
-      // 如果设置了 end 参数，则立即设置到响应头
-      res.setHeader('Set-Cookie', cookies);
-    }
-  };
-  // 解析请求中的现有 Cookie
-  const parsedCookies = cookie.parse(req.headers.cookie || '');
-  handReq.cookies = parsedCookies;
-  handRes.cookie = cookieFn;
-  // 返回扩展的上下文
-  return {
-    req: handReq,
-    res: handRes,
-  };
-}
 export type Cors = {
   /**
    * @default '*''
    */
   origin?: string | undefined;
 };
-export type ServerOpts = {
-  /**path default `/api/router` */
-  path?: string;
-  /**handle Fn */
-  handle?: (msg?: { path: string; key?: string;[key: string]: any }, ctx?: { req: http.IncomingMessage; res: http.ServerResponse }) => any;
-  cors?: Cors;
+export type ServerNodeOpts = ServerOpts<{
   httpType?: 'http' | 'https' | 'http2';
   httpsKey?: string;
   httpsCert?: string;
-};
+}>;
 export const resultError = (error: string, code = 500) => {
   const r = {
     code: code,
@@ -67,41 +25,39 @@ export const resultError = (error: string, code = 500) => {
   return JSON.stringify(r);
 };
 
-export class Server {
-  path = '/api/router';
-  private _server: http.Server | https.Server | http2.Http2SecureServer;
-  public handle: ServerOpts['handle'];
-  private _callback: any;
-  private cors: Cors;
-  private hasOn = false;
+export class ServerNode extends ServerBase implements ServerType {
+  declare _server: http.Server | https.Server | http2.Http2SecureServer;
+  declare _callback: any;
+  declare cors: Cors;
   private httpType = 'http';
+  declare listeners: Listener[];
   private options = {
     key: '',
     cert: '',
   };
-  constructor(opts?: ServerOpts) {
-    this.path = opts?.path || '/api/router';
-    this.handle = opts?.handle;
-    this.cors = opts?.cors;
+  io: WsServer | undefined;
+  constructor(opts?: ServerNodeOpts) {
+    super(opts);
     this.httpType = opts?.httpType || 'http';
     this.options = {
       key: opts?.httpsKey || '',
       cert: opts?.httpsCert || '',
     };
+    const io = opts?.io ?? false;
+    if (io) {
+      this.io = new WsServer(this);
+    }
   }
-  listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
-  listen(port: number, hostname?: string, listeningListener?: () => void): void;
-  listen(port: number, backlog?: number, listeningListener?: () => void): void;
-  listen(port: number, listeningListener?: () => void): void;
-  listen(path: string, backlog?: number, listeningListener?: () => void): void;
-  listen(path: string, listeningListener?: () => void): void;
-  listen(handle: any, backlog?: number, listeningListener?: () => void): void;
-  listen(handle: any, listeningListener?: () => void): void;
-  listen(...args: any[]) {
+  customListen(...args: any[]): void {
+    if (isBun) {
+      throw new Error('Use BunServer from server-bun module for Bun runtime');
+    }
     this._server = this.createServer();
     const callback = this.createCallback();
     this._server.on('request', callback);
     this._server.listen(...args);
+
+    this.io?.listen();
   }
   createServer() {
     let server: http.Server | https.Server | http2.Http2SecureServer;
@@ -132,112 +88,4 @@ export class Server {
     server = http.createServer();
     return server;
   }
-  setHandle(handle?: any) {
-    this.handle = handle;
-  }
-  /**
-   * get callback
-   * @returns
-   */
-  createCallback() {
-    const path = this.path;
-    const handle = this.handle;
-    const cors = this.cors;
-    const _callback = async (req: IncomingMessage, res: ServerResponse) => {
-      // only handle /api/router
-      if (req.url === '/favicon.ico') {
-        return;
-      }
-      if (res.headersSent) {
-        // 程序已经在其他地方响应了
-        return;
-      }
-      if (this.hasOn && !req.url.startsWith(path)) {
-        // 其他监听存在，不判断不是当前路径的请求，
-        // 也就是不处理!url.startsWith(path)这个请求了
-        // 交给其他监听处理
-        return;
-      }
-      if (cors) {
-        res.setHeader('Access-Control-Allow-Origin', cors?.origin || '*'); // 允许所有域名的请求访问，可以根据需要设置具体的域名
-        res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
-        res.setHeader('Access-Control-Allow-Methods', 'GET, POST');
-        if (req.method === 'OPTIONS') {
-          res.end();
-          return;
-        }
-      }
-      const url = req.url;
-      if (!url.startsWith(path)) {
-        res.end(resultError(`not path:[${path}]`));
-        return;
-      }
-      const messages = await handleServer(req, res);
-      if (!handle) {
-        res.end(resultError('no handle'));
-        return;
-      }
-      try {
-        const end = await handle(messages as any, { req, res });
-        if (res.writableEnded) {
-          // 如果响应已经结束，则不进行任何操作
-          return;
-        }
-        res.setHeader('Content-Type', 'application/json; charset=utf-8');
-        if (typeof end === 'string') {
-          res.end(end);
-        } else {
-          res.end(JSON.stringify(end));
-        }
-      } catch (e) {
-        console.error(e);
-        res.setHeader('Content-Type', 'application/json; charset=utf-8');
-        if (e.code && typeof e.code === 'number') {
-          res.end(resultError(e.message || `Router Server error`, e.code));
-        } else {
-          res.end(resultError('Router Server error'));
-        }
-      }
-    };
-    this._callback = _callback;
-    return _callback;
-  }
-  get handleServer() {
-    return this._callback;
-  }
-  set handleServer(fn: any) {
-    this._callback = fn;
-  }
-  /**
-   * 兜底监听，当除开 `/api/router` 之外的请求，框架只监听一个api，所以有其他的请求都执行其他的监听
-   * @description 主要是为了兼容其他的监听
-   * @param listener
-   */
-  on(listener: Listener | Listener[]) {
-    this._server = this._server || this.createServer();
-    this._server.removeAllListeners('request');
-    this.hasOn = true;
-    if (Array.isArray(listener)) {
-      listener.forEach((l) => this._server.on('request', l));
-    } else {
-      this._server.on('request', listener);
-    }
-    const callbackListener = this._callback || this.createCallback();
-    this._server.on('request', callbackListener);
-    return () => {
-      if (Array.isArray(listener)) {
-        listener.forEach((l) => this._server.removeListener('request', l as Listener));
-      } else {
-        this._server.removeListener('request', listener as Listener);
-      }
-      this.hasOn = false;
-      this._server.removeListener('request', callbackListener);
-    }
-  }
-  get callback() {
-    return this._callback || this.createCallback();
-  }
-  get server() {
-    return this._server;
-  }
-}
+}