@kevisual/router 0.0.41 → 0.0.42

package/src/server/server-type.ts

@@ -0,0 +1,70 @@
+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 | Listener[] | ListenerFun | 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 CommonReq = {
+  url: string;
+  method: string;
+  headers: Record<string, string>;
+  [key: string]: any;
+}
+
+export type CommonRes = {
+  statusCode: number;
+  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;
+  end: (data?: any) => void;
+  [key: string]: any;
+}

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;
-  }
-}
+}

package/src/server/ws-server.ts

@@ -1,39 +1,38 @@
 // @ts-type=ws
 import { WebSocketServer } from 'ws';
 import type { WebSocket } from 'ws';
-import { Server } from './server.ts';
+import { ServerType } from './server-type.ts'
 import { parseIfJson } from '../utils/parse.ts';
+import { isBun } from '../utils/is-engine.ts';
 
 
-export const createWsServer = (server: Server) => {
+export const createWsServer = (server: ServerType) => {
   // 将 WebSocket 服务器附加到 HTTP 服务器
   const wss = new WebSocketServer({ server: server.server as any });
   return wss;
 };
 type WsServerBaseOpts = {
-  wss?: WebSocketServer;
+  wss?: WebSocketServer | null;
   path?: string;
 };
 export type ListenerFn = (message: { data: Record<string, any>; ws: WebSocket; end: (data: any) => any }) => Promise<any>;
 export type Listener<T = 'router' | 'chat' | 'ai'> = {
   type: T;
+  path?: string;
   listener: ListenerFn;
 };
 
 export class WsServerBase {
-  wss: WebSocketServer;
-  path: string;
-  listeners: { type: string; listener: ListenerFn }[] = [];
+  wss: WebSocketServer | null;
+  listeners: Listener[] = [];
   listening: boolean = false;
+  server: ServerType;
+
   constructor(opts: WsServerBaseOpts) {
     this.wss = opts.wss;
-    if (!this.wss) {
+    if (!this.wss && !isBun) {
       throw new Error('wss is required');
     }
-    this.path = opts.path || '';
-  }
-  setPath(path: string) {
-    this.path = path;
   }
   listen() {
     if (this.listening) {
@@ -42,116 +41,49 @@ export class WsServerBase {
     }
     this.listening = true;
 
-    this.wss.on('connection', (ws) => {
-      ws.on('message', async (message: string | Buffer) => {
-        const data = parseIfJson(message);
-        if (typeof data === 'string') {
-          const cleanMessage = data.trim().replace(/^["']|["']$/g, '');
-          ws.emit('string', cleanMessage);
-          return;
-        }
-        const { type, data: typeData, ...rest } = data;
-        if (!type) {
-          ws.send(JSON.stringify({ code: 500, message: 'type is required' }));
-        }
-        const listeners = this.listeners.find((item) => item.type === type);
-        const res = {
-          type,
-          data: {} as any,
-          ...rest,
-        };
-        const end = (data: any, all?: Record<string, any>) => {
-          const result = {
-            ...res,
-            data,
-            ...all,
-          };
-          ws.send(JSON.stringify(result));
-        };
+    if (!this.wss) {
+      // Bun 环境下，wss 可能为 null
+      return;
+    }
 
-        if (!listeners) {
-          const data = { code: 500, message: `${type} server is error` };
-          end(data);
-          return;
-        }
-        listeners.listener({
-          data: typeData,
-          ws,
-          end: end,
-        });
-      });
-      ws.on('string', (message: string) => {
-        if (message === 'close') {
-          ws.close();
-        }
-        if (message == 'ping') {
-          ws.send('pong');
-        }
+    this.wss.on('connection', (ws, req) => {
+      const url = new URL(req.url, 'http://localhost');
+      const pathname = url.pathname;
+      const token = url.searchParams.get('token') || '';
+      const id = url.searchParams.get('id') || '';
+      ws.on('message', async (message: string | Buffer) => {
+        await this.server.onWebSocket({ ws, message, pathname, token, id });
       });
       ws.send('connected');
     });
   }
-  addListener(type: string, listener: ListenerFn) {
-    if (!type || !listener) {
-      throw new Error('type and listener is required');
-    }
-    const find = this.listeners.find((item) => item.type === type);
-    if (find) {
-      this.listeners = this.listeners.filter((item) => item.type !== type);
-    }
-    this.listeners.push({ type, listener });
-  }
-  removeListener(type: string) {
-    this.listeners = this.listeners.filter((item) => item.type !== type);
-  }
 }
 // TODO: ws handle and path and routerContext
 export class WsServer extends WsServerBase {
-  server: Server;
-  constructor(server: Server, opts?: any) {
-    const wss = new WebSocketServer({ noServer: true });
-    const path = server.path;
+  constructor(server: ServerType) {
+    const wss = isBun ? null : new WebSocketServer({ noServer: true });
     super({ wss });
     this.server = server;
-    this.setPath(opts?.path || path);
-    this.initListener();
-  }
-  initListener() {
-    const server = this.server;
-    const listener: Listener = {
-      type: 'router',
-      listener: async ({ data, ws, end }) => {
-        if (!server) {
-          end({ code: 500, message: 'server handle is error' });
-          return;
-        }
-        const handle = this.server.handle;
-        try {
-          const result = await handle(data as any);
-          end(result);
-        } catch (e) {
-          if (e.code && typeof e.code === 'number') {
-            end({
-              code: e.code,
-              message: e.message,
-            });
-          } else {
-            end({ code: 500, message: 'Router Server error' });
-          }
-        }
-      },
-    };
-    this.addListener(listener.type, listener.listener);
   }
   listen() {
+    if (isBun) {
+      // Bun 的 WebSocket 在 Bun.serve 中处理，这里不需要额外操作
+      // WebSocket 升级会在 listenWithBun 中处理
+      this.listening = true;
+      return;
+    }
     super.listen();
     const server = this.server;
     const wss = this.wss;
+
     // HTTP 服务器的 upgrade 事件
+    // @ts-ignore
     server.server.on('upgrade', (req, socket, head) => {
-      if (req.url === this.path) {
+      const url = new URL(req.url, 'http://localhost');
+      const listenPath = this.server.listeners.map((item) => item.path).filter((item) => item);
+      if (listenPath.includes(url.pathname) || url.pathname === this.server.path) {
         wss.handleUpgrade(req, socket, head, (ws) => {
-          // 这里手动触发 connection 事件
+          // 这里手动触发 connection事件
           // @ts-ignore
           wss.emit('connection', ws, req);
         });

package/src/test/listen-ip.ts

@@ -1,7 +1,7 @@
 // import { Server } from 'node:http';
-import { Server } from '../server/server.ts'
+import { ServerNode } from '../server/server.ts'
 
-const server = new Server({
+const server = new ServerNode({
   path: '/',
   handle: async (data, ctx) => {
     console.log('ctx', ctx.req.url)

package/src/utils/is-engine.ts

@@ -2,9 +2,13 @@ export const isNode = typeof process !== 'undefined' && process.versions != null
 export const isBrowser = typeof window !== 'undefined' && typeof document !== 'undefined' && typeof document.createElement === 'function';
 // @ts-ignore
 export const isDeno = typeof Deno !== 'undefined' && typeof Deno.version === 'object' && typeof Deno.version.deno === 'string';
+// @ts-ignore
+export const isBun = typeof Bun !== 'undefined' && typeof Bun.version === 'string';
 
 export const getEngine = () => {
-  if (isNode) {
+  if (isBun) {
+    return 'bun';
+  } else if (isNode) {
     return 'node';
   } else if (isBrowser) {
     return 'browser';