@kevisual/router 0.2.4 → 0.2.6

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/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;
@@ -43,17 +43,7 @@ var require_dist = __commonJS((exports) => {
   var NOOP_VALUE = (value) => value;
   var ID_START = /^[$_\p{ID_Start}]$/u;
   var ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
-  var SIMPLE_TOKENS = {
-    "{": "{",
-    "}": "}",
-    "(": "(",
-    ")": ")",
-    "[": "[",
-    "]": "]",
-    "+": "+",
-    "?": "?",
-    "!": "!"
-  };
+  var ID = /^[$_\p{ID_Start}][$\u200c\u200d\p{ID_Continue}]*$/u;
   function escapeText(str) {
     return str.replace(/[{}()\[\]+?!:*\\]/g, "\\$&");
   }
@@ -83,97 +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];
-      const type = SIMPLE_TOKENS[value];
-      if (type) {
-        tokens.push({ type, index: index++, value });
-      } else if (value === "\\") {
-        tokens.push({ type: "escape", index: index++, value: chars[index++] });
-      } else if (value === ":") {
-        tokens.push({ type: "param", index: index++, value: name() });
-      } else if (value === "*") {
-        tokens.push({ type: "wildcard", index: index++, value: name() });
-      } else {
-        tokens.push({ type: "char", index: 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(", ")}`);
       }
@@ -182,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 = {}) {
@@ -262,106 +251,134 @@ var require_dist = __commonJS((exports) => {
   function pathToRegexp(path, options = {}) {
     const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true } = options;
     const keys = [];
-    const flags = sensitive ? "" : "i";
-    const sources = [];
-    for (const input of pathsToArray(path, [])) {
-      const data = typeof input === "object" ? input : parse(input, options);
-      for (const tokens of flatten(data.tokens, 0, [])) {
-        sources.push(toRegExpSource(tokens, delimiter, keys, data.originalPath));
+    let source = "";
+    let combinations = 0;
+    function process2(path2) {
+      if (Array.isArray(path2)) {
+        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) {
+          throw new PathError("Too many path combinations", data.originalPath);
+        }
+        if (combinations > 0)
+          source += "|";
+        source += toRegExpSource(tokens, delimiter, keys, data.originalPath);
+        combinations++;
+      });
     }
-    let pattern = `^(?:${sources.join("|")})`;
+    process2(path);
+    let pattern = `^(?:${source})`;
     if (trailing)
-      pattern += `(?:${escape(delimiter)}$)?`;
-    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
-    const regexp = new RegExp(pattern, flags);
-    return { regexp, keys };
-  }
-  function pathsToArray(paths, init) {
-    if (Array.isArray(paths)) {
-      for (const p of paths)
-        pathsToArray(p, init);
-    } else {
-      init.push(paths);
-    }
-    return init;
+      pattern += "(?:" + escape(delimiter) + "$)?";
+    pattern += end ? "$" : "(?=" + escape(delimiter) + "|$)";
+    return { regexp: new RegExp(pattern, sensitive ? "" : "i"), keys };
   }
-  function* flatten(tokens, index, init) {
-    if (index === tokens.length) {
-      return yield init;
-    }
-    const token = tokens[index];
-    if (token.type === "group") {
-      for (const seq of flatten(token.tokens, 0, init.slice())) {
-        yield* flatten(tokens, index + 1, seq);
+  function flatten(tokens, index, result, callback) {
+    while (index < tokens.length) {
+      const token = tokens[index++];
+      if (token.type === "group") {
+        const len = result.length;
+        flatten(token.tokens, 0, result, (seq) => flatten(tokens, index, seq, callback));
+        result.length = len;
+        continue;
       }
-    } else {
-      init.push(token);
+      result.push(token);
     }
-    yield* flatten(tokens, index + 1, init);
+    callback(result);
   }
   function toRegExpSource(tokens, delimiter, keys, originalPath) {
     let result = "";
     let backtrack = "";
-    let isSafeSegmentParam = true;
-    for (const token of tokens) {
+    let wildcardBacktrack = "";
+    let prevCaptureType = 0;
+    let hasSegmentCapture = 0;
+    let index = 0;
+    function hasInSegment(index2, type) {
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type === type)
+          return true;
+        if (token.type === "text") {
+          if (token.value.includes(delimiter))
+            break;
+        }
+      }
+      return false;
+    }
+    function peekText(index2) {
+      let result2 = "";
+      while (index2 < tokens.length) {
+        const token = tokens[index2++];
+        if (token.type !== "text")
+          break;
+        result2 += token.value;
+      }
+      return result2;
+    }
+    while (index < tokens.length) {
+      const token = tokens[index++];
       if (token.type === "text") {
         result += escape(token.value);
         backtrack += token.value;
-        isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+        if (prevCaptureType === 2)
+          wildcardBacktrack += token.value;
+        if (token.value.includes(delimiter))
+          hasSegmentCapture = 0;
         continue;
       }
       if (token.type === "param" || token.type === "wildcard") {
-        if (!isSafeSegmentParam && !backtrack) {
+        if (prevCaptureType && !backtrack) {
           throw new PathError(`Missing text before "${token.name}" ${token.type}`, originalPath);
         }
         if (token.type === "param") {
-          result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+          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 += `([\\s\\S]+)`;
+          result += hasSegmentCapture & 2 ? `(${negate(backtrack, "")}+)` : wildcardBacktrack ? `(${negate(wildcardBacktrack, "")}+|${negate(delimiter, "")}+)` : `([^]+)`;
+          wildcardBacktrack = "";
+          hasSegmentCapture |= prevCaptureType = 2;
         }
         keys.push(token);
         backtrack = "";
-        isSafeSegmentParam = false;
         continue;
       }
+      throw new TypeError(`Unknown token type: ${token.type}`);
     }
     return result;
   }
-  function negate(delimiter, backtrack) {
-    if (backtrack.length < 2) {
-      if (delimiter.length < 2)
-        return `[^${escape(delimiter + backtrack)}]`;
-      return `(?:(?!${escape(delimiter)})[^${escape(backtrack)}])`;
-    }
-    if (delimiter.length < 2) {
-      return `(?:(?!${escape(backtrack)})[^${escape(delimiter)}])`;
-    }
-    return `(?:(?!${escape(backtrack)}|${escape(delimiter)})[\\s\\S])`;
-  }
-  function stringifyTokens(tokens) {
+  function negate(a, b) {
+    if (b.length > a.length)
+      return negate(b, a);
+    if (a === b)
+      b = "";
+    if (b.length > 1)
+      return `(?:(?!${escape(a)}|${escape(b)})[^])`;
+    if (a.length > 1)
+      return `(?:(?!${escape(a)})[^${escape(b)}])`;
+    return `[^${escape(a + b)}]`;
+  }
+  function stringifyTokens(tokens, index) {
     let value = "";
-    let i = 0;
-    function name(value2) {
-      const isSafe = isNameSafe(value2) && isNextNameSafe(tokens[i]);
-      return isSafe ? value2 : JSON.stringify(value2);
-    }
-    while (i < tokens.length) {
-      const token = tokens[i++];
+    while (index < tokens.length) {
+      const token = tokens[index++];
       if (token.type === "text") {
         value += escapeText(token.value);
         continue;
       }
       if (token.type === "group") {
-        value += `{${stringifyTokens(token.tokens)}}`;
+        value += "{" + stringifyTokens(token.tokens, 0) + "}";
         continue;
       }
       if (token.type === "param") {
-        value += `:${name(token.name)}`;
+        value += ":" + stringifyName(token.name, tokens[index]);
         continue;
       }
       if (token.type === "wildcard") {
-        value += `*${name(token.name)}`;
+        value += "*" + stringifyName(token.name, tokens[index]);
         continue;
       }
       throw new TypeError(`Unknown token type: ${token.type}`);
@@ -369,16 +386,15 @@ var require_dist = __commonJS((exports) => {
     return value;
   }
   function stringify(data) {
-    return stringifyTokens(data.tokens);
-  }
-  function isNameSafe(name) {
-    const [first, ...rest] = name;
-    return ID_START.test(first) && rest.every((char) => ID_CONTINUE.test(char));
+    return stringifyTokens(data.tokens, 0);
   }
-  function isNextNameSafe(token) {
-    if (token && token.type === "text")
-      return !ID_CONTINUE.test(token.value[0]);
-    return true;
+  function stringifyName(name, next) {
+    if (!ID.test(name))
+      return JSON.stringify(name);
+    if ((next === null || next === undefined ? undefined : next.type) === "text" && ID_CONTINUE.test(next.value[0])) {
+      return JSON.stringify(name);
+    }
+    return name;
   }
 });
 
@@ -684,7 +700,7 @@ class HttpChain {
       setInterval(() => {
         res.write(`
 `);
-      }, 3000);
+      }, 3000).unref?.();
       req.on("close", () => {
         clearInterval(intervalId);
         res.end();