@kevisual/router 0.0.3 → 0.0.4-alpha-7

package/dist/router.d.ts

@@ -0,0 +1,507 @@
+import { Schema } from 'zod';
+export { Schema } from 'zod';
+import http, { IncomingMessage, ServerResponse } from 'http';
+import { WebSocketServer, WebSocket } from 'ws';
+
+type BaseRule = {
+    value?: any;
+    required?: boolean;
+    message?: string;
+};
+type RuleString = {
+    type: 'string';
+    minLength?: number;
+    maxLength?: number;
+    regex?: string;
+} & BaseRule;
+type RuleNumber = {
+    type: 'number';
+    min?: number;
+    max?: number;
+} & BaseRule;
+type RuleBoolean = {
+    type: 'boolean';
+} & BaseRule;
+type RuleArray = {
+    type: 'array';
+    items: Rule;
+    minItems?: number;
+    maxItems?: number;
+} & BaseRule;
+type RuleObject = {
+    type: 'object';
+    properties: {
+        [key: string]: Rule;
+    };
+} & BaseRule;
+type RuleAny = {
+    type: 'any';
+} & BaseRule;
+type Rule = RuleString | RuleNumber | RuleBoolean | RuleArray | RuleObject | RuleAny;
+declare const createSchema: (rule: Rule) => Schema;
+
+type RouterContextT = {
+    code?: number;
+    [key: string]: any;
+};
+type RouteContext<T = {
+    code?: number;
+}, S = any> = {
+    query?: {
+        [key: string]: any;
+    };
+    /** return body */
+    body?: number | string | Object;
+    /** return code */
+    code?: number;
+    /** return msg */
+    message?: string;
+    state?: S;
+    currentPath?: string;
+    currentKey?: string;
+    currentRoute?: Route;
+    progress?: [[string, string]][];
+    nextQuery?: {
+        [key: string]: any;
+    };
+    end?: boolean;
+    queryRouter?: QueryRouter;
+    error?: any;
+    call?: (message: {
+        path: string;
+        key: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }) => Promise<any>;
+    index?: number;
+    throw?: (code?: number | string, message?: string, tips?: string) => void;
+} & T;
+type Run<T = any> = (ctx: RouteContext<T>) => Promise<typeof ctx | null | void>;
+type NextRoute = Pick<Route, 'id' | 'path' | 'key'>;
+type RouteOpts = {
+    path?: string;
+    key?: string;
+    id?: string;
+    run?: Run;
+    nextRoute?: NextRoute;
+    description?: string;
+    middleware?: Route[] | string[];
+    type?: 'route' | 'middleware';
+    /**
+     * validator: {
+     *  packageName: {
+     *    type: 'string',
+     *    required: true,
+     *  },
+     * }
+     */
+    validator?: {
+        [key: string]: Rule;
+    };
+    schema?: {
+        [key: string]: Schema<any>;
+    };
+    isVerify?: boolean;
+    verify?: (ctx?: RouteContext, dev?: boolean) => boolean;
+    verifyKey?: (key: string, ctx?: RouteContext, dev?: boolean) => boolean;
+    idUsePath?: boolean;
+    isDebug?: boolean;
+};
+type DefineRouteOpts = Omit<RouteOpts, 'idUsePath' | 'verify' | 'verifyKey' | 'nextRoute'>;
+declare const pickValue: readonly ["path", "key", "id", "description", "type", "validator", "middleware"];
+type RouteInfo = Pick<Route, (typeof pickValue)[number]>;
+declare class Route {
+    path?: string;
+    key?: string;
+    id?: string;
+    share?: boolean;
+    run?: Run;
+    nextRoute?: NextRoute;
+    description?: string;
+    middleware?: (Route | string)[];
+    type?: string;
+    private _validator?;
+    schema?: {
+        [key: string]: Schema<any>;
+    };
+    data?: any;
+    isVerify?: boolean;
+    isDebug?: boolean;
+    constructor(path: string, key?: string, opts?: RouteOpts);
+    private createSchema;
+    /**
+     * set validator and create schema
+     * @param validator
+     */
+    set validator(validator: {
+        [key: string]: Rule;
+    });
+    get validator(): {
+        [key: string]: Rule;
+    };
+    /**
+     * has code, body, message in ctx, return ctx if has error
+     * @param ctx
+     * @param dev
+     * @returns
+     */
+    verify(ctx: RouteContext, dev?: boolean): void;
+    /**
+     * Need to manully call return ctx fn and configure body, code, message
+     * @param key
+     * @param ctx
+     * @param dev
+     * @returns
+     */
+    verifyKey(key: string, ctx: RouteContext, dev?: boolean): {
+        message: string;
+        path: string;
+        key: string;
+        error: any;
+    } | {
+        message: string;
+        path: string;
+        key: string;
+        error?: undefined;
+    };
+    setValidator(validator: {
+        [key: string]: Rule;
+    }): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(opts: DefineRouteOpts): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(fn: Run<T>): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(key: string, fn: Run<T>): this;
+    define<T extends {
+        [key: string]: any;
+    } = RouterContextT>(path: string, key: string, fn: Run<T>): this;
+    addTo(router: QueryRouter | {
+        add: (route: Route) => void;
+        [key: string]: any;
+    }): void;
+    setData(data: any): this;
+    throw(code?: number | string, message?: string, tips?: string): void;
+}
+declare class QueryRouter {
+    routes: Route[];
+    maxNextRoute: number;
+    constructor();
+    add(route: Route): void;
+    /**
+     * remove route by path and key
+     * @param route
+     */
+    remove(route: Route | {
+        path: string;
+        key: string;
+    }): void;
+    /**
+     * remove route by id
+     * @param uniqueId
+     */
+    removeById(unique: string): void;
+    /**
+     * 执行route
+     * @param path
+     * @param key
+     * @param ctx
+     * @returns
+     */
+    runRoute(path: string, key: string, ctx?: RouteContext): any;
+    /**
+     * 第一次执行
+     * @param message
+     * @param ctx
+     * @returns
+     */
+    parse(message: {
+        path: string;
+        key?: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }): Promise<any>;
+    call(message: {
+        path: string;
+        key: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }): Promise<any>;
+    getList(): RouteInfo[];
+    getHandle<T = any>(router: QueryRouter, wrapperFn?: HandleFn<T>, ctx?: RouteContext): (msg: {
+        path: string;
+        key?: string;
+        [key: string]: any;
+    }) => Promise<{
+        [key: string]: any;
+        code: string;
+        data?: any;
+        message?: string;
+    } | {
+        code: any;
+        data: any;
+        message: any;
+    }>;
+    exportRoutes(): Route[];
+    importRoutes(routes: Route[]): void;
+    importRouter(router: QueryRouter): void;
+    throw(code?: number | string, message?: string, tips?: string): void;
+}
+type QueryRouterServerOpts = {
+    handleFn?: HandleFn;
+    context?: RouteContext;
+};
+interface HandleFn<T = any> {
+    (msg: {
+        path: string;
+        [key: string]: any;
+    }, ctx?: any): {
+        code: string;
+        data?: any;
+        message?: string;
+        [key: string]: any;
+    };
+    (res: RouteContext<T>): any;
+}
+/**
+ * QueryRouterServer
+ * @description 移除server相关的功能，只保留router相关的功能，和http.createServer不相关，独立
+ */
+declare class QueryRouterServer extends QueryRouter {
+    handle: any;
+    constructor(opts?: QueryRouterServerOpts);
+    setHandle(wrapperFn?: HandleFn, ctx?: RouteContext): void;
+    use(path: string, fn: (ctx: any) => any, opts?: RouteOpts): void;
+    addRoute(route: Route): void;
+    Route: typeof Route;
+    route(opts: RouteOpts): Route;
+    route(path: string, key?: string): Route;
+    route(path: string, opts?: RouteOpts): Route;
+    route(path: string, key?: string, opts?: RouteOpts): Route;
+    call(message: {
+        path: string;
+        key: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }): Promise<any>;
+    run({ path, key, payload }: {
+        path: string;
+        key: string;
+        payload?: any;
+    }): Promise<any>;
+}
+
+declare class Connect {
+    path: string;
+    key?: string;
+    _fn?: (ctx?: RouteContext) => Promise<RouteContext>;
+    description?: string;
+    connects: {
+        path: string;
+        key?: string;
+    }[];
+    share: boolean;
+    constructor(path: string);
+    use(path: string): void;
+    useList(paths: string[]): void;
+    useConnect(connect: Connect): void;
+    useConnectList(connects: Connect[]): void;
+    getPathList(): string[];
+    set fn(fn: (ctx?: RouteContext) => Promise<RouteContext>);
+    get fn(): (ctx?: RouteContext) => Promise<RouteContext>;
+}
+declare class QueryConnect {
+    connects: Connect[];
+    constructor();
+    add(connect: Connect): void;
+    remove(connect: Connect): void;
+    getList(): {
+        path: string;
+        key: string;
+    }[];
+}
+
+type Listener = (...args: any[]) => void;
+type Cors = {
+    /**
+     * @default '*''
+     */
+    origin?: string | undefined;
+};
+type ServerOpts = {
+    /**path default `/api/router` */
+    path?: string;
+    /**handle Fn */
+    handle?: (msg?: {
+        path: string;
+        key?: string;
+        [key: string]: any;
+    }) => any;
+    cors?: Cors;
+};
+declare class Server {
+    path: string;
+    private _server;
+    handle: ServerOpts['handle'];
+    private _callback;
+    private cors;
+    private hasOn;
+    constructor(opts?: ServerOpts);
+    listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
+    listen(port: number, hostname?: string, listeningListener?: () => void): void;
+    listen(port: number, backlog?: number, listeningListener?: () => void): void;
+    listen(port: number, listeningListener?: () => void): void;
+    listen(path: string, backlog?: number, listeningListener?: () => void): void;
+    listen(path: string, listeningListener?: () => void): void;
+    listen(handle: any, backlog?: number, listeningListener?: () => void): void;
+    listen(handle: any, listeningListener?: () => void): void;
+    setHandle(handle?: any): void;
+    /**
+     * get callback
+     * @returns
+     */
+    createCallback(): (req: IncomingMessage, res: ServerResponse) => Promise<void>;
+    get handleServer(): any;
+    set handleServer(fn: any);
+    /**
+     * 兜底监听，当除开 `/api/router` 之外的请求，框架只监听一个api，所以有其他的请求都执行其他的监听
+     * @description 主要是为了兼容其他的监听
+     * @param listener
+     */
+    on(listener: Listener | Listener[]): void;
+    get callback(): any;
+    get server(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+}
+
+/**
+ * get params and body
+ * @param req
+ * @param res
+ * @returns
+ */
+declare const handleServer: (req: IncomingMessage, res: ServerResponse) => Promise<{
+    token: string;
+}>;
+
+/** 自定义错误 */
+declare class CustomError extends Error {
+    code?: number;
+    data?: any;
+    message: string;
+    tips?: string;
+    constructor(code?: number | string, message?: string, tips?: string);
+    static fromCode(code?: number): CustomError;
+    static fromErrorData(code?: number, data?: any): CustomError;
+    static parseError(e: CustomError): {
+        code: number;
+        data: any;
+        message: string;
+        tips: string;
+    };
+    parse(e?: CustomError): {
+        code: number;
+        data: any;
+        message: string;
+        tips: string;
+    };
+}
+
+type WsServerBaseOpts = {
+    wss?: WebSocketServer;
+    path?: string;
+};
+type ListenerFn = (message: {
+    data: Record<string, any>;
+    ws: WebSocket;
+    end: (data: any) => any;
+}) => Promise<any>;
+declare class WsServerBase {
+    wss: WebSocketServer;
+    path: string;
+    listeners: {
+        type: string;
+        listener: ListenerFn;
+    }[];
+    listening: boolean;
+    constructor(opts: WsServerBaseOpts);
+    setPath(path: string): void;
+    listen(): void;
+    addListener(type: string, listener: ListenerFn): void;
+    removeListener(type: string): void;
+}
+declare class WsServer extends WsServerBase {
+    server: Server;
+    constructor(server: Server, opts?: any);
+    initListener(): void;
+    listen(): void;
+}
+
+type RouterHandle = (msg: {
+    path: string;
+    [key: string]: any;
+}) => {
+    code: string;
+    data?: any;
+    message?: string;
+    [key: string]: any;
+};
+type AppOptions<T = {}> = {
+    router?: QueryRouter;
+    server?: Server;
+    /** handle msg 关联 */
+    routerHandle?: RouterHandle;
+    routerContext?: RouteContext<T>;
+    serverOptions?: {
+        path?: string;
+        cors?: Cors;
+        handle?: any;
+    };
+    io?: boolean;
+    ioOpts?: {
+        routerHandle?: RouterHandle;
+        routerContext?: RouteContext<T>;
+        path?: string;
+    };
+};
+declare class App<T = {}> {
+    router: QueryRouter;
+    server: Server;
+    io: WsServer;
+    constructor(opts?: AppOptions<T>);
+    listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
+    listen(port: number, hostname?: string, listeningListener?: () => void): void;
+    listen(port: number, backlog?: number, listeningListener?: () => void): void;
+    listen(port: number, listeningListener?: () => void): void;
+    listen(path: string, backlog?: number, listeningListener?: () => void): void;
+    listen(path: string, listeningListener?: () => void): void;
+    listen(handle: any, backlog?: number, listeningListener?: () => void): void;
+    listen(handle: any, listeningListener?: () => void): void;
+    use(path: string, fn: (ctx: any) => any, opts?: RouteOpts): void;
+    addRoute(route: Route): void;
+    add: (route: Route) => void;
+    Route: typeof Route;
+    route(opts: RouteOpts): Route;
+    route(path: string, key?: string): Route;
+    route(path: string, opts?: RouteOpts): Route;
+    route(path: string, key?: string, opts?: RouteOpts): Route;
+    call(message: {
+        path: string;
+        key: string;
+        payload?: any;
+    }, ctx?: RouteContext & {
+        [key: string]: any;
+    }): Promise<any>;
+    exportRoutes(): Route[];
+    importRoutes(routes: any[]): void;
+    importApp(app: App): void;
+    throw(code?: number | string, message?: string, tips?: string): void;
+}
+
+export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, Route, type RouteContext, type RouteOpts, type Rule, type Run, Server, createSchema, handleServer };

