@kevisual/router 0.2.5 → 0.2.6

package/dist/router-browser.js

@@ -18980,7 +18980,7 @@ var listenProcess = async ({ app, mockProcess, params = {}, timeout: timeout2 =
     const ctx = mergeParams?.context || {};
     if (!msg.path && !msg.id) {
       const route = app.routes.find((r) => r.path !== "router");
-      msg.id = route?.id;
+      msg.id = route?.rid;
     }
     const result = await app.run(msg, ctx);
     const response = {
@@ -32971,9 +32971,9 @@ class QueryRouter {
     if (!message?.path) {
       return Promise.resolve({ code: 404, body: null, message: "Not found path" });
     }
-    const { path, key = "", payload = {}, ...query } = message;
+    const { path, key = "", payload = {}, args = {}, ...query } = message;
     ctx = ctx || {};
-    ctx.query = { ...ctx.query, ...query, ...payload };
+    ctx.query = { ...ctx.query, ...query, ...payload, ...args };
     ctx.args = ctx.query;
     ctx.state = { ...ctx?.state };
     ctx.throw = this.throw;
@@ -33183,7 +33183,8 @@ class QueryRouterServer extends QueryRouter {
     const { path, key, rid } = api2;
     return this.run({ path, key, rid, payload }, ctx);
   }
-  async createAuth(fun) {
+  async createAuth(fun, opts) {
+    const overwrite = opts?.overwrite ?? false;
     this.route({
       path: "auth",
       key: "auth",
@@ -33193,7 +33194,7 @@ class QueryRouterServer extends QueryRouter {
       if (fun) {
         await fun(ctx, "auth");
       }
-    }).addTo(this, { overwrite: false });
+    }).addTo(this, { overwrite });
     this.route({
       path: "auth-admin",
       key: "auth-admin",
@@ -33204,7 +33205,7 @@ class QueryRouterServer extends QueryRouter {
       if (fun) {
         await fun(ctx, "auth-admin");
       }
-    }).addTo(this, { overwrite: false });
+    }).addTo(this, { overwrite });
     this.route({
       path: "auth-can",
       key: "auth-can",
@@ -33214,7 +33215,7 @@ class QueryRouterServer extends QueryRouter {
       if (fun) {
         await fun(ctx, "auth-can");
       }
-    }).addTo(this, { overwrite: false });
+    }).addTo(this, { overwrite });
   }
 }
 
@@ -33409,7 +33410,6 @@ export {
   QueryUtil,
   QueryRouterServer,
   QueryRouter,
-  MockProcess,
   Mini,
   CustomError,
   App

package/dist/router-define.d.ts

@@ -168,7 +168,7 @@ declare class Route<M extends SimpleObject$1 = SimpleObject$1, U extends SimpleO
     description?: string;
     metadata?: M;
     middleware?: RouteMiddleware[];
-    type?: string | undefined;
+    type?: string;
     /**
      * 是否开启debug，开启后会打印错误信息
      */
@@ -244,6 +244,7 @@ declare class QueryRouter<T extends SimpleObject$1 = SimpleObject$1> implements
         path: string;
         key?: string;
         payload?: any;
+        args?: any;
     }, ctx?: RouteContext<T> & {
         [key: string]: any;
     }): Promise<RouteContext<T, {}, {
@@ -260,13 +261,14 @@ declare class QueryRouter<T extends SimpleObject$1 = SimpleObject$1> implements
         path?: string;
         key?: string;
         payload?: any;
+        args?: any;
     }, ctx?: RouteContext<T> & {
         [key: string]: any;
     }): Promise<RouteContext<T, {}, {
         [key: string]: any;
     }> | {
         code: number;
-        body: null;
+        body: any;
         message: string;
     }>;
     /**
@@ -281,12 +283,13 @@ declare class QueryRouter<T extends SimpleObject$1 = SimpleObject$1> implements
         path: string;
         key?: string;
         payload?: any;
+        args?: any;
     }, ctx?: RouteContext & {
         [key: string]: any;
     }): Promise<{
-        code: number | undefined;
-        data: string | number | Object | null | undefined;
-        message: string | undefined;
+        code: number;
+        data: any;
+        message: string;
     }>;
     /**
      * Router Run获取数据
@@ -299,12 +302,13 @@ declare class QueryRouter<T extends SimpleObject$1 = SimpleObject$1> implements
         path?: string;
         key?: string;
         payload?: any;
+        args?: any;
     }, ctx?: RouteContext<T> & {
         [key: string]: any;
     }): Promise<{
-        code: number | undefined;
-        data: string | number | Object | null | undefined;
-        message: string | undefined;
+        code: number;
+        data: any;
+        message: string;
     }>;
     /**
      * 设置上下文
@@ -339,12 +343,12 @@ declare class QueryRouter<T extends SimpleObject$1 = SimpleObject$1> implements
     importRoutes(routes: Route[]): void;
     importRouter(router: QueryRouter): void;
     throw(...args: any[]): void;
-    hasRoute(path: string, key?: string): Route<SimpleObject$1, SimpleObject$1> | undefined;
+    hasRoute(path: string, key?: string): Route<SimpleObject$1, SimpleObject$1>;
     findRoute(opts?: {
         path?: string;
         key?: string;
         rid?: string;
-    }): Route<SimpleObject$1, SimpleObject$1> | undefined;
+    }): Route<SimpleObject$1, SimpleObject$1>;
     createRouteList(opts?: {
         force?: boolean;
         filter?: (route: Route) => boolean;
@@ -438,6 +442,7 @@ declare class QueryRouterServer<C extends SimpleObject$1 = SimpleObject$1> exten
         path?: string;
         key?: string;
         payload?: any;
+        args?: any;
         token?: string;
         data?: any;
     }, ctx?: Partial<RouteContext<C>>): Promise<any>;
@@ -453,7 +458,9 @@ declare class QueryRouterServer<C extends SimpleObject$1 = SimpleObject$1> exten
      * 创建认证相关的中间件，默认是 auth, auth-admin, auth-can 三个中间件
      * @param fun 认证函数，接收 RouteContext 和认证类型
      */
