@kevisual/router 0.0.10-beta.1 → 0.0.11

package/dist/router-browser.d.ts

@@ -55,14 +55,29 @@ type RouteContext<T = {
     /** return msg */
     message?: string;
     state?: S;
+    /**
+     * 当前路径
+     */
     currentPath?: string;
+    /**
+     * 当前key
+     */
     currentKey?: string;
+    /**
+     * 当前route
+     */
     currentRoute?: Route;
-    progress?: [[string, string]][];
+    /**
+     * 进度
+     */
+    progress?: [string, string][];
     nextQuery?: {
         [key: string]: any;
     };
     end?: boolean;
+    /**
+     * 请求 route的返回结果，包函ctx
+     */
     queryRouter?: QueryRouter;
     error?: any;
     /** 请求 route的返回结果，包函ctx */
@@ -391,4 +406,5 @@ declare class CustomError extends Error {
     };
 }
 
-export { CustomError, QueryRouter, QueryRouterServer, Route, type RouteContext, type RouteOpts, type Rule, type Run, createSchema };
+export { CustomError, QueryRouter, QueryRouterServer, Route, createSchema };
+export type { RouteContext, RouteOpts, Rule, Run };

package/dist/router-browser.js

@@ -5868,6 +5868,13 @@ class QueryRouter {
         ctx.currentKey = key;
         ctx.currentRoute = route;
         ctx.index = (ctx.index || 0) + 1;
+        const progress = [path, key];
+        if (ctx.progress) {
+            ctx.progress.push(progress);
+        }
+        else {
+            ctx.progress = [progress];
+        }
         if (ctx.index > maxNextRoute) {
             ctx.code = 500;
             ctx.message = 'Too many nextRoute';
@@ -6054,7 +6061,7 @@ class QueryRouter {
         const { path, key = '', payload = {}, ...query } = message;
         ctx = ctx || {};
         ctx.query = { ...ctx.query, ...query, ...payload };
-        ctx.state = {};
+        ctx.state = { ...ctx?.state };
         ctx.throw = this.throw;
         // put queryRouter to ctx
         // TODO: 是否需要queryRouter，函数内部处理router路由执行，这应该是避免去内部去包含的功能过
@@ -6062,6 +6069,7 @@ class QueryRouter {
         ctx.call = this.call.bind(this);
         ctx.queryRoute = this.queryRoute.bind(this);
         ctx.index = 0;
+        ctx.progress = ctx.progress || [];
         const res = await this.runRoute(path, key, ctx);
         const serialize = ctx.needSerialize ?? true; // 是否需要序列化
         if (serialize) {

package/dist/router-simple.d.ts

@@ -16,8 +16,11 @@ interface Route {
  */
 declare class SimpleRouter {
     routes: Route[];
-    constructor();
-    getBody(req: Req): Promise<unknown>;
+    exclude: string[];
+    constructor(opts?: {
+        exclude?: string[];
+    });
+    getBody(req: Req): Promise<Record<string, any>>;
     getSearch(req: Req): querystring.ParsedUrlQuery;
     use(method: string, route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>): this;
     get(route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>): this;
@@ -29,7 +32,7 @@ declare class SimpleRouter {
      * @param res
      * @returns
      */
-    parse(req: Req, res: ServerResponse): Promise<void> | "not_found";
+    parse(req: Req, res: ServerResponse): Promise<void> | "is_exclude" | "not_found";
 }
 
 export { SimpleRouter };

package/dist/router-simple.js

@@ -1,4 +1,4 @@
-import url from 'url';
+import url from 'node:url';
 
 var dist = {};
 
@@ -441,8 +441,9 @@ const parseSearch = (req) => {
  */
 class SimpleRouter {
     routes = [];
-    constructor() {
-        // console.log('AppSimple initialized');
+    exclude = []; // 排除的请求
+    constructor(opts) {
+        this.exclude = opts?.exclude || ['/api/router'];
     }
     getBody(req) {
         return parseBody(req);
@@ -476,6 +477,9 @@ class SimpleRouter {
     parse(req, res) {
         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) {

package/dist/router.d.ts

@@ -1,8 +1,8 @@
 import { Schema } from 'zod';
 export { Schema } from 'zod';
-import http, { IncomingMessage, ServerResponse } from 'http';
-import https from 'https';
-import http2 from 'http2';
+import http, { IncomingMessage, ServerResponse } from 'node:http';
+import https from 'node:https';
+import http2 from 'node:http2';
 import * as cookie from 'cookie';
 import { WebSocketServer, WebSocket } from 'ws';
 
@@ -60,14 +60,29 @@ type RouteContext<T = {
     /** return msg */
     message?: string;
     state?: S;
+    /**
+     * 当前路径
+     */
     currentPath?: string;
+    /**
+     * 当前key
+     */
     currentKey?: string;
+    /**
+     * 当前route
+     */
     currentRoute?: Route;
-    progress?: [[string, string]][];
+    /**
+     * 进度
+     */
+    progress?: [string, string][];
     nextQuery?: {
         [key: string]: any;
     };
     end?: boolean;
+    /**
+     * 请求 route的返回结果，包函ctx
+     */
     queryRouter?: QueryRouter;
     error?: any;
     /** 请求 route的返回结果，包函ctx */
@@ -457,7 +472,7 @@ declare class Server {
     listen(path: string, listeningListener?: () => void): void;
     listen(handle: any, backlog?: number, listeningListener?: () => void): void;
     listen(handle: any, listeningListener?: () => void): void;
-    createServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http2.Http2SecureServer<typeof http.IncomingMessage, typeof http.ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>;
+    createServer(): http.Server<typeof IncomingMessage, typeof ServerResponse> | https.Server<typeof IncomingMessage, typeof ServerResponse> | http2.Http2SecureServer<typeof IncomingMessage, typeof ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>;
     setHandle(handle?: any): void;
     /**
      * get callback
@@ -473,11 +488,15 @@ declare class Server {
      */
     on(listener: Listener | Listener[]): void;
     get callback(): any;
-    get server(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | http2.Http2SecureServer<typeof http.IncomingMessage, typeof http.ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>;
+    get server(): http.Server<typeof IncomingMessage, typeof ServerResponse> | https.Server<typeof IncomingMessage, typeof ServerResponse> | http2.Http2SecureServer<typeof IncomingMessage, typeof ServerResponse, typeof http2.Http2ServerRequest, typeof http2.Http2ServerResponse>;
 }
 
 /**
  * get params and body
+ * 优先原则
+ * 1. 请求参数中的 payload 的token 优先
+ * 2. 请求头中的 authorization 优先
+ * 3. 请求头中的 cookie 优先
  * @param req
  * @param res
  * @returns
@@ -610,4 +629,5 @@ declare class App<T = {}, U = AppReqRes> {
     throw(code?: number | string, message?: string, tips?: string): void;
 }
 
-export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, Route, type RouteContext, type RouteOpts, type Rule, type Run, Server, createSchema, handleServer };
+export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, Route, Server, createSchema, handleServer };
+export type { RouteContext, RouteOpts, Rule, Run };

package/dist/router.js

@@ -1,8 +1,8 @@
 import { webcrypto } from 'node:crypto';
-import http from 'http';
-import https from 'https';
-import http2 from 'http2';
-import url from 'url';
+import http from 'node:http';
+import https from 'node:https';
+import http2 from 'node:http2';
+import url from 'node:url';
 import { WebSocketServer } from 'ws';
 
 const urlAlphabet =
@@ -5887,6 +5887,13 @@ class QueryRouter {
         ctx.currentKey = key;
         ctx.currentRoute = route;
         ctx.index = (ctx.index || 0) + 1;
+        const progress = [path, key];
+        if (ctx.progress) {
+            ctx.progress.push(progress);
+        }
+        else {
+            ctx.progress = [progress];
+        }
         if (ctx.index > maxNextRoute) {
             ctx.code = 500;
             ctx.message = 'Too many nextRoute';
@@ -6073,7 +6080,7 @@ class QueryRouter {
         const { path, key = '', payload = {}, ...query } = message;
         ctx = ctx || {};
         ctx.query = { ...ctx.query, ...query, ...payload };
-        ctx.state = {};
+        ctx.state = { ...ctx?.state };
         ctx.throw = this.throw;
         // put queryRouter to ctx
         // TODO: 是否需要queryRouter，函数内部处理router路由执行，这应该是避免去内部去包含的功能过
@@ -6081,6 +6088,7 @@ class QueryRouter {
         ctx.call = this.call.bind(this);
         ctx.queryRoute = this.queryRoute.bind(this);
         ctx.index = 0;
+        ctx.progress = ctx.progress || [];
         const res = await this.runRoute(path, key, ctx);
         const serialize = ctx.needSerialize ?? true; // 是否需要序列化
         if (serialize) {
@@ -6328,6 +6336,10 @@ const parseBody = async (req) => {
 
 /**
  * get params and body
+ * 优先原则
+ * 1. 请求参数中的 payload 的token 优先
+ * 2. 请求头中的 authorization 优先
+ * 3. 请求头中的 cookie 优先
  * @param req
  * @param res
  * @returns
@@ -6745,8 +6757,6 @@ class Server {
                 // 交给其他监听处理
                 return;
             }
-            // res.setHeader('Content-Type', 'text/html; charset=utf-8');
-            res.setHeader('Content-Type', 'application/json; charset=utf-8');
             if (cors) {
                 res.setHeader('Access-Control-Allow-Origin', cors?.origin || '*'); // 允许所有域名的请求访问，可以根据需要设置具体的域名
                 res.setHeader('Access-Control-Allow-Headers', 'Origin, X-Requested-With, Content-Type, Accept, Authorization');
@@ -6756,7 +6766,6 @@ class Server {
                     return;
                 }
             }
-            // res.writeHead(200); // 设置响应头，给予其他任何listen 知道headersSent，它已经被响应了
             const url = req.url;
             if (!url.startsWith(path)) {
                 res.end(resultError(`not path:[${path}]`));
@@ -6770,8 +6779,10 @@ class Server {
             try {
                 const end = await handle(messages, { req, res });
                 if (res.writableEnded) {
+                    // 如果响应已经结束，则不进行任何操作
                     return;
                 }
+                res.setHeader('Content-Type', 'application/json; charset=utf-8');
                 if (typeof end === 'string') {
                     res.end(end);
                 }
@@ -6781,6 +6792,7 @@ class Server {
             }
             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));
                 }
@@ -6844,7 +6856,10 @@ class WsServerBase {
     listeners = [];
     listening = false;
     constructor(opts) {
-        this.wss = opts.wss || new WebSocketServer();
+        this.wss = opts.wss;
+        if (!this.wss) {
+            throw new Error('wss is required');
+        }
         this.path = opts.path || '';
     }
     setPath(path) {

package/package.json

@@ -1,11 +1,8 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.10-beta.1",
+  "version": "0.0.11",
   "description": "",
-  "main": "dist/index.js",
-  "module": "dist/index.js",
-  "types": "dist/index.d.ts",
   "type": "module",
   "scripts": {
     "build": "npm run clean && rollup -c",
@@ -14,7 +11,8 @@
     "clean": "rm -rf dist"
   },
   "files": [
-    "dist"
+    "dist",
+    "src"
   ],
   "keywords": [],
   "author": "abearxiong",
@@ -24,20 +22,20 @@
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.13.11",
-    "@types/ws": "^8.18.0",
+    "@types/node": "^22.14.1",
+    "@types/ws": "^8.18.1",
     "@types/xml2js": "^0.4.14",
     "cookie": "^1.0.2",
     "lodash-es": "^4.17.21",
     "nanoid": "^5.1.5",
-    "rollup": "^4.36.0",
+    "rollup": "^4.40.0",
     "rollup-plugin-dts": "^6.2.1",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
     "tslib": "^2.8.1",
-    "typescript": "^5.8.2",
+    "typescript": "^5.8.3",
     "xml2js": "^0.6.2",
-    "zod": "^3.24.2"
+    "zod": "^3.24.3"
   },
   "repository": {
     "type": "git",
@@ -71,6 +69,10 @@
     "./simple-lib": {
       "import": "./dist/router-simple-lib.js",
       "require": "./dist/router-simple-lib.js"
+    },
+    "./mod.ts": {
+      "import": "./src/mod.ts",
+      "require": "./src/mod.ts"
     }
   }
 }

package/src/app.ts

@@ -0,0 +1,103 @@
+import { QueryRouter, Route, RouteContext, RouteOpts } from './route.ts';
+import { Server, ServerOpts, HandleCtx } from './server/server.ts';
+import { WsServer } from './server/ws-server.ts';
+import { CustomError } from './result/error.ts';
+
+type RouterHandle = (msg: { path: string; [key: string]: any }) => { code: string; data?: any; message?: string; [key: string]: any };
+type AppOptions<T = {}> = {
+  router?: QueryRouter;
+  server?: Server;
+  /** handle msg 关联 */
+  routerHandle?: RouterHandle;
+  routerContext?: RouteContext<T>;
+  serverOptions?: ServerOpts;
+  io?: boolean;
+  ioOpts?: { routerHandle?: RouterHandle; routerContext?: RouteContext<T>; path?: string };
+};
+export type AppReqRes = HandleCtx;
+
+/**
+ *  封装了 Router 和 Server 的 App 模块，处理http的请求和响应，内置了 Cookie 和 Token 和 res 的处理
+ */
+export class App<T = {}, U = AppReqRes> {
+  router: QueryRouter;
+  server: Server;
+  io: WsServer;
+  constructor(opts?: AppOptions<T>) {
+    const router = opts?.router || new QueryRouter();
+    const server = opts?.server || new Server(opts?.serverOptions || {});
+    server.setHandle(router.getHandle(router, opts?.routerHandle, opts?.routerContext));
+    router.setContext({ needSerialize: true, ...opts?.routerContext });
+    this.router = router;
+    this.server = server;
+    if (opts?.io) {
+      this.io = new WsServer(server, opts?.ioOpts);
+    }
+  }
+  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[]) {
+    // @ts-ignore
+    this.server.listen(...args);
+    if (this.io) {
+      this.io.listen();
+    }
+  }
+  use(path: string, fn: (ctx: any) => any, opts?: RouteOpts) {
+    const route = new Route(path, '', opts);
+    route.run = fn;
+    this.router.add(route);
+  }
+  addRoute(route: Route) {
+    this.router.add(route);
+  }
+  add = this.addRoute;
+
+  Route = Route;
+  route(opts: RouteOpts): Route<U>;
+  route(path: string, key?: string): Route<U>;
+  route(path: string, opts?: RouteOpts): Route<U>;
+  route(path: string, key?: string, opts?: RouteOpts): Route<U>;
+  route(...args: any[]) {
+    const [path, key, opts] = args;
+    if (typeof path === 'object') {
+      return new Route(path.path, path.key, path);
+    }
+    if (typeof path === 'string') {
+      if (opts) {
+        return new Route(path, key, opts);
+      }
+      if (key && typeof key === 'object') {
+        return new Route(path, key?.key || '', key);
+      }
+      return new Route(path, key);
+    }
+    return new Route(path, key, opts);
+  }
+  async call(message: { path: string; key?: string; payload?: any }, ctx?: RouteContext & { [key: string]: any }) {
+    const router = this.router;
+    return await router.call(message, ctx);
+  }
+  async queryRoute(path: string, key?: string, payload?: any, ctx?: RouteContext & { [key: string]: any }) {
+    return await this.router.queryRoute({ path, key, payload }, ctx);
+  }
+  exportRoutes() {
+    return this.router.exportRoutes();
+  }
+  importRoutes(routes: any[]) {
+    this.router.importRoutes(routes);
+  }
+  importApp(app: App) {
+    this.importRoutes(app.exportRoutes());
+  }
+  throw(code?: number | string, message?: string, tips?: string): void;
+  throw(...args: any[]) {
+    throw new CustomError(...args);
+  }
+}

package/src/browser.ts

@@ -0,0 +1,9 @@
+export { Route, QueryRouter, QueryRouterServer } from './route.ts';
+
+export { Rule, Schema, createSchema } from './validator/index.ts';
+
+export type { RouteContext, RouteOpts } from './route.ts';
+
+export type { Run } from './route.ts';
+
+export { CustomError } from './result/error.ts';

package/src/connect.ts

@@ -0,0 +1,67 @@
+import { nanoid } from 'nanoid';
+import { RouteContext } from './route.ts';
+
+export class Connect {
+  path: string;
+  key?: string;
+  _fn?: (ctx?: RouteContext) => Promise<RouteContext>;
+  description?: string;
+  connects: { path: string; key?: string }[];
+  share = false;
+
+  constructor(path: string) {
+    this.path = path;
+    this.key = nanoid();
+  }
+  use(path: string) {
+    this.connects.push({ path });
+  }
+  useList(paths: string[]) {
+    paths.forEach((path) => {
+      this.connects.push({ path });
+    });
+  }
+  useConnect(connect: Connect) {
+    this.connects.push({ path: connect.path, key: connect.key });
+  }
+  useConnectList(connects: Connect[]) {
+    connects.forEach((connect) => {
+      this.connects.push({ path: connect.path, key: connect.key });
+    });
+  }
+  getPathList() {
+    return this.connects.map((c) => c.path).filter(Boolean);
+  }
+  set fn(fn: (ctx?: RouteContext) => Promise<RouteContext>) {
+    this._fn = fn;
+  }
+  get fn() {
+    return this._fn;
+  }
+}
+export class QueryConnect {
+  connects: Connect[];
+  constructor() {
+    this.connects = [];
+  }
+  add(connect: Connect) {
+    const has = this.connects.find((c) => c.path === connect.path && c.key === connect.key);
+    if (has) {
+      // remove the old connect
+      console.log('[replace connect]:', connect.path, connect.key);
+      this.connects = this.connects.filter((c) => c.path !== connect.path && c.key !== connect.key);
+    }
+    this.connects.push(connect);
+  }
+  remove(connect: Connect) {
+    this.connects = this.connects.filter((c) => c.path !== connect.path && c.key !== connect.key);
+  }
+  getList() {
+    return this.connects.map((c) => {
+      return {
+        path: c.path,
+        key: c.key,
+      };
+    });
+  }
+}

package/src/index.ts

@@ -0,0 +1,16 @@
+export { Route, QueryRouter, QueryRouterServer } from './route.ts';
+export { Connect, QueryConnect } from './connect.ts';
+
+export type { RouteContext, RouteOpts } from './route.ts';
+
+export type { Run } from './route.ts';
+
+export { Server, handleServer } from './server/index.ts';
+/**
+ * 自定义错误
+ */
+export { CustomError } from './result/error.ts';
+
+export { Rule, Schema, createSchema } from './validator/index.ts';
+
+export { App } from './app.ts';

package/src/io.ts

@@ -0,0 +1,6 @@
+// TODO: Implement IOApp
+export class IOApp {
+  constructor() {
+    console.log('IoApp');
+  }
+}

package/src/mod.ts

@@ -0,0 +1,13 @@
+import { Route, QueryRouter, QueryRouterServer } from './route.ts';
+
+export { App } from './app.ts';
+
+export { Route, QueryRouter, QueryRouterServer };
+
+export { Rule, Schema, createSchema } from './validator/index.ts';
+
+export type { RouteContext, RouteOpts } from './route.ts';
+
+export type { Run } from './route.ts';
+
+export { CustomError } from './result/error.ts';

package/src/result/error.ts

@@ -0,0 +1,67 @@
+/** 自定义错误 */
+export class CustomError extends Error {
+  code?: number;
+  data?: any;
+  message: string;
+  tips?: string;
+  constructor(code?: number | string, message?: string, tips?: string) {
+    super(message || String(code));
+    this.name = 'CustomError';
+    if (typeof code === 'number') {
+      this.code = code;
+      this.message = message;
+    } else {
+      this.code = 500;
+      this.message = code;
+    }
+    this.tips = tips;
+    // 这一步可不写，默认会保存堆栈追踪信息到自定义错误构造函数之前，
+    // 而如果写成 `Error.captureStackTrace(this)` 则自定义错误的构造函数也会被保存到堆栈追踪信息
+    Error.captureStackTrace(this, this.constructor);
+  }
+  static fromCode(code?: number) {
+    return new this(code);
+  }
+  static fromErrorData(code?: number, data?: any) {
+    const error = new this(code);
+    error.data = data;
+    return error;
+  }
+  static parseError(e: CustomError) {
+    return {
+      code: e?.code,
+      data: e?.data,
+      message: e?.message,
+      tips: e?.tips,
+    };
+  }
+  parse(e?: CustomError) {
+    if (e) {
+      return CustomError.parseError(e);
+    } else {
+      return {
+        code: e?.code,
+        data: e?.data,
+        message: e?.message,
+        tips: e?.tips,
+      };
+    }
+  }
+}
+
+/*
+try {
+  //
+} catch(e) {
+  if (e instanceof CustomError) {
+    const errorInfo = e.parse();
+    if (dev) {
+      return {
+        error: errorInfo,
+      };
+    } else {
+      return errorInfo;
+    }
+  }
+}
+*/

package/src/result/index.ts

@@ -0,0 +1 @@
+export * from './error.ts';