@kevisual/router 0.0.15 → 0.0.17

package/dist/router-browser.d.ts

@@ -2,6 +2,7 @@ import { Schema } from 'zod';
 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';
 
 type BaseRule = {
     value?: any;
@@ -110,6 +111,11 @@ type RouteContext<T = {
 } & T;
 type Run<T = any> = (ctx: RouteContext<T>) => Promise<typeof ctx | null | void>;
 type NextRoute = Pick<Route, 'id' | 'path' | 'key'>;
+type RouteMiddleware = {
+    path: string;
+    key?: string;
+    id?: string;
+} | string;
 type RouteOpts = {
     path?: string;
     key?: string;
@@ -120,7 +126,7 @@ type RouteOpts = {
     metadata?: {
         [key: string]: any;
     };
-    middleware?: Route[] | string[];
+    middleware?: RouteMiddleware[];
     type?: 'route' | 'middleware';
     /**
      * validator: {
@@ -171,7 +177,7 @@ declare class Route<U = {
     metadata?: {
         [key: string]: any;
     };
-    middleware?: (Route | string)[];
+    middleware?: RouteMiddleware[];
     type?: string;
     private _validator?;
     schema?: {
@@ -431,5 +437,47 @@ declare const parseSearchValue: (value?: string, opts?: {
     decode?: boolean;
 }) => any;
 
-export { CustomError, QueryRouter, QueryRouterServer, Route, createSchema, parseBody, parseSearch, parseSearchValue };
-export type { RouteContext, RouteOpts, Rule, Run };
+type RouteObject = {
+    [key: string]: RouteOpts$1;
+};
+declare function define<T extends Record<string, RouteOpts$1>>(value: T): {
+    [K in keyof T]: T[K] & RouteOpts$1;
+};
+type RouteArray = RouteOpts$1[];
+type ChainOptions = {
+    app: QueryRouterServer$1;
+};
+declare class Chain {
+    object: RouteOpts$1;
+    app?: QueryRouterServer$1;
+    constructor(object: RouteOpts$1, opts?: ChainOptions);
+    get key(): string;
+    get path(): string;
+    setDescription(desc: string): this;
+    setMeta(metadata: {
+        [key: string]: any;
+    }): this;
+    setPath(path: string): this;
+    setMiddleware(middleware: RouteMiddleware$1[]): this;
+    setKey(key: string): this;
+    setId(key: string): this;
+    setRun(run: Run$1): this;
+    define(run: Run$1): this;
+    createRoute(): this;
+}
+declare const util: {
+    getChain: (obj: RouteOpts$1, opts?: ChainOptions) => Chain;
+};
+declare class QueryUtil<T extends RouteObject = RouteObject> {
+    routeObject: 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;
+}
+
+export { CustomError, QueryRouter, QueryRouterServer, QueryUtil, Route, createSchema, define, parseBody, parseSearch, parseSearchValue, util };
+export type { RouteArray, RouteContext, RouteObject, RouteOpts, Rule, Run };

package/dist/router-browser.js

@@ -94,7 +94,7 @@ try {
 }
 */
 
-var util;
+var util$1;
 (function (util) {
     util.assertEqual = (val) => val;
     function assertIs(_arg) { }
@@ -156,7 +156,7 @@ var util;
         }
         return value;
     };
-})(util || (util = {}));
+})(util$1 || (util$1 = {}));
 var objectUtil;
 (function (objectUtil) {
     objectUtil.mergeShapes = (first, second) => {
@@ -166,7 +166,7 @@ var objectUtil;
         };
     };
 })(objectUtil || (objectUtil = {}));