-    createAuth(fun: (ctx: RouteContext<C>, type?: 'auth' | 'auth-admin' | 'auth-can') => any): Promise<void>;
+    createAuth(fun?: (ctx: RouteContext<C>, type?: 'auth' | 'auth-admin' | 'auth-can') => any, opts?: {
+        overwrite?: boolean;
+    }): Promise<void>;
 }
 /** JSON Schema 基本类型映射到 TypeScript 类型 */
 type JsonSchemaTypeToTS<T> = T extends {
@@ -508,8 +515,8 @@ declare class Chain {
     object: RouteOpts;
     app?: QueryRouterServer;
     constructor(object: RouteOpts, opts?: ChainOptions);
-    get key(): string | undefined;
-    get path(): string | undefined;
+    get key(): string;
+    get path(): string;
     setDescription(desc: string): this;
     setMeta(metadata: {
         [key: string]: any;

package/dist/router-simple.d.ts

@@ -1,3 +1,4 @@
+import * as node_querystring from 'node:querystring';
 import { Key } from 'path-to-regexp';
 import { IncomingMessage, ServerResponse, Server } from 'node:http';
 import { ListenOptions } from 'node:net';
@@ -24,7 +25,7 @@ declare class SimpleRouter {
         exclude?: string[];
     });
     getBody(req: Req): Promise<Record<string, any>>;
-    getSearch(req: Req): any;
+    getSearch(req: Req): node_querystring.ParsedUrlQuery;
     parseSearchValue: (value?: string, opts?: {
         decode?: boolean;
     }) => any;
@@ -102,7 +103,7 @@ declare class HttpChain {
         listenCallBack?: () => void;
     }): () => void;
     getString(value: string | SimpleObject): string;
-    sse(value: string | SimpleObject): this | undefined;
+    sse(value: string | SimpleObject): this;
     close(): this;
 }
 

package/dist/router-simple.js

@@ -30,7 +30,7 @@ var __toESM = (mod, isNodeMode, target) => {
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 
-// ../../node_modules/.pnpm/path-to-regexp@8.4.0/node_modules/path-to-regexp/dist/index.js
+// ../../node_modules/.pnpm/path-to-regexp@8.4.2/node_modules/path-to-regexp/dist/index.js
 var require_dist = __commonJS((exports) => {
   Object.defineProperty(exports, "__esModule", { value: true });
   exports.PathError = exports.TokenData = undefined;
@@ -44,7 +44,6 @@ var require_dist = __commonJS((exports) => {
   var ID_START = /^[$_\p{ID_Start}]$/u;
   var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
   var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
-  var SIMPLE_TOKENS = "{}()[]+?!";
   function escapeText(str) {
     return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
   }
@@ -74,96 +73,90 @@ var require_dist = __commonJS((exports) => {
   function parse(str, options = {}) {
     const { encodePath = NOOP_VALUE } = options;
     const chars = [...str];
-    const tokens = [];
     let index = 0;
-    let pos = 0;
-    function name() {
-      let value = "";
-      if (ID_START.test(chars[index])) {
-        do {
-          value += chars[index++];
-        } while (ID_CONTINUE.test(chars[index]));
-      } else if (chars[index] === '"') {
-        let quoteStart = index;
-        while (index < chars.length) {
-          if (chars[++index] === '"') {
-            index++;
-            quoteStart = 0;
-            break;
-          }
-          if (chars[index] === "\\")
-            index++;
-          value += chars[index];
-        }
-        if (quoteStart) {
-          throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
-        }
-      }
-      if (!value) {
-        throw new PathError(`Missing parameter name at index ${index}`, str);
-      }
-      return value;
-    }
-    while (index < chars.length) {
-      const value = chars[index++];
-      if (SIMPLE_TOKENS.includes(value)) {
-        tokens.push({ type: value, index, value });
-      } else if (value === "\\") {
-        tokens.push({ type: "escape", index, value: chars[index++] });
-      } else if (value === ":") {
-        tokens.push({ type: "param", index, value: name() });
-      } else if (value === "*") {
-        tokens.push({ type: "wildcard", index, value: name() });
-      } else {
-        tokens.push({ type: "char", index, value });
-      }
-    }
-    tokens.push({ type: "end", index, value: "" });
-    function consumeUntil(endType) {
+    function consumeUntil(end) {
       const output = [];
-      while (true) {
-        const token = tokens[pos++];
-        if (token.type === endType)
-          break;
-        if (token.type === "char" || token.type === "escape") {
-          let path = token.value;
-          let cur = tokens[pos];
-          while (cur.type === "char" || cur.type === "escape") {
-            path += cur.value;
-            cur = tokens[++pos];
+      let path = "";
+      function writePath() {
+        if (!path)
+          return;
+        output.push({
+          type: "text",
+          value: encodePath(path)
+        });
+        path = "";
+      }
+      while (index < chars.length) {
+        const value = chars[index++];
+        if (value === end) {
+          writePath();
+          return output;
+        }
+        if (value === "\\") {
+          if (index === chars.length) {
+            throw new PathError(`Unexpected end after \\ at index ${index}`, str);
           }
-          output.push({
-            type: "text",
-            value: encodePath(path)
-          });
+          path += chars[index++];
           continue;
         }
-        if (token.type === "param" || token.type === "wildcard") {
-          output.push({
-            type: token.type,
-            name: token.value
-          });
+        if (value === ":" || value === "*") {
+          const type = value === ":" ? "param" : "wildcard";
+          let name = "";
+          if (ID_START.test(chars[index])) {
+            do {
+              name += chars[index++];
+            } while (ID_CONTINUE.test(chars[index]));
+          } else if (chars[index] === '"') {
+            let quoteStart = index;
+            while (index < chars.length) {
+              if (chars[++index] === '"') {
+                index++;
+                quoteStart = 0;
+                break;
+              }
+              if (chars[index] === "\\")
+                index++;
+              name += chars[index];
+            }
+            if (quoteStart) {
+              throw new PathError(`Unterminated quote at index ${quoteStart}`, str);
+            }
+          }
+          if (!name) {
+            throw new PathError(`Missing parameter name at index ${index}`, str);
+          }
+          writePath();
+          output.push({ type, name });
           continue;
         }
-        if (token.type === "{") {
+        if (value === "{") {
+          writePath();
           output.push({
             type: "group",
             tokens: consumeUntil("}")
           });
           continue;
         }
-        throw new PathError(`Unexpected ${token.type} at index ${token.index}, expected ${endType}`, str);
+        if (value === "}" || value === "(" || value === ")" || value === "[" || value === "]" || value === "+" || value === "?" || value === "!") {
+          throw new PathError(`Unexpected ${value} at index ${index - 1}`, str);
+        }
+        path += value;
       }
+      if (end) {
+        throw new PathError(`Unexpected end at index ${index}, expected ${end}`, str);
+      }
+      writePath();
       return output;
     }
-    return new TokenData(consumeUntil("end"), str);
+    return new TokenData(consumeUntil(""), str);
   }
   function compile(path, options = {}) {
     const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
     const data = typeof path === "object" ? path : parse(path, options);
     const fn = tokensToFunction(data.tokens, delimiter, encode);
     return function path2(params = {}) {
-      const [path3, ...missing] = fn(params);
+      const missing = [];
+      const path3 = fn(params, missing);
       if (missing.length) {
         throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
       }
@@ -172,55 +165,61 @@ var require_dist = __commonJS((exports) => {
   }
   function tokensToFunction(tokens, delimiter, encode) {
     const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
-    return (data) => {
-      const result = [""];
+    return (data, missing) => {
+      let result = "";
       for (const encoder of encoders) {
-        const [value, ...extras] = encoder(data);
-        result[0] += value;
-        result.push(...extras);
+        result += encoder(data, missing);
       }
       return result;
     };
   }
   function tokenToFunction(token, delimiter, encode) {
     if (token.type === "text")
-      return () => [token.value];
+      return () => token.value;
     if (token.type === "group") {
       const fn = tokensToFunction(token.tokens, delimiter, encode);
-      return (data) => {
-        const [value, ...missing] = fn(data);
-        if (!missing.length)
-          return [value];
-        return [""];
+      return (data, missing) => {
+        const len = missing.length;
+        const value = fn(data, missing);
+        if (missing.length === len)
+          return value;
+        missing.length = len;
+        return "";
       };
     }
     const encodeValue = encode || NOOP_VALUE;
     if (token.type === "wildcard" && encode !== false) {
-      return (data) => {
+      return (data, missing) => {
         const value = data[token.name];
-        if (value == null)
-          return ["", token.name];
+        if (value == null) {
+          missing.push(token.name);
+          return "";
+        }
         if (!Array.isArray(value) || value.length === 0) {
           throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
         }
-        return [
-          value.map((value2, index) => {
-            if (typeof value2 !== "string") {
-              throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
-            }
-            return encodeValue(value2);
-          }).join(delimiter)
-        ];
+        let result = "";
+        for (let i = 0;i < value.length; i++) {
+          if (typeof value[i] !== "string") {
+            throw new TypeError(`Expected "${token.name}/${i}" to be a string`);
+          }
+          if (i > 0)
+            result += delimiter;
+          result += encodeValue(value[i]);
+        }
+        return result;
       };
     }
-    return (data) => {
+    return (data, missing) => {
       const value = data[token.name];
-      if (value == null)
-        return ["", token.name];
+      if (value == null) {
+        missing.push(token.name);
+        return "";
+      }
       if (typeof value !== "string") {
         throw new TypeError(`Expected "${token.name}" to be a string`);
       }
-      return [encodeValue(value)];
+      return encodeValue(value);
     };
   }
   function match(path, options = {}) {
@@ -251,67 +250,48 @@ var require_dist = __commonJS((exports) => {
   }
   function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
-    const root = new SourceNode("^");
-    const paths = [path];
+    const keys = [];
+    let source = "";
     let combinations = 0;
-    while (paths.length) {
-      const path2 = paths.shift();
+    function process2(path2) {
       if (Array.isArray(path2)) {
-        paths.push(...path2);
-        continue;
+        for (const p of path2)
+          process2(p);
+        return;
       }
       const data = typeof path2 === "object" ? path2 : parse(path2, options);
       flatten(data.tokens, 0, [], (tokens) => {
-        if (combinations++ >= 256) {
+        if (combinations >= 256) {
           throw new PathError("Too many path combinations", data.originalPath);
         }
-        let node = root;
-        for (const part of toRegExpSource(tokens, delimiter, data.originalPath)) {
-          node = node.add(part.source, part.key);
-        }
-        node.add("");
+        if (combinations > 0)
+          source += "|";
+        source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+        combinations++;
       });
     }
-    const keys = [];
-    let pattern = toRegExp(root, keys);
+    process2(path);
+    let pattern = `^(?:${source})`;
     if (trailing)
       pattern += "(?:" + escape(delimiter) + "$)?";
     pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
     return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
   }
-  function toRegExp(node, keys) {
-    if (node.key)
-      keys.push(node.key);
-    const children = Object.keys(node.children);
-    const text = children.map((id) => toRegExp(node.children[id], keys)).join("|");
-    return node.source + (children.length < 2 ? text : `(?:${text})`);
-  }
-
-  class SourceNode {
-    constructor(source, key) {
-      this.source = source;
-      this.key = key;
-      this.children = Object.create(null);
-    }
-    add(source, key) {
-      var _a;
-      const id = source + ":" + (key ? key.name : "");
-      return (_a = this.children)[id] || (_a[id] = new SourceNode(source, key));
-    }
-  }
   function flatten(tokens, index, result, callback) {
     while (index < tokens.length) {
       const token = tokens[index++];
       if (token.type === "group") {
-        flatten(token.tokens, 0, result.slice(), (seq) => flatten(tokens, index, seq, callback));
+        const len = result.length;
+        flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+        result.length = len;
         continue;
       }
       result.push(token);
     }
     callback(result);
   }
-  function toRegExpSource(tokens, delimiter, originalPath) {
-    let result = [];
+  function toRegExpSource(tokens, delimiter, keys, originalPath) {
+    let result = "";
     let backtrack = "";
     let wildcardBacktrack = "";
     let prevCaptureType = 0;
@@ -342,7 +322,7 @@ var require_dist = __commonJS((exports) => {
     while (index < tokens.length) {
       const token = tokens[index++];
       if (token.type === "text") {
-        result.push({ source: escape(token.value) });
+        result += escape(token.value);
         backtrack += token.value;
         if (prevCaptureType === 2)
           wildcardBacktrack += token.value;
@@ -355,19 +335,14 @@ var require_dist = __commonJS((exports) => {
           throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
         }
         if (token.type === "param") {
-          result.push({
-            source: hasSegmentCapture ? `(${negate(delimiter, backtrack)}+?)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+?)` : `(${negate(delimiter, "")}+?)`,
-            key: token
-          });
+          result += hasSegmentCapture & 2 ? `(${negate(delimiter, backtrack)}+)` : hasInSegment(index, "wildcard") ? `(${negate(delimiter, peekText(index))}+)` : hasSegmentCapture & 1 ? `(${negate(delimiter, backtrack)}+|${escape(backtrack)})` : `(${negate(delimiter, "")}+)`;
           hasSegmentCapture |= prevCaptureType = 1;
         } else {
-          result.push({
-            source: hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+?)` : hasSegmentCapture & 1 ? `(${negate(wildcardBacktrack, "")}+?)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+?|${negate(delimiter, "")}+?)` : `([^]+?)`,
-            key: token
-          });
+          result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
           wildcardBacktrack = "";
           hasSegmentCapture |= prevCaptureType = 2;
         }
+        keys.push(token);
         backtrack = "";
         continue;
       }
@@ -725,7 +700,7 @@ class HttpChain {
       setInterval(() => {
         res.write(`
 `);
-      }, 3000);
+      }, 3000).unref?.();
       req.on("close", () => {
         clearInterval(intervalId);
         res.end();