package/dist/{index.js → router.js}

@@ -5652,6 +5652,9 @@ class Route {
         this.data = data;
         return this;
     }
+    throw(...args) {
+        throw new CustomError(...args);
+    }
 }
 class QueryRouter {
     routes;
@@ -5873,6 +5876,7 @@ class QueryRouter {
         ctx = ctx || {};
         ctx.query = { ...ctx.query, ...query, ...payload };
         ctx.state = {};
+        ctx.throw = this.throw;
         // put queryRouter to ctx
         // TODO: 是否需要queryRouter，函数内部处理router路由执行，这应该是避免去内部去包含的功能过
         ctx.queryRouter = this;
@@ -5900,6 +5904,22 @@ class QueryRouter {
             return { code, data: body, message };
         };
     }
+    exportRoutes() {
+        return this.routes.map((r) => {
+            return r;
+        });
+    }
+    importRoutes(routes) {
+        for (let route of routes) {
+            this.add(route);
+        }
+    }
+    importRouter(router) {
+        this.importRoutes(router.routes);
+    }
+    throw(...args) {
+        throw new CustomError(...args);
+    }
 }
 /**
  * QueryRouterServer
@@ -5914,6 +5934,59 @@ class QueryRouterServer extends QueryRouter {
     setHandle(wrapperFn, ctx) {
         this.handle = this.getHandle(this, wrapperFn, ctx);
     }
+    use(path, fn, opts) {
+        const route = new Route(path, '', opts);
+        route.run = fn;
+        this.add(route);
+    }
+    addRoute(route) {
+        this.add(route);
+    }
+    Route = Route;
+    route(...args) {
+        const [path, key, opts] = args;
+        if (typeof path === 'object') {
+            return new Route(path.path, path.key, path);
+        }
+        if (typeof path === 'string') {
+            if (opts) {
+                return new Route(path, key, opts);
+            }
+            if (key && typeof key === 'object') {
+                return new Route(path, key?.key || '', key);
+            }
+            return new Route(path, key);
+        }
+        return new Route(path, key, opts);
+    }
+    async call(message, ctx) {
+        return await this.parse(message, ctx);
+    }
+    async run({ path, key, payload }) {
+        const handle = this.handle;
+        const resultError = (error, code = 500) => {
+            const r = {
+                code: code,
+                message: error,
+            };
+            return r;
+        };
+        try {
+            const end = handle({ path, key, ...payload });
+            return end;
+        }
+        catch (e) {
+            if (e.code && typeof e.code === 'number') {
+                return {
+                    code: e.code,
+                    message: e.message,
+                };
+            }
+            else {
+                return resultError('Router Server error');
+            }
+        }
+    }
 }
 
 class Connect {
@@ -6167,46 +6240,6 @@ class Server {
     }
 }
 
-const Code400 = [
-    {
-        code: 400,
-        msg: 'Bad Request',
-        zn: '表示其他错误，就是4xx都无法描述的前端发生的错误',
-    },
-    { code: 401, msg: 'Authentication', zn: '表示认证类型的错误' }, // token 无效 （无token， token无效， token 过期）
-    {
-        code: 403,
-        msg: 'Authorization',
-        zn: '表示授权的错误（认证和授权的区别在于：认证表示“识别前来访问的是谁”，而授权则是“赋予特定用户执行特定操作的权限”）',
-    },
-    { code: 404, msg: 'Not Found', zn: '表示访问的数据不存在' },
-    {
-        code: 405,
-        msg: 'Method Not Allowd',
-        zn: '表示可以访问接口，但是使用的HTTP方法不允许',
-    },
-];
-const ResultCode = [{ code: 200, msg: 'OK', zn: '请求成功。' }].concat(Code400);
-const Result = ({ code, msg, userTip, ...other }) => {
-    const Code = ResultCode.find((item) => item.code === code);
-    let _result = {
-        code: code || Code?.code,
-        msg: msg || Code?.msg,
-        userTip: undefined,
-        ...other,
-    };
-    if (userTip) {
-        _result.userTip = userTip;
-    }
-    return _result;
-};
-Result.success = (data) => {
-    return {
-        code: 200,
-        data,
-    };
-};
-
 const parseIfJson = (input) => {
     try {
         // 尝试解析 JSON
@@ -6412,6 +6445,18 @@ class App {
         const router = this.router;
         return await router.parse(message, ctx);
     }
+    exportRoutes() {
+        return this.router.exportRoutes();
+    }
+    importRoutes(routes) {
+        this.router.importRoutes(routes);
+    }
+    importApp(app) {
+        this.importRoutes(app.exportRoutes());
+    }
+    throw(...args) {
+        throw new CustomError(...args);
+    }
 }
 
-export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, Result, Route, ZodType as Schema, Server, createSchema, handleServer };
+export { App, Connect, CustomError, QueryConnect, QueryRouter, QueryRouterServer, Route, ZodType as Schema, Server, createSchema, handleServer };