@kevisual/router 0.0.42 → 0.0.44

package/dist/router.d.ts

@@ -1,10 +1,12 @@
-import http$1, { IncomingMessage, ServerResponse } from 'node:http';
+import * as http from 'node:http';
+import http__default, { IncomingMessage, ServerResponse } from 'node:http';
 import https from 'node:https';
 import http2 from 'node:http2';
-import * as http from 'http';
-import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from 'http';
+import EventEmitter from 'node:events';
+import { EventEmitter as EventEmitter$1 } from 'events';
 import { WebSocketServer, WebSocket } from 'ws';
 import { z } from 'zod';
+import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from 'http';
 import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
 import { Query, DataOpts, Result } from '@kevisual/query/query';
 
@@ -383,14 +385,6 @@ declare class QueryConnect {
     }[];
 }
 
-type Listener$1 = {
-    id?: string;
-    io?: boolean;
-    path?: string;
-    fun: (...args: any[]) => Promise<void> | void;
-};
-type ListenerFun = (...args: any[]) => Promise<void> | void;
-type OnListener = Listener$1 | Listener$1[] | ListenerFun | ListenerFun[];
 type Cors$2 = {
     /**
      * @default '*''
@@ -432,18 +426,64 @@ interface ServerType {
      * @param listener
      */
     on(listener: OnListener): void;
-    onWebSocket({ ws, message, pathname, token, id }: {
-        ws: WS;
-        message: string | Buffer;
-        pathname: string;
-        token?: string;
-        id?: string;
-    }): void;
+    onWebSocket({ ws, message, pathname, token, id }: OnWebSocketOptions): void;
 }
+type OnWebSocketOptions = {
+    ws: WS;
+    message: string | Buffer;
+    pathname: string;
+    token?: string;
+    id?: string;
+};
+type OnWebSocketFn = (options: OnWebSocketOptions) => Promise<void> | void;
 type WS = {
     send: (data: any) => void;
-    close: () => void;
+    close: (code?: number, reason?: string) => void;
+};
+type Listener$1 = {
+    id?: string;
+    io?: boolean;
+    path?: string;
+    fun: WebScoketListenerFun | HttpListenerFun;
+};
+type WebScoketListenerFun = (req: WebSocketReq, res: WebSocketRes) => Promise<void> | void;
+type HttpListenerFun = (req: RouterReq, res: RouterRes) => Promise<void> | void;
+type WebSocketReq = {
+    emitter?: EventEmitter;
+    ws: WS;
+    data: any;
+    pathname?: string;
+    token?: string;
+    id?: string;
 };