-const ZodParsedType = util.arrayToEnum([
+const ZodParsedType = util$1.arrayToEnum([
     "string",
     "nan",
     "number",
@@ -233,7 +233,7 @@ const getParsedType = (data) => {
     }
 };
 
-const ZodIssueCode = util.arrayToEnum([
+const ZodIssueCode = util$1.arrayToEnum([
     "invalid_type",
     "invalid_literal",
     "custom",
@@ -337,7 +337,7 @@ class ZodError extends Error {
         return this.message;
     }
     get message() {
-        return JSON.stringify(this.issues, util.jsonStringifyReplacer, 2);
+        return JSON.stringify(this.issues, util$1.jsonStringifyReplacer, 2);
     }
     get isEmpty() {
         return this.issues.length === 0;
@@ -377,19 +377,19 @@ const errorMap = (issue, _ctx) => {
             }
             break;
         case ZodIssueCode.invalid_literal:
-            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util.jsonStringifyReplacer)}`;
+            message = `Invalid literal value, expected ${JSON.stringify(issue.expected, util$1.jsonStringifyReplacer)}`;
             break;
         case ZodIssueCode.unrecognized_keys:
-            message = `Unrecognized key(s) in object: ${util.joinValues(issue.keys, ", ")}`;
+            message = `Unrecognized key(s) in object: ${util$1.joinValues(issue.keys, ", ")}`;
             break;
         case ZodIssueCode.invalid_union:
             message = `Invalid input`;
             break;
         case ZodIssueCode.invalid_union_discriminator:
-            message = `Invalid discriminator value. Expected ${util.joinValues(issue.options)}`;
+            message = `Invalid discriminator value. Expected ${util$1.joinValues(issue.options)}`;
             break;
         case ZodIssueCode.invalid_enum_value:
-            message = `Invalid enum value. Expected ${util.joinValues(issue.options)}, received '${issue.received}'`;
+            message = `Invalid enum value. Expected ${util$1.joinValues(issue.options)}, received '${issue.received}'`;
             break;
         case ZodIssueCode.invalid_arguments:
             message = `Invalid function arguments`;
@@ -415,7 +415,7 @@ const errorMap = (issue, _ctx) => {
                     message = `Invalid input: must end with "${issue.validation.endsWith}"`;
                 }
                 else {
-                    util.assertNever(issue.validation);
+                    util$1.assertNever(issue.validation);
                 }
             }
             else if (issue.validation !== "regex") {
@@ -485,7 +485,7 @@ const errorMap = (issue, _ctx) => {
             break;
         default:
             message = _ctx.defaultError;
-            util.assertNever(issue);
+            util$1.assertNever(issue);
     }
     return { message };
 };
@@ -1444,7 +1444,7 @@ class ZodString extends ZodType {
                 }
             }
             else {
-                util.assertNever(check);
+                util$1.assertNever(check);
             }
         }
         return { status: status.value, value: input.data };
@@ -1731,7 +1731,7 @@ class ZodNumber extends ZodType {
         const status = new ParseStatus();
         for (const check of this._def.checks) {
             if (check.kind === "int") {
-                if (!util.isInteger(input.data)) {
+                if (!util$1.isInteger(input.data)) {
                     ctx = this._getOrReturnCtx(input, ctx);
                     addIssueToContext(ctx, {
                         code: ZodIssueCode.invalid_type,
@@ -1798,7 +1798,7 @@ class ZodNumber extends ZodType {
                 }
             }
             else {
-                util.assertNever(check);
+                util$1.assertNever(check);
             }
         }
         return { status: status.value, value: input.data };
@@ -1921,7 +1921,7 @@ class ZodNumber extends ZodType {
     }
     get isInt() {
         return !!this._def.checks.find((ch) => ch.kind === "int" ||
-            (ch.kind === "multipleOf" && util.isInteger(ch.value)));
+            (ch.kind === "multipleOf" && util$1.isInteger(ch.value)));
     }
     get isFinite() {
         let max = null, min = null;
@@ -2017,7 +2017,7 @@ class ZodBigInt extends ZodType {
                 }
             }
             else {
-                util.assertNever(check);
+                util$1.assertNever(check);
             }
         }
         return { status: status.value, value: input.data };
@@ -2211,7 +2211,7 @@ class ZodDate extends ZodType {
                 }
             }
             else {
-                util.assertNever(check);
+                util$1.assertNever(check);
             }
         }
         return {
@@ -2584,7 +2584,7 @@ class ZodObject extends ZodType {
         if (this._cached !== null)
             return this._cached;
         const shape = this._def.shape();
-        const keys = util.objectKeys(shape);
+        const keys = util$1.objectKeys(shape);
         return (this._cached = { shape, keys });
     }
     _parse(input) {
@@ -2826,7 +2826,7 @@ class ZodObject extends ZodType {
     }
     pick(mask) {
         const shape = {};
-        util.objectKeys(mask).forEach((key) => {
+        util$1.objectKeys(mask).forEach((key) => {
             if (mask[key] && this.shape[key]) {
                 shape[key] = this.shape[key];
             }
@@ -2838,7 +2838,7 @@ class ZodObject extends ZodType {
     }
     omit(mask) {
         const shape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        util$1.objectKeys(this.shape).forEach((key) => {
             if (!mask[key]) {
                 shape[key] = this.shape[key];
             }
@@ -2856,7 +2856,7 @@ class ZodObject extends ZodType {
     }
     partial(mask) {
         const newShape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        util$1.objectKeys(this.shape).forEach((key) => {
             const fieldSchema = this.shape[key];
             if (mask && !mask[key]) {
                 newShape[key] = fieldSchema;
@@ -2872,7 +2872,7 @@ class ZodObject extends ZodType {
     }
     required(mask) {
         const newShape = {};
-        util.objectKeys(this.shape).forEach((key) => {
+        util$1.objectKeys(this.shape).forEach((key) => {
             if (mask && !mask[key]) {
                 newShape[key] = this.shape[key];
             }
@@ -2891,7 +2891,7 @@ class ZodObject extends ZodType {
         });
     }
     keyof() {
-        return createZodEnum(util.objectKeys(this.shape));
+        return createZodEnum(util$1.objectKeys(this.shape));
     }
 }
 ZodObject.create = (shape, params) => {
@@ -3039,7 +3039,7 @@ const getDiscriminator = (type) => {
     }
     else if (type instanceof ZodNativeEnum) {
         // eslint-disable-next-line ban/ban
-        return util.objectValues(type.enum);
+        return util$1.objectValues(type.enum);
     }
     else if (type instanceof ZodDefault) {
         return getDiscriminator(type._def.innerType);
@@ -3155,8 +3155,8 @@ function mergeValues(a, b) {
         return { valid: true, data: a };
     }
     else if (aType === ZodParsedType.object && bType === ZodParsedType.object) {
-        const bKeys = util.objectKeys(b);
-        const sharedKeys = util
+        const bKeys = util$1.objectKeys(b);
+        const sharedKeys = util$1
             .objectKeys(a)
             .filter((key) => bKeys.indexOf(key) !== -1);
         const newObj = { ...a, ...b };
@@ -3711,7 +3711,7 @@ class ZodEnum extends ZodType {
             const ctx = this._getOrReturnCtx(input);
             const expectedValues = this._def.values;
             addIssueToContext(ctx, {
-                expected: util.joinValues(expectedValues),
+                expected: util$1.joinValues(expectedValues),
                 received: ctx.parsedType,
                 code: ZodIssueCode.invalid_type,
             });
@@ -3777,23 +3777,23 @@ class ZodNativeEnum extends ZodType {
         _ZodNativeEnum_cache.set(this, void 0);
     }
     _parse(input) {
-        const nativeEnumValues = util.getValidEnumValues(this._def.values);
+        const nativeEnumValues = util$1.getValidEnumValues(this._def.values);
         const ctx = this._getOrReturnCtx(input);
         if (ctx.parsedType !== ZodParsedType.string &&
             ctx.parsedType !== ZodParsedType.number) {
-            const expectedValues = util.objectValues(nativeEnumValues);
+            const expectedValues = util$1.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
-                expected: util.joinValues(expectedValues),
+                expected: util$1.joinValues(expectedValues),
                 received: ctx.parsedType,
                 code: ZodIssueCode.invalid_type,
             });
             return INVALID;
         }
         if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache)) {
-            __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util.getValidEnumValues(this._def.values)));
+            __classPrivateFieldSet(this, _ZodNativeEnum_cache, new Set(util$1.getValidEnumValues(this._def.values)));
         }
         if (!__classPrivateFieldGet(this, _ZodNativeEnum_cache).has(input.data)) {
-            const expectedValues = util.objectValues(nativeEnumValues);
+            const expectedValues = util$1.objectValues(nativeEnumValues);
             addIssueToContext(ctx, {
                 received: ctx.data,
                 code: ZodIssueCode.invalid_enum_value,
@@ -3976,7 +3976,7 @@ class ZodEffects extends ZodType {
                 });
             }
         }
-        util.assertNever(effect);
+        util$1.assertNever(effect);
     }
 }
 ZodEffects.create = (schema, effect, params) => {
@@ -4400,7 +4400,7 @@ var z = /*#__PURE__*/Object.freeze({
     isDirty: isDirty,
     isValid: isValid,
     isAsync: isAsync,
-    get util () { return util; },
+    get util () { return util$1; },
     get objectUtil () { return objectUtil; },
     ZodParsedType: ZodParsedType,
     getParsedType: getParsedType,
@@ -5911,7 +5911,15 @@ class QueryRouter {
                         route = this.routes.find((r) => r.id === item);
                     }
                     else {
-                        route = this.routes.find((r) => r.path === item.path && r.key === item.key);
+                        route = this.routes.find((r) => {
+                            if (item.id) {
+                                return r.id === item.id;
+                            }
+                            else {
+                                // key 可以是空，所以可以不严格验证
+                                return r.path === item.path && r.key == item.key;
+                            }
+                        });
                     }
                     if (!route) {
                         if (isString) {
@@ -6291,4 +6299,95 @@ const parseSearchValue = (value, opts) => {
     }
 };
 
-export { CustomError, QueryRouter, QueryRouterServer, Route, ZodType as Schema, createSchema, parseBody, parseSearch, parseSearchValue };
+function define(value) {
+    return value;
+}
+class Chain {
+    object;
+    app;
+    constructor(object, opts) {
+        this.object = object;
+        this.app = opts?.app;
+    }
+    get key() {
+        return this.object.key;
+    }
+    get path() {
+        return this.object.path;
+    }
+    setDescription(desc) {
+        this.object.description = desc;
+        return this;
+    }
+    setMeta(metadata) {
+        this.object.metadata = metadata;
+        return this;
+    }
+    setPath(path) {
+        this.object.path = path;
+        return this;
+    }
+    setMiddleware(middleware) {
+        this.object.middleware = middleware;
+        return this;
+    }
+    setKey(key) {
+        this.object.key = key;
+        return this;
+    }
+    setId(key) {
+        this.object.id = key;
+        return this;
+    }
+    setRun(run) {
+        this.object.run = run;
+        return this;
+    }
+    define(run) {
+        this.object.run = run;
+        return this;
+    }
+    createRoute() {
+        this.app.route(this.object).addTo(this.app);
+        return this;
+    }
+}
+const util = {
+    getChain: (obj, opts) => {
+        return new Chain(obj, opts);
+    },
+};
+class QueryUtil {
+    routeObject;
+    app;
+    constructor(object, opts) {
+        this.routeObject = object;
+        this.app = opts?.app;
+    }
+    static createFormObj(object, opts) {
+        return new QueryUtil(object, opts);
+    }
+    static create(value, opts) {
+        const obj = value;
+        return new QueryUtil(obj, opts);
+    }
+    get(key) {
+        return this.routeObject[key];
+    }
+    chain(key, opts) {
+        const obj = this.routeObject[key];
+        let newOpts = { app: this.app, ...opts };
+        return new Chain(obj, newOpts);
+    }
+    queryChain(key) {
+        const value = this.routeObject[key];
+        return (queryData) => {
+            return {
+                ...value,
+                ...queryData,
+            };
+        };
+    }
+}
+
+export { CustomError, QueryRouter, QueryRouterServer, QueryUtil, Route, ZodType as Schema, createSchema, define, parseBody, parseSearch, parseSearchValue, util };