@kevisual/router 0.0.21-beta → 0.0.21

package/dist/router-browser.d.ts

@@ -12,8 +12,8 @@ type BaseRule = {
 };
 type RuleString = {
     type: 'string';
-    minLength?: number;
-    maxLength?: number;
+    min?: number;
+    max?: number;
     regex?: string;
 } & BaseRule;
 type RuleNumber = {
@@ -27,8 +27,6 @@ type RuleBoolean = {
 type RuleArray = {
     type: 'array';
     items: Rule;
-    minItems?: number;
-    maxItems?: number;
 } & BaseRule;
 type RuleObject = {
     type: 'object';

package/dist/router-browser.js

@@ -4499,10 +4499,10 @@ const schemaFormRule = (rule) => {
     switch (rule.type) {
         case 'string':
             let stringSchema = z.string();
-            if (rule.minLength)
-                stringSchema = stringSchema.min(rule.minLength, `String must be at least ${rule.minLength} characters long.`);
-            if (rule.maxLength)
-                stringSchema = stringSchema.max(rule.maxLength, `String must not exceed ${rule.maxLength} characters.`);
+            if (rule.min)
+                stringSchema = stringSchema.min(rule.min, `String must be at least ${rule.min} characters long.`);
+            if (rule.max)
+                stringSchema = stringSchema.max(rule.max, `String must not exceed ${rule.max} characters.`);
             if (rule.regex)
                 stringSchema = stringSchema.regex(new RegExp(rule.regex), 'Invalid format');
             return stringSchema;

package/dist/router.d.ts

@@ -5,6 +5,7 @@ import https from 'node:https';
 import http2 from 'node:http2';
 import * as cookie from 'cookie';
 import { WebSocketServer, WebSocket } from 'ws';
+import { IncomingMessage as IncomingMessage$1, ServerResponse as ServerResponse$1 } from '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';
 
@@ -15,8 +16,8 @@ type BaseRule = {
 };
 type RuleString = {
     type: 'string';
-    minLength?: number;
-    maxLength?: number;
+    min?: number;
+    max?: number;
     regex?: string;
 } & BaseRule;
 type RuleNumber = {
@@ -30,8 +31,6 @@ type RuleBoolean = {
 type RuleArray = {
     type: 'array';
     items: Rule;
-    minItems?: number;
-    maxItems?: number;
 } & BaseRule;
 type RuleObject = {
     type: 'object';
@@ -716,6 +715,10 @@ declare class App<T = {}, U = AppReqRes> {
     importRoutes(routes: any[]): void;
     importApp(app: App): void;
     throw(code?: number | string, message?: string, tips?: string): void;
+    static handleRequest(req: IncomingMessage$1, res: ServerResponse$1): Promise<{
+        cookies: Record<string, string>;
+        token: string;
+    }>;
 }
 
 export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, QueryUtil, Route, Server, createSchema, define, handleServer, util };

package/dist/router.js

@@ -4521,10 +4521,10 @@ const schemaFormRule = (rule) => {
     switch (rule.type) {
         case 'string':
             let stringSchema = z.string();
-            if (rule.minLength)
-                stringSchema = stringSchema.min(rule.minLength, `String must be at least ${rule.minLength} characters long.`);
-            if (rule.maxLength)
-                stringSchema = stringSchema.max(rule.maxLength, `String must not exceed ${rule.maxLength} characters.`);
+            if (rule.min)
+                stringSchema = stringSchema.min(rule.min, `String must be at least ${rule.min} characters long.`);
+            if (rule.max)
+                stringSchema = stringSchema.max(rule.max, `String must not exceed ${rule.max} characters.`);
             if (rule.regex)
                 stringSchema = stringSchema.regex(new RegExp(rule.regex), 'Invalid format');
             return stringSchema;
@@ -12169,6 +12169,9 @@ class App {
     throw(...args) {
         throw new CustomError(...args);
     }
+    static handleRequest(req, res) {
+        return handleServer(req, res);
+    }
 }
 
 export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, QueryUtil, Route, ZodType as Schema, Server, createSchema, define, handleServer, util };

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.21-beta",
+  "version": "0.0.21",
   "description": "",
   "type": "module",
   "main": "./dist/router.js",

package/src/app.ts

@@ -2,6 +2,8 @@ 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';
+import { handleServer } from './server/handle-server.ts';
+import { IncomingMessage, ServerResponse } from 'http';
 
 type RouterHandle = (msg: { path: string; [key: string]: any }) => { code: string; data?: any; message?: string; [key: string]: any };
 type AppOptions<T = {}> = {
@@ -100,6 +102,9 @@ export class App<T = {}, U = AppReqRes> {
   throw(...args: any[]) {
     throw new CustomError(...args);
   }
+  static handleRequest(req: IncomingMessage, res: ServerResponse) {
+    return handleServer(req, res);
+  }
 }
 
 export * from './browser.ts';

package/src/validator/rule.ts

@@ -8,8 +8,8 @@ type BaseRule = {
 
 type RuleString = {
   type: 'string';
-  minLength?: number;
-  maxLength?: number;
+  min?: number;
+  max?: number;
   regex?: string;
 } & BaseRule;
 
@@ -26,8 +26,6 @@ type RuleBoolean = {
 type RuleArray = {
   type: 'array';
   items: Rule;
-  minItems?: number;
-  maxItems?: number;
 } & BaseRule;
 
 type RuleObject = {
@@ -45,8 +43,8 @@ export const schemaFormRule = (rule: Rule): z.ZodType<any, any, any> => {
   switch (rule.type) {
     case 'string':
       let stringSchema = z.string();
-      if (rule.minLength) stringSchema = stringSchema.min(rule.minLength, `String must be at least ${rule.minLength} characters long.`);
-      if (rule.maxLength) stringSchema = stringSchema.max(rule.maxLength, `String must not exceed ${rule.maxLength} characters.`);
+      if (rule.min) stringSchema = stringSchema.min(rule.min, `String must be at least ${rule.min} characters long.`);
+      if (rule.max) stringSchema = stringSchema.max(rule.max, `String must not exceed ${rule.max} characters.`);
       if (rule.regex) stringSchema = stringSchema.regex(new RegExp(rule.regex), 'Invalid format');
       return stringSchema;
     case 'number':