@kevisual/router 0.0.10 → 0.0.12

package/src/router-simple.ts

@@ -0,0 +1,76 @@
+import { pathToRegexp, Key } from 'path-to-regexp';
+import type { IncomingMessage, ServerResponse } from 'http';
+import { parseBody, parseSearch } from './server/parse-body.ts';
+
+type Req = IncomingMessage & { params?: Record<string, string> };
+interface Route {
+  method: string;
+  regexp: RegExp;
+  keys: Key[];
+  handlers: Array<(req: Req, res: ServerResponse) => Promise<void> | void>;
+}
+/**
+ * SimpleRouter
+ */
+export class SimpleRouter {
+  routes: Route[] = [];
+  exclude: string[] = []; // 排除的请求
+  constructor(opts?: { exclude?: string[] }) {
+    this.exclude = opts?.exclude || ['/api/router'];
+  }
+  getBody(req: Req) {
+    return parseBody<Record<string, any>>(req);
+  }
+  getSearch(req: Req) {
+    return parseSearch(req);
+  }
+  use(method: string, route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>) {
+    const handlers = Array.isArray(fns) ? fns.flat() : [];
+    const pattern = pathToRegexp(route);
+
+    this.routes.push({ method: method.toLowerCase(), regexp: pattern.regexp, keys: pattern.keys, handlers });
+    return this;
+  }
+  get(route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>) {
+    return this.use('get', route, ...fns);
+  }
+  post(route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>) {
+    return this.use('post', route, ...fns);
+  }
+  all(route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>) {
+    this.use('post', route, ...fns);
+    this.use('get', route, ...fns);
+    return this;
+  }
+  /**
+   * 解析 req 和 res 请求
+   * @param req
+   * @param res
+   * @returns
+   */
+  parse(req: Req, res: ServerResponse) {
+    const { pathname } = new URL(req.url, 'http://localhost');
+    const method = req.method.toLowerCase();
+    if (this.exclude.includes(pathname)) {
+      return 'is_exclude';
+    }
+    const route = this.routes.find((route) => {
+      const matchResult = route.regexp.exec(pathname);
+      if (matchResult && route.method === method) {
+        const params: Record<string, string> = {};
+        route.keys.forEach((key, i) => {
+          params[key.name] = matchResult[i + 1];
+        });
+        req.params = params;
+        return true;
+      }
+    });
+
+    if (route) {
+      const { handlers } = route;
+      return handlers.reduce((promiseChain, handler) => promiseChain.then(() => Promise.resolve(handler(req, res))), Promise.resolve());
+    }
+
+    return 'not_found';
+  }
+}

package/src/server/handle-server.ts

@@ -0,0 +1,57 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { parseBody } from './parse-body.ts';
+import url from 'node:url';
+import { createHandleCtx } from './server.ts';
+
+/**
+ * get params and body
+ * 优先原则
+ * 1. 请求参数中的 payload 的token 优先
+ * 2. 请求头中的 authorization 优先
+ * 3. 请求头中的 cookie 优先
+ * @param req
+ * @param res
+ * @returns
+ */
+export const handleServer = async (req: IncomingMessage, res: ServerResponse) => {
+  if (req.url === '/favicon.ico') {
+    return;
+  }
+  const can = ['get', 'post'];
+  const method = req.method.toLocaleLowerCase();
+  if (!can.includes(method)) {
+    return;
+  }
+  const parsedUrl = url.parse(req.url, true);
+  // 获取token
+  let token = req.headers['authorization'] || '';
+  const handle = createHandleCtx(req, res);
+  const cookies = handle.req.cookies;
+  if (!token) {
+    token = cookies.token; // cookie优先
+  }
+  if (token) {
+    token = token.replace('Bearer ', '');
+  }
+  // 获取查询参数
+  const param = parsedUrl.query;
+  let body: Record<any, any>;
+  if (method === 'post') {
+    body = await parseBody(req);
+  }
+  if (param?.payload && typeof param.payload === 'string') {
+    try {
+      const payload = JSON.parse(param.payload as string);
+      param.payload = payload;
+    } catch (e) {
+      console.error(e);
+    }
+  }
+  const data = {
+    token,
+    ...param,
+    ...body,
+    cookies,
+  };
+  return data;
+};