+type WebSocketRes = {
+    end: (data: any) => void;
+};
+type ListenerFun = WebScoketListenerFun | HttpListenerFun;
+type OnListener = Listener$1 | ListenerFun | (Listener$1 | ListenerFun)[];
+type RouterReq<T = {}> = {
+    url: string;
+    method: string;
+    headers: Record<string, string>;
+    socket?: {
+        remoteAddress?: string;
+        remotePort?: number;
+    };
+    cookies?: Record<string, string>;
+} & T;
+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;
 
 interface StringifyOptions {
     /**
@@ -565,6 +605,7 @@ declare class ServerBase implements ServerType {
     _callback: any;
     cors: Cors$1;
     listeners: Listener$1[];
+    emitter: EventEmitter$1<any>;
     constructor(opts?: ServerOpts);
     listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
     listen(port: number, hostname?: string, listeningListener?: () => void): void;
@@ -590,13 +631,7 @@ declare class ServerBase implements ServerType {
      */
     createCallback(): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
     on(listener: OnListener): void;
-    onWebSocket({ ws, message, pathname, token, id }: {
-        ws: any;
-        message: any;
-        pathname: any;
-        token: any;
-        id: any;
-    }): Promise<void>;
+    onWebSocket({ ws, message, pathname, token, id }: OnWebSocketOptions): Promise<void>;
 }
 
 type WsServerBaseOpts = {
@@ -638,7 +673,7 @@ type ServerNodeOpts = ServerOpts<{
     httpsCert?: string;
 }>;
 declare class ServerNode extends ServerBase implements ServerType {
-    _server: http$1.Server | https.Server | http2.Http2SecureServer;
+    _server: http__default.Server | https.Server | http2.Http2SecureServer;
     _callback: any;
     cors: Cors;
     private httpType;
@@ -647,7 +682,7 @@ declare class ServerNode extends ServerBase implements ServerType {
     io: WsServer | undefined;
     constructor(opts?: ServerNodeOpts);
     customListen(...args: any[]): void;
-    createServer(): http$1.Server<typeof http$1.IncomingMessage, typeof http$1.ServerResponse> | http2.Http2SecureServer<typeof http$1.IncomingMessage, typeof http$1.ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>;
+    createServer(): http__default.Server<typeof http__default.IncomingMessage, typeof http__default.ServerResponse> | http2.Http2SecureServer<typeof http__default.IncomingMessage, typeof http__default.ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>;
 }
 
 /**
@@ -889,4 +924,4 @@ declare class App<U = {}> {
 }
 
 export { App, Connect, CustomError, Mini, QueryConnect, QueryRouter, QueryRouterServer, QueryUtil, Route, ServerNode, createSchema, define, handleServer, util };
-export type { RouteArray, RouteContext, RouteMiddleware, RouteObject, RouteOpts, Rule, Run, Schema };
+export type { OnWebSocketFn, RouteArray, RouteContext, RouteMiddleware, RouteObject, RouteOpts, RouterReq, RouterRes, Rule, Run, Schema };

package/dist/router.js

@@ -3,7 +3,7 @@ import require$$2 from 'node:http';
 import require$$1$1 from 'node:https';
 import http2 from 'node:http2';
 import url from 'node:url';
-import require$$0$3 from 'node:events';
+import require$$0$3, { EventEmitter } from 'node:events';
 import require$$3 from 'node:net';
 import require$$4 from 'node:tls';
 import require$$0$2 from 'node:stream';
@@ -1214,6 +1214,7 @@ class ServerBase {
     _callback;
     cors;
     listeners = [];
+    emitter = new EventEmitter();
     constructor(opts) {
         this.path = opts?.path || '/api/router';
         this.handle = opts?.handle;
@@ -1348,6 +1349,7 @@ class ServerBase {
                 ws.send(JSON.stringify(data));
             };
             listener.fun({
+                emitter: this.emitter,
                 data,
                 token,
                 id,
@@ -6498,6 +6500,7 @@ class BunServer extends ServerBase {
             idleTimeout: 0, // 4 minutes idle timeout (max 255 seconds)
             fetch: async (request, server) => {
                 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') {
@@ -6520,12 +6523,18 @@ class BunServer extends ServerBase {
                         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 = {
                         statusCode: 200,
                         headersSent: false,
                         writableEnded: false,
                         _headers: {},
+                        _bodyChunks: [],
                         writeHead(statusCode, headers) {
                             this.statusCode = statusCode;
                             for (const key in headers) {
@@ -6563,9 +6572,79 @@ class BunServer extends ServerBase {
                             }
                             this.setHeader('Set-Cookie', cookieString);
                         },
+                        write(chunk, encoding, callback) {
+                            if (typeof encoding === 'function') {
+                                callback = encoding;
+                                encoding = 'utf8';
+                            }
+                            if (!this._bodyChunks) {
+                                this._bodyChunks = [];
+                            }
+                            this._bodyChunks.push(chunk);
+                            if (callback)
+                                callback();
+                            return true;
+                        },
+                        pipe(stream) {
+                            this.writableEnded = true;
+                            // 如果是 ReadableStream，直接使用
+                            if (stream instanceof ReadableStream) {
+                                resolve(new Response(stream, {
+                                    status: this.statusCode,
+                                    headers: this._headers,
+                                }));
+                                return;
+                            }
+                            // 如果是 Node.js 流，转换为 ReadableStream
+                            const readableStream = new ReadableStream({
+                                start(controller) {
+                                    stream.on('data', (chunk) => {
+                                        controller.enqueue(chunk);
+                                    });
+                                    stream.on('end', () => {
+                                        controller.close();
+                                    });
+                                    stream.on('error', (err) => {
+                                        controller.error(err);
+                                    });
+                                },
+                                cancel() {
+                                    if (stream.destroy) {
+                                        stream.destroy();
+                                    }
+                                }
+                            });
+                            resolve(new Response(readableStream, {
+                                status: this.statusCode,
+                                headers: this._headers,
+                            }));
+                        },
                         end(data) {
                             this.writableEnded = true;
-                            resolve(new Response(data, {
+                            // 合并所有写入的数据块
+                            let responseData = 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, {
                                 status: this.statusCode,
                                 headers: this._headers,
                             }));
@@ -6585,7 +6664,7 @@ class BunServer extends ServerBase {
             },
             websocket: {
                 open: (ws) => {
-                    ws.send('connected');
+                    ws.send({ type: 'connected' });
                 },
                 message: async (ws, message) => {
                     const pathname = ws.data.pathname || '';
@@ -6595,6 +6674,14 @@ class BunServer extends ServerBase {
                 },
                 close: (ws) => {
                     // WebSocket 连接关闭
+                    const id = ws?.data?.id || '';
+                    if (id) {
+                        this.emitter.emit(id, { type: 'close', ws, id });
+                        setTimeout(() => {
+                            // 关闭后 5 秒清理监听器, 避免内存泄漏， 理论上原本的自己就应该被清理掉了，这里是保险起见
+                            this.emitter.removeAllListeners(id);
+                        }, 5000);
+                    }
                 },
             },
         });
@@ -11081,7 +11168,7 @@ class App {
         }
         this.server.on({
             id: 'app-request-listener',
-            fun: fn
+            fun: fn,
         });
     }
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.42",
+  "version": "0.0.44",
   "description": "",
   "type": "module",
   "main": "./dist/router.js",

package/src/app.ts

@@ -134,7 +134,7 @@ export class App<U = {}> {
     }
     this.server.on({
       id: 'app-request-listener',
-      fun: fn
+      fun: fn as any,
     });
   }
 }

package/src/index.ts

@@ -18,3 +18,6 @@ export type { Rule, Schema, } from './validator/index.ts';
 export { App } from './app.ts';
 
 export * from './router-define.ts';
+
+
+export { RouterReq, RouterRes, OnWebSocketFn } from './server/server-type.ts';

package/src/server/server-base.ts

@@ -1,9 +1,9 @@
 import type { IncomingMessage, ServerResponse } from 'node:http';
 import { handleServer } from './handle-server.ts';
 import * as cookie from './cookie.ts';
-import { ServerType, Listener, OnListener, ServerOpts } from './server-type.ts';
+import { ServerType, Listener, OnListener, ServerOpts, OnWebSocketOptions, OnWebSocketFn, WebScoketListenerFun, ListenerFun, HttpListenerFun } from './server-type.ts';
 import { parseIfJson } from '../utils/parse.ts';
-
+import { EventEmitter } from 'events';
 type CookieFn = (name: string, value: string, options?: cookie.SerializeOptions, end?: boolean) => void;
 
 export type HandleCtx = {
@@ -63,6 +63,7 @@ export class ServerBase implements ServerType {
   _callback: any;
   cors: Cors;
   listeners: Listener[] = [];
+  emitter = new EventEmitter();
   constructor(opts?: ServerOpts) {
     this.path = opts?.path || '/api/router';
     this.handle = opts?.handle;
@@ -118,7 +119,7 @@ export class ServerBase implements ServerType {
       }
       const listeners = that.listeners || [];
       for (const item of listeners) {
-        const fun = item.fun;
+        const fun = item.fun as any;
         if (typeof fun === 'function' && !item.io) {
           await fun(req, res);
         }
@@ -193,7 +194,7 @@ export class ServerBase implements ServerType {
       this.listeners.push(listener);
     }
   }
-  async onWebSocket({ ws, message, pathname, token, id }) {
+  async onWebSocket({ ws, message, pathname, token, id }: OnWebSocketOptions) {
     const listener = this.listeners.find((item) => item.path === pathname && item.io);
     const data: any = parseIfJson(message);
 
@@ -201,7 +202,8 @@ export class ServerBase implements ServerType {
       const end = (data: any) => {
         ws.send(JSON.stringify(data));
       }
-      listener.fun({
+      (listener.fun as WebScoketListenerFun)({
+        emitter: this.emitter,
         data,
         token,
         id,

package/src/server/server-bun.ts

@@ -4,19 +4,8 @@
  * @tags bun, server, websocket, http
  * @createdAt 2025-12-20
  */
-import type { IncomingMessage, ServerResponse } from 'node:http';
-import { ServerType, type ServerOpts, type Cors, Listener } from './server-type.ts';
-import { handleServer } from './handle-server.ts';
+import { ServerType, type ServerOpts, type Cors, RouterRes, RouterReq } from './server-type.ts';
 import { ServerBase } from './server-base.ts';
-import { parseIfJson } from '../utils/parse.ts';
-
-const resultError = (error: string, code = 500) => {
-  const r = {
-    code: code,
-    message: error,
-  };
-  return JSON.stringify(r);
-};
 
 export class BunServer extends ServerBase implements ServerType {
   declare _server: any;
@@ -54,15 +43,16 @@ export class BunServer extends ServerBase implements ServerType {
       }
     }
 
-    const requestCallback = this.createCallback();
+    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: Request, server: any) => {
+      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') {
@@ -82,17 +72,23 @@ export class BunServer extends ServerBase implements ServerType {
 
         // 将 Bun 的 Request 转换为 Node.js 风格的 req/res
         return new Promise((resolve) => {
-          const req: any = {
+          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: any = {
+          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) {
@@ -130,10 +126,84 @@ export class BunServer extends ServerBase implements ServerType {
               }
               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(data, {
+                new Response(responseData as any, {
                   status: this.statusCode,
                   headers: this._headers as any,
                 })
@@ -153,7 +223,7 @@ export class BunServer extends ServerBase implements ServerType {
       },
       websocket: {
         open: (ws: any) => {
-          ws.send('connected');
+          ws.send({ type: 'connected' });
         },
         message: async (ws: any, message: string | Buffer) => {
           const pathname = ws.data.pathname || '';
@@ -163,6 +233,14 @@ export class BunServer extends ServerBase implements ServerType {
         },
         close: (ws: any) => {
           // WebSocket 连接关闭
+          const id = ws?.data?.id || '';
+          if (id) {
+            this.emitter.emit(id, { type: 'close', ws, id });
+            setTimeout(() => {
+              // 关闭后 5 秒清理监听器, 避免内存泄漏， 理论上原本的自己就应该被清理掉了，这里是保险起见
+              this.emitter.removeAllListeners(id);
+            }, 5000);
+          }
         },
       },
     });

package/src/server/server-type.ts

@@ -1,13 +1,7 @@
-import * as http from 'http';
+import EventEmitter from 'node:events';
+import * as http from 'node: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 | Listener[] | ListenerFun | ListenerFun[];
 export type Cors = {
   /**
    * @default '*''
@@ -44,27 +38,59 @@ export interface ServerType {
    * @param listener
    */
   on(listener: OnListener): void;
-  onWebSocket({ ws, message, pathname, token, id }: { ws: WS; message: string | Buffer; pathname: string, token?: string, id?: string }): void;
+  onWebSocket({ ws, message, pathname, token, id }: OnWebSocketOptions): void;
 }
 
+export type OnWebSocketOptions = { ws: WS; message: string | Buffer; pathname: string, token?: string, id?: string }
+export type OnWebSocketFn = (options: OnWebSocketOptions) => Promise<void> | void;
 type WS = {
   send: (data: any) => void;
-  close: () => void;
+  close: (code?: number, reason?: string) => void;
+}
+export type Listener = {
+  id?: string;
+  io?: boolean;
+  path?: string;
+  fun: WebScoketListenerFun | HttpListenerFun;
 }
 
-export type CommonReq = {
+export type WebScoketListenerFun = (req: WebSocketReq, res: WebSocketRes) => Promise<void> | void;
+export type HttpListenerFun = (req: RouterReq, res: RouterRes) => Promise<void> | void;
+
+export type WebSocketReq = {
+  emitter?: EventEmitter;
+  ws: WS;
+  data: any;
+  pathname?: string;
+  token?: string;
+  id?: string;
+}
+export type WebSocketRes = {
+  end: (data: any) => void;
+}
+export type ListenerFun = WebScoketListenerFun | HttpListenerFun;;
+export type OnListener = Listener | ListenerFun | (Listener | ListenerFun)[];
+export type RouterReq<T = {}> = {
   url: string;
   method: string;
   headers: Record<string, string>;
-  [key: string]: any;
-}
+  socket?: {
+    remoteAddress?: string;
+    remotePort?: number;
+  };
+  cookies?: Record<string, string>;
+} & T;
 
-export type CommonRes = {
+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;
-  [key: string]: any;
-}
+} & T;