@kevisual/router 0.0.18 → 0.0.19

package/dist/router-browser.d.ts

@@ -3,6 +3,7 @@ export { Schema } from 'zod';
 import * as querystring from 'querystring';
 import { IncomingMessage } from 'node:http';
 import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
+import { Query, DataOpts, Result } from '@kevisual/query/query';
 
 type BaseRule = {
     value?: any;
@@ -467,18 +468,42 @@ declare class Chain {
     define<U extends SimpleObject = {}>(run: Run$1<U>): this;
     createRoute(): this;
 }
+type QueryChainOptions = {
+    query?: Query;
+    omitKeys?: string[];
+};
+declare class QueryChain {
+    obj: SimpleObject;
+    query: Query;
+    omitKeys: string[];
+    constructor(value?: SimpleObject, opts?: QueryChainOptions);
+    omit(obj: SimpleObject, key?: string[]): {
+        [x: string]: any;
+    };
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData?: SimpleObject): Pick<RouteOpts$1, 'path' | 'key' | 'metadata' | 'description' | 'validator'>;
+    post<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+    get<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+}
 declare const util: {
     getChain: (obj: RouteOpts$1, opts?: ChainOptions) => Chain;
 };
 declare class QueryUtil<T extends RouteObject = RouteObject> {
-    routeObject: T;
+    obj: T;
     app: QueryRouterServer$1;
     constructor(object: T, opts?: ChainOptions);
     static createFormObj<U extends RouteObject>(object: U, opts?: ChainOptions): QueryUtil<U>;
     static create<U extends Record<string, RouteOpts$1>>(value: U, opts?: ChainOptions): QueryUtil<U>;
     get<K extends keyof T>(key: K): RouteOpts$1;
     chain<K extends keyof T>(key: K, opts?: ChainOptions): Chain;
-    queryChain<K extends keyof T>(key: K): (queryData?: Record<string, any>) => RouteOpts$1;
+    queryChain<K extends keyof T>(key: K, opts?: QueryChainOptions): QueryChain;
+    static Chain: typeof Chain;
+    static QueryChain: typeof QueryChain;
+    get routeObject(): T;
 }
 
 export { CustomError, QueryRouter, QueryRouterServer, QueryUtil, Route, createSchema, define, parseBody, parseSearch, parseSearchValue, util };

package/dist/router-browser.js