package/src/server/index.ts

@@ -0,0 +1,2 @@
+export { Server } from './server.ts';
+export { handleServer } from './handle-server.ts';

package/src/server/parse-body.ts

@@ -0,0 +1,24 @@
+import type { IncomingMessage } from 'node:http';
+import url from 'node:url';
+
+export const parseBody = async <T = Record<string, any>>(req: IncomingMessage) => {
+  return new Promise<T>((resolve, reject) => {
+    const arr: any[] = [];
+    req.on('data', (chunk) => {
+      arr.push(chunk);
+    });
+    req.on('end', () => {
+      try {
+        const body = Buffer.concat(arr).toString();
+        resolve(JSON.parse(body));
+      } catch (e) {
+        resolve({} as T);
+      }
+    });
+  });
+};
+
+export const parseSearch = (req: IncomingMessage) => {
+  const parsedUrl = url.parse(req.url, true);
+  return parsedUrl.query;
+};

package/src/server/parse-xml.ts

@@ -0,0 +1,31 @@
+import xml2js from 'xml2js';
+
+export const parseXml = async (req: any): Promise<any> => {
+  return await new Promise((resolve) => {
+    // 读取请求数据
+    let data = '';
+    req.setEncoding('utf8');
+    // 监听data事件，接收数据片段
+    req.on('data', (chunk) => {
+      data += chunk;
+    });
+    // 当请求结束时处理数据
+    req.on('end', () => {
+      try {
+        // 使用xml2js解析XML
+        xml2js.parseString(data, function (err, result) {
+          if (err) {
+            console.error('XML解析错误:', err);
+            resolve(null);
+          } else {
+            const jsonString = JSON.stringify(result);
+            resolve(jsonString);
+          }
+        });
+      } catch (error) {
+        console.error('处理请求时出错:', error);
+        resolve(null);
+      }
+    });
+  });
+};

package/src/server/server.ts

@@ -0,0 +1,233 @@
+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';
+export type Listener = (...args: any[]) => void;
+
+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;
+  httpType?: 'http' | 'https' | 'http2';
+  httpsKey?: string;
+  httpsCert?: string;
+};
+export const resultError = (error: string, code = 500) => {
+  const r = {
+    code: code,
+    message: error,
+  };
+  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;
+  private httpType = 'http';
+  private options = {
+    key: '',
+    cert: '',
+  };
+  constructor(opts?: ServerOpts) {
+    this.path = opts?.path || '/api/router';
+    this.handle = opts?.handle;
+    this.cors = opts?.cors;
+    this.httpType = opts?.httpType || 'http';
+    this.options = {
+      key: opts?.httpsKey || '',
+      cert: opts?.httpsCert || '',
+    };
+  }
+  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[]) {
+    this._server = this.createServer();
+    const callback = this.createCallback();
+    this._server.on('request', callback);
+    this._server.listen(...args);
+  }
+  createServer() {
+    let server: http.Server | https.Server | http2.Http2SecureServer;
+    const httpType = this.httpType;
+    if (httpType === 'https') {
+      if (this.options.key && this.options.cert) {
+        server = https.createServer({
+          key: this.options.key,
+          cert: this.options.cert,
+        });
+        return server;
+      } else {
+        console.error('https key and cert is required');
+        console.log('downgrade to http');
+      }
+    } else if (httpType === 'http2') {
+      if (this.options.key && this.options.cert) {
+        server = http2.createSecureServer({
+          key: this.options.key,
+          cert: this.options.cert,
+        });
+        return server;
+      } else {
+        console.error('https key and cert is required');
+        console.log('downgrade to http');
+      }
+    }
+    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);
+    }
+    this._server.on('request', this._callback || this.createCallback());
+  }
+  get callback() {
+    return this._callback || this.createCallback();
+  }
+  get server() {
+    return this._server;
+  }
+}