@@ -1054,15 +1054,15 @@ const base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z
 const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
 const dateRegex = new RegExp(`^${dateRegexSource}$`);
 function timeRegexSource(args) {
-    // let regex = `\\d{2}:\\d{2}:\\d{2}`;
-    let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
+    let secondsRegexSource = `[0-5]\\d`;
     if (args.precision) {
-        regex = `${regex}\\.\\d{${args.precision}}`;
+        secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
     }
     else if (args.precision == null) {
-        regex = `${regex}(\\.\\d+)?`;
+        secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
     }
-    return regex;
+    const secondsQuantifier = args.precision ? "+" : "?"; // require seconds if precision is nonzero
+    return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
 }
 function timeRegex(args) {
     return new RegExp(`^${timeRegexSource(args)}$`);
@@ -6268,7 +6268,36 @@ const parseBody = async (req) => {
         req.on('end', () => {
             try {
                 const body = Buffer.concat(arr).toString();
-                resolve(JSON.parse(body));
+                // 获取 Content-Type 头信息
+                const contentType = req.headers['content-type'] || '';
+                // 处理 application/json
+                if (contentType.includes('application/json')) {
+                    resolve(JSON.parse(body));
+                    return;
+                }
+                // 处理 application/x-www-form-urlencoded
+                if (contentType.includes('application/x-www-form-urlencoded')) {
+                    const formData = new URLSearchParams(body);
+                    const result = {};
+                    formData.forEach((value, key) => {
+                        // 尝试将值解析为 JSON，如果失败则保留原始字符串
+                        try {
+                            result[key] = JSON.parse(value);
+                        }
+                        catch {
+                            result[key] = value;
+                        }
+                    });
+                    resolve(result);
+                    return;
+                }
+                // 默认尝试 JSON 解析
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve({});
+                }
             }
             catch (e) {
                 resolve({});
@@ -6352,16 +6381,54 @@ class Chain {
         return this;
     }
 }
+class QueryChain {
+    obj = {};
+    query;
+    omitKeys = ['metadata', 'description', 'validator'];
+    constructor(value, opts) {
+        this.obj = value || {};
+        this.query = opts?.query;
+        if (opts?.omitKeys)
+            this.omitKeys = opts.omitKeys;
+    }
+    omit(obj, key = []) {
+        const newObj = { ...obj };
+        key.forEach((k) => {
+            delete newObj[k];
+        });
+        return newObj;
+    }
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData) {
+        const obj = this.omit(this.obj, this.omitKeys);
+        return {
+            ...obj,
+            ...queryData,
+        };
+    }
+    post(data, options) {
+        const _queryData = this.getKey(data);
+        return this.query.post(_queryData, options);
+    }
+    get(data, options) {
+        const _queryData = this.getKey(data);
+        return this.query.get(_queryData, options);
+    }
+}
 const util = {
     getChain: (obj, opts) => {
         return new Chain(obj, opts);
     },
 };
 class QueryUtil {
-    routeObject;
+    obj;
     app;
     constructor(object, opts) {
-        this.routeObject = object;
+        this.obj = object;
         this.app = opts?.app;
     }
     static createFormObj(object, opts) {
@@ -6372,21 +6439,21 @@ class QueryUtil {
         return new QueryUtil(obj, opts);
     }
     get(key) {
-        return this.routeObject[key];
+        return this.obj[key];
     }
     chain(key, opts) {
-        const obj = this.routeObject[key];
+        const obj = this.obj[key];
         let newOpts = { app: this.app, ...opts };
-        return new Chain(obj, newOpts);
+        return new QueryUtil.Chain(obj, newOpts);
     }
-    queryChain(key) {
-        const value = this.routeObject[key];
-        return (queryData) => {
-            return {
-                ...value,
-                ...queryData,
-            };
-        };
+    queryChain(key, opts) {
+        const value = this.obj[key];
+        return new QueryUtil.QueryChain(value, opts);
+    }
+    static Chain = Chain;
+    static QueryChain = QueryChain;
+    get routeObject() {
+        return this.obj;
     }
 }
 

package/dist/router-define.d.ts

@@ -1,5 +1,6 @@
 import { RouteOpts, QueryRouterServer, RouteMiddleware, Run } from '@kevisual/router';
 export { RouteOpts } from '@kevisual/router';
+import { Query, DataOpts, Result } from '@kevisual/query/query';
 
 type RouteObject = {
     [key: string]: RouteOpts;
@@ -30,18 +31,42 @@ declare class Chain {
     define<U extends SimpleObject = {}>(run: Run<U>): this;
     createRoute(): this;
 }
+type QueryChainOptions = {
+    query?: Query;
+    omitKeys?: string[];
+};
+declare class QueryChain {
+    obj: SimpleObject;
+    query: Query;
+    omitKeys: string[];
+    constructor(value?: SimpleObject, opts?: QueryChainOptions);
+    omit(obj: SimpleObject, key?: string[]): {
+        [x: string]: any;
+    };
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData?: SimpleObject): Pick<RouteOpts, 'path' | 'key' | 'metadata' | 'description' | 'validator'>;
+    post<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+    get<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+}
 declare const util: {
     getChain: (obj: RouteOpts, opts?: ChainOptions) => Chain;
 };
 declare class QueryUtil<T extends RouteObject = RouteObject> {
-    routeObject: T;
+    obj: T;
     app: QueryRouterServer;
     constructor(object: T, opts?: ChainOptions);
     static createFormObj<U extends RouteObject>(object: U, opts?: ChainOptions): QueryUtil<U>;
     static create<U extends Record<string, RouteOpts>>(value: U, opts?: ChainOptions): QueryUtil<U>;
     get<K extends keyof T>(key: K): RouteOpts;
     chain<K extends keyof T>(key: K, opts?: ChainOptions): Chain;
-    queryChain<K extends keyof T>(key: K): (queryData?: Record<string, any>) => RouteOpts;
+    queryChain<K extends keyof T>(key: K, opts?: QueryChainOptions): QueryChain;
+    static Chain: typeof Chain;
+    static QueryChain: typeof QueryChain;
+    get routeObject(): T;
 }
 
 export { QueryUtil, define, util };

package/dist/router-define.js

@@ -51,16 +51,54 @@ class Chain {
         return this;
     }
 }
+class QueryChain {
+    obj = {};
+    query;
+    omitKeys = ['metadata', 'description', 'validator'];
+    constructor(value, opts) {
+        this.obj = value || {};
+        this.query = opts?.query;
+        if (opts?.omitKeys)
+            this.omitKeys = opts.omitKeys;
+    }
+    omit(obj, key = []) {
+        const newObj = { ...obj };
+        key.forEach((k) => {
+            delete newObj[k];
+        });
+        return newObj;
+    }
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData) {
+        const obj = this.omit(this.obj, this.omitKeys);
+        return {
+            ...obj,
+            ...queryData,
+        };
+    }
+    post(data, options) {
+        const _queryData = this.getKey(data);
+        return this.query.post(_queryData, options);
+    }
+    get(data, options) {
+        const _queryData = this.getKey(data);
+        return this.query.get(_queryData, options);
+    }
+}
 const util = {
     getChain: (obj, opts) => {
         return new Chain(obj, opts);
     },
 };
 class QueryUtil {
-    routeObject;
+    obj;
     app;
     constructor(object, opts) {
-        this.routeObject = object;
+        this.obj = object;
         this.app = opts?.app;
     }
     static createFormObj(object, opts) {
@@ -71,21 +109,21 @@ class QueryUtil {
         return new QueryUtil(obj, opts);
     }
     get(key) {
-        return this.routeObject[key];
+        return this.obj[key];
     }
     chain(key, opts) {
-        const obj = this.routeObject[key];
+        const obj = this.obj[key];
         let newOpts = { app: this.app, ...opts };
-        return new Chain(obj, newOpts);
-    }
-    queryChain(key) {
-        const value = this.routeObject[key];
-        return (queryData) => {
-            return {
-                ...value,
-                ...queryData,
-            };
-        };
+        return new QueryUtil.Chain(obj, newOpts);
+    }
+    queryChain(key, opts) {
+        const value = this.obj[key];
+        return new QueryUtil.QueryChain(value, opts);
+    }
+    static Chain = Chain;
+    static QueryChain = QueryChain;
+    get routeObject() {
+        return this.obj;
     }
 }
 

package/dist/router-simple.d.ts

@@ -22,6 +22,9 @@ declare class SimpleRouter {
     });
     getBody(req: Req): Promise<Record<string, any>>;
     getSearch(req: Req): querystring.ParsedUrlQuery;
+    parseSearchValue: (value?: string, opts?: {
+        decode?: boolean;
+    }) => any;
     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;
     post(route: string, ...fns: Array<(req: Req, res: ServerResponse) => Promise<void> | void>): this;

package/dist/router-simple.js

@@ -423,7 +423,36 @@ const parseBody = async (req) => {
         req.on('end', () => {
             try {
                 const body = Buffer.concat(arr).toString();
-                resolve(JSON.parse(body));
+                // 获取 Content-Type 头信息
+                const contentType = req.headers['content-type'] || '';
+                // 处理 application/json
+                if (contentType.includes('application/json')) {
+                    resolve(JSON.parse(body));
+                    return;
+                }
+                // 处理 application/x-www-form-urlencoded
+                if (contentType.includes('application/x-www-form-urlencoded')) {
+                    const formData = new URLSearchParams(body);
+                    const result = {};
+                    formData.forEach((value, key) => {
+                        // 尝试将值解析为 JSON，如果失败则保留原始字符串
+                        try {
+                            result[key] = JSON.parse(value);
+                        }
+                        catch {
+                            result[key] = value;
+                        }
+                    });
+                    resolve(result);
+                    return;
+                }
+                // 默认尝试 JSON 解析
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve({});
+                }
             }
             catch (e) {
                 resolve({});
@@ -435,6 +464,24 @@ const parseSearch = (req) => {
     const parsedUrl = url.parse(req.url, true);
     return parsedUrl.query;
 };
+/**
+ * 把url当个key 的 value 的字符串转成json
+ * @param value
+ */
+const parseSearchValue = (value, opts) => {
+    if (!value)
+        return {};
+    const decode = opts?.decode ?? false;
+    if (decode) {
+        value = decodeURIComponent(value);
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch (e) {
+        return {};
+    }
+};
 
 /**
  * SimpleRouter
@@ -451,6 +498,7 @@ class SimpleRouter {
     getSearch(req) {
         return parseSearch(req);
     }
+    parseSearchValue = parseSearchValue;
     use(method, route, ...fns) {
         const handlers = Array.isArray(fns) ? fns.flat() : [];
         const pattern = distExports.pathToRegexp(route);

package/dist/router.d.ts

@@ -6,6 +6,7 @@ import http2 from 'node:http2';
 import * as cookie from 'cookie';
 import { WebSocketServer, WebSocket } from 'ws';
 import { RouteOpts as RouteOpts$1, QueryRouterServer as QueryRouterServer$1, RouteMiddleware as RouteMiddleware$1, Run as Run$1 } from '@kevisual/router';
+import { Query, DataOpts, Result } from '@kevisual/query/query';
 
 type BaseRule = {
     value?: any;
@@ -608,18 +609,42 @@ declare class Chain {
     define<U extends SimpleObject = {}>(run: Run$1<U>): this;
     createRoute(): this;
 }
+type QueryChainOptions = {
+    query?: Query;
+    omitKeys?: string[];
+};
+declare class QueryChain {
+    obj: SimpleObject;
+    query: Query;
+    omitKeys: string[];
+    constructor(value?: SimpleObject, opts?: QueryChainOptions);
+    omit(obj: SimpleObject, key?: string[]): {
+        [x: string]: any;
+    };
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData?: SimpleObject): Pick<RouteOpts$1, 'path' | 'key' | 'metadata' | 'description' | 'validator'>;
+    post<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+    get<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>>;
+}
 declare const util: {
     getChain: (obj: RouteOpts$1, opts?: ChainOptions) => Chain;
 };
 declare class QueryUtil<T extends RouteObject = RouteObject> {
-    routeObject: T;
+    obj: T;
     app: QueryRouterServer$1;
     constructor(object: T, opts?: ChainOptions);
     static createFormObj<U extends RouteObject>(object: U, opts?: ChainOptions): QueryUtil<U>;
     static create<U extends Record<string, RouteOpts$1>>(value: U, opts?: ChainOptions): QueryUtil<U>;
     get<K extends keyof T>(key: K): RouteOpts$1;
     chain<K extends keyof T>(key: K, opts?: ChainOptions): Chain;
-    queryChain<K extends keyof T>(key: K): (queryData?: Record<string, any>) => RouteOpts$1;
+    queryChain<K extends keyof T>(key: K, opts?: QueryChainOptions): QueryChain;
+    static Chain: typeof Chain;
+    static QueryChain: typeof QueryChain;
+    get routeObject(): T;
 }
 
 type RouterHandle = (msg: {

package/dist/router.js

@@ -1076,15 +1076,15 @@ const base64urlRegex = /^([0-9a-zA-Z-_]{4})*(([0-9a-zA-Z-_]{2}(==)?)|([0-9a-zA-Z
 const dateRegexSource = `((\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-((0[13578]|1[02])-(0[1-9]|[12]\\d|3[01])|(0[469]|11)-(0[1-9]|[12]\\d|30)|(02)-(0[1-9]|1\\d|2[0-8])))`;
 const dateRegex = new RegExp(`^${dateRegexSource}$`);
 function timeRegexSource(args) {
-    // let regex = `\\d{2}:\\d{2}:\\d{2}`;
-    let regex = `([01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d`;
+    let secondsRegexSource = `[0-5]\\d`;
     if (args.precision) {
-        regex = `${regex}\\.\\d{${args.precision}}`;
+        secondsRegexSource = `${secondsRegexSource}\\.\\d{${args.precision}}`;
     }
     else if (args.precision == null) {
-        regex = `${regex}(\\.\\d+)?`;
+        secondsRegexSource = `${secondsRegexSource}(\\.\\d+)?`;
     }
-    return regex;
+    const secondsQuantifier = args.precision ? "+" : "?"; // require seconds if precision is nonzero
+    return `([01]\\d|2[0-3]):[0-5]\\d(:${secondsRegexSource})${secondsQuantifier}`;
 }
 function timeRegex(args) {
     return new RegExp(`^${timeRegexSource(args)}$`);
@@ -6354,7 +6354,36 @@ const parseBody = async (req) => {
         req.on('end', () => {
             try {
                 const body = Buffer.concat(arr).toString();
-                resolve(JSON.parse(body));
+                // 获取 Content-Type 头信息
+                const contentType = req.headers['content-type'] || '';
+                // 处理 application/json
+                if (contentType.includes('application/json')) {
+                    resolve(JSON.parse(body));
+                    return;
+                }
+                // 处理 application/x-www-form-urlencoded
+                if (contentType.includes('application/x-www-form-urlencoded')) {
+                    const formData = new URLSearchParams(body);
+                    const result = {};
+                    formData.forEach((value, key) => {
+                        // 尝试将值解析为 JSON，如果失败则保留原始字符串
+                        try {
+                            result[key] = JSON.parse(value);
+                        }
+                        catch {
+                            result[key] = value;
+                        }
+                    });
+                    resolve(result);
+                    return;
+                }
+                // 默认尝试 JSON 解析
+                try {
+                    resolve(JSON.parse(body));
+                }
+                catch {
+                    resolve({});
+                }
             }
             catch (e) {
                 resolve({});
@@ -11991,16 +12020,54 @@ class Chain {
         return this;
     }
 }
+class QueryChain {
+    obj = {};
+    query;
+    omitKeys = ['metadata', 'description', 'validator'];
+    constructor(value, opts) {
+        this.obj = value || {};
+        this.query = opts?.query;
+        if (opts?.omitKeys)
+            this.omitKeys = opts.omitKeys;
+    }
+    omit(obj, key = []) {
+        const newObj = { ...obj };
+        key.forEach((k) => {
+            delete newObj[k];
+        });
+        return newObj;
+    }
+    /**
+     * 生成
+     * @param queryData
+     * @returns
+     */
+    getKey(queryData) {
+        const obj = this.omit(this.obj, this.omitKeys);
+        return {
+            ...obj,
+            ...queryData,
+        };
+    }
+    post(data, options) {
+        const _queryData = this.getKey(data);
+        return this.query.post(_queryData, options);
+    }
+    get(data, options) {
+        const _queryData = this.getKey(data);
+        return this.query.get(_queryData, options);
+    }
+}
 const util = {
     getChain: (obj, opts) => {
         return new Chain(obj, opts);
     },
 };
 class QueryUtil {
-    routeObject;
+    obj;
     app;
     constructor(object, opts) {
-        this.routeObject = object;
+        this.obj = object;
         this.app = opts?.app;
     }
     static createFormObj(object, opts) {
@@ -12011,21 +12078,21 @@ class QueryUtil {
         return new QueryUtil(obj, opts);
     }
     get(key) {
-        return this.routeObject[key];
+        return this.obj[key];
     }
     chain(key, opts) {
-        const obj = this.routeObject[key];
+        const obj = this.obj[key];
         let newOpts = { app: this.app, ...opts };
-        return new Chain(obj, newOpts);
+        return new QueryUtil.Chain(obj, newOpts);
     }
-    queryChain(key) {
-        const value = this.routeObject[key];
-        return (queryData) => {
-            return {
-                ...value,
-                ...queryData,
-            };
-        };
+    queryChain(key, opts) {
+        const value = this.obj[key];
+        return new QueryUtil.QueryChain(value, opts);
+    }
+    static Chain = Chain;
+    static QueryChain = QueryChain;
+    get routeObject() {
+        return this.obj;
     }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.18",
+  "version": "0.0.19",
   "description": "",
   "type": "module",
   "main": "./dist/router.js",
@@ -21,18 +21,19 @@
   "author": "abearxiong",
   "license": "MIT",
   "devDependencies": {
+    "@kevisual/query": "^0.0.18",
     "@rollup/plugin-alias": "^5.1.1",
     "@rollup/plugin-commonjs": "^28.0.3",
     "@rollup/plugin-node-resolve": "^16.0.1",
     "@rollup/plugin-typescript": "^12.1.2",
     "@types/lodash-es": "^4.17.12",
-    "@types/node": "^22.14.1",
+    "@types/node": "^22.15.18",
     "@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.40.0",
+    "rollup": "^4.40.2",
     "rollup-plugin-dts": "^6.2.1",
     "ts-loader": "^9.5.2",
     "ts-node": "^10.9.2",
@@ -40,7 +41,7 @@
     "typescript": "^5.8.3",
     "ws": "npm:@kevisual/ws",
     "xml2js": "^0.6.2",
-    "zod": "^3.24.3"
+    "zod": "^3.24.4"
   },
   "repository": {
     "type": "git",

package/src/router-define.ts

@@ -1,5 +1,5 @@
 import type { QueryRouterServer, RouteOpts, Run, RouteMiddleware } from '@kevisual/router';
-
+import type { DataOpts, Query, Result } from '@kevisual/query/query';
 // export type RouteObject<T extends readonly string[]> = {
 //   [K in T[number]]: RouteOpts;
 // };
@@ -70,6 +70,47 @@ class Chain {
     return this;
   }
 }
+type QueryChainOptions = {
+  query?: Query;
+  omitKeys?: string[];
+};
+class QueryChain {
+  obj: SimpleObject = {};
+  query: Query;
+  omitKeys: string[] = ['metadata', 'description', 'validator'];
+  constructor(value?: SimpleObject, opts?: QueryChainOptions) {
+    this.obj = value || {};
+    this.query = opts?.query;
+    if (opts?.omitKeys) this.omitKeys = opts.omitKeys;
+  }
+  omit(obj: SimpleObject, key: string[] = []) {
+    const newObj = { ...obj };
+    key.forEach((k) => {
+      delete newObj[k];
+    });
+    return newObj;
+  }
+  /**
+   * 生成
+   * @param queryData
+   * @returns
+   */
+  getKey(queryData?: SimpleObject): Pick<RouteOpts, 'path' | 'key' | 'metadata' | 'description' | 'validator'> {
+    const obj = this.omit(this.obj, this.omitKeys);
+    return {
+      ...obj,
+      ...queryData,
+    };
+  }
+  post<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>> {
+    const _queryData = this.getKey(data);
+    return this.query.post(_queryData, options);
+  }
+  get<R = SimpleObject, P = SimpleObject>(data: P, options?: DataOpts): Promise<Result<R>> {
+    const _queryData = this.getKey(data);
+    return this.query.get(_queryData, options);
+  }
+}
 export const util = {
   getChain: (obj: RouteOpts, opts?: ChainOptions) => {
     return new Chain(obj, opts);
@@ -77,10 +118,10 @@ export const util = {
 };
 
 export class QueryUtil<T extends RouteObject = RouteObject> {
-  routeObject: T;
+  obj: T;
   app: QueryRouterServer;
   constructor(object: T, opts?: ChainOptions) {
-    this.routeObject = object;
+    this.obj = object;
     this.app = opts?.app;
   }
   static createFormObj<U extends RouteObject>(object: U, opts?: ChainOptions) {
@@ -91,20 +132,20 @@ export class QueryUtil<T extends RouteObject = RouteObject> {
     return new QueryUtil<U>(obj, opts);
   }
   get<K extends keyof T>(key: K): RouteOpts {
-    return this.routeObject[key] as RouteOpts;
+    return this.obj[key] as RouteOpts;
   }
   chain<K extends keyof T>(key: K, opts?: ChainOptions) {
-    const obj = this.routeObject[key];
+    const obj = this.obj[key];
     let newOpts = { app: this.app, ...opts };
-    return new Chain(obj, newOpts);
-  }
-  queryChain<K extends keyof T>(key: K): (queryData?: Record<string, any>) => RouteOpts {
-    const value = this.routeObject[key];
-    return (queryData?: Record<string, any>) => {
-      return {
-        ...value,
-        ...queryData,
-      };
-    };
+    return new QueryUtil.Chain(obj, newOpts);
+  }
+  queryChain<K extends keyof T>(key: K, opts?: QueryChainOptions) {
+    const value = this.obj[key];
+    return new QueryUtil.QueryChain(value, opts);
+  }
+  static Chain = Chain;
+  static QueryChain = QueryChain;
+  get routeObject() {
+    return this.obj;
   }
 }

package/src/router-simple.ts

@@ -1,6 +1,6 @@
 import { pathToRegexp, Key } from 'path-to-regexp';
 import type { IncomingMessage, ServerResponse } from 'node:http';
-import { parseBody, parseSearch } from './server/parse-body.ts';
+import { parseBody, parseSearch, parseSearchValue } from './server/parse-body.ts';
 
 type Req = IncomingMessage & { params?: Record<string, string> };
 interface Route {
@@ -24,6 +24,7 @@ export class SimpleRouter {
   getSearch(req: Req) {
     return parseSearch(req);
   }
+  parseSearchValue = parseSearchValue;
   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);

package/src/server/parse-body.ts

@@ -10,7 +10,39 @@ export const parseBody = async <T = Record<string, any>>(req: IncomingMessage) =
     req.on('end', () => {
       try {
         const body = Buffer.concat(arr).toString();
-        resolve(JSON.parse(body));
+
+        // 获取 Content-Type 头信息
+        const contentType = req.headers['content-type'] || '';
+
+        // 处理 application/json
+        if (contentType.includes('application/json')) {
+          resolve(JSON.parse(body) as T);
+          return;
+        }
+        // 处理 application/x-www-form-urlencoded
+        if (contentType.includes('application/x-www-form-urlencoded')) {
+          const formData = new URLSearchParams(body);
+          const result: Record<string, any> = {};
+
+          formData.forEach((value, key) => {
+            // 尝试将值解析为 JSON，如果失败则保留原始字符串
+            try {
+              result[key] = JSON.parse(value);
+            } catch {
+              result[key] = value;
+            }
+          });
+
+          resolve(result as T);
+          return;
+        }
+
+        // 默认尝试 JSON 解析
+        try {
+          resolve(JSON.parse(body) as T);
+        } catch {
+          resolve({} as T);
+        }
       } catch (e) {
         resolve({} as T);
       }