package/src/server/ws-server.ts

@@ -0,0 +1,162 @@
+// @ts-type=ws
+import { WebSocketServer } from 'ws';
+import type { WebSocket } from 'ws';
+import { Server } from './server.ts';
+import { parseIfJson } from '../utils/parse.ts';
+
+
+export const createWsServer = (server: Server) => {
+  // 将 WebSocket 服务器附加到 HTTP 服务器
+  const wss = new WebSocketServer({ server: server.server as any });
+  return wss;
+};
+type WsServerBaseOpts = {
+  wss?: WebSocketServer;
+  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;
+  listener: ListenerFn;
+};
+
+export class WsServerBase {
+  wss: WebSocketServer;
+  path: string;
+  listeners: { type: string; listener: ListenerFn }[] = [];
+  listening: boolean = false;
+  constructor(opts: WsServerBaseOpts) {
+    this.wss = opts.wss;
+    if (!this.wss) {
+      throw new Error('wss is required');
+    }
+    this.path = opts.path || '';
+  }
+  setPath(path: string) {
+    this.path = path;
+  }
+  listen() {
+    if (this.listening) {
+      console.error('WsServer is listening');
+      return;
+    }
+    this.listening = true;
+
+    this.wss.on('connection', (ws) => {
+      ws.on('message', async (message: string) => {
+        const data = parseIfJson(message);
+        if (typeof data === 'string') {
+          ws.emit('string', data);
+          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 (!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');
+        }
+      });
+      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;
+    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() {
+    super.listen();
+    const server = this.server;
+    const wss = this.wss;
+    // HTTP 服务器的 upgrade 事件
+    server.server.on('upgrade', (req, socket, head) => {
+      if (req.url === this.path) {
+        wss.handleUpgrade(req, socket, head, (ws) => {
+          // 这里手动触发 connection 事件
+          // @ts-ignore
+          wss.emit('connection', ws, req);
+        });
+      } else {
+        socket.destroy();
+      }
+    });
+  }
+}

package/src/sign.ts

@@ -0,0 +1,46 @@
+import { generate } from 'selfsigned';
+
+type Attributes = {
+  name: string;
+  value: string;
+};
+type AltNames = {
+  type: number;
+  value?: string;
+  ip?: string;
+};
+export const createCert = (attrs: Attributes[] = [], altNames: AltNames[] = []) => {
+  let attributes = [
+    { name: 'commonName', value: '*' }, // 通配符域名
+    { name: 'countryName', value: 'CN' }, // 国家代码
+    { name: 'stateOrProvinceName', value: 'ZheJiang' }, // 州名
+    { name: 'localityName', value: 'Hangzhou' }, // 城市名
+    { name: 'organizationName', value: 'Envision' }, // 组织名
+    { name: 'organizationalUnitName', value: 'IT' }, // 组织单位
+    ...attrs,
+  ];
+  // attribute 根据name去重复, 后面的覆盖前面的
+  attributes = attributes.filter((item, index, self) => {
+    return self.findIndex((t) => t.name === item.name) === index;
+  });
+
+  const options = {
+    days: 365, // 证书有效期（天）
+    extensions: [
+      {
+        name: 'subjectAltName',
+        altNames: [
+          { type: 2, value: '*' }, // DNS 名称
+          { type: 2, value: 'localhost' }, // DNS
+          { type: 7, ip: '127.0.0.1' }, // IP 地址
+          ...altNames,
+        ],
+      },
+    ],
+  };
+  const pems = generate(attributes, options);
+  return {
+    key: pems.private,
+    cert: pems.cert,
+  };
+};