@kevisual/router 0.0.4-alpha-7 → 0.0.5-alpha-0

package/dist/router-simple.d.ts

@@ -0,0 +1,25 @@
+import { Key } from 'path-to-regexp';
+import { ServerResponse, IncomingMessage } from 'http';
+
+type Req = IncomingMessage & {
+    params?: Record<string, string>;
+};
+interface Route {
+    method: string;
+    regexp: RegExp;
+    keys: Key[];
+    handlers: Array<(req: Req, res: ServerResponse) => Promise<void> | void>;
+}
+/**
+ * SimpleRouter
+ */
+declare class SimpleRouter {
+    routes: Route[];
+    constructor();
+    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;
+    parse(req: Req, res: ServerResponse): Promise<void>;
+}
+
+export { SimpleRouter };

package/dist/router-simple.js

@@ -0,0 +1,463 @@
+var dist = {};
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	Object.defineProperty(dist, "__esModule", { value: true });
+	dist.TokenData = void 0;
+	dist.parse = parse;
+	dist.compile = compile;
+	dist.match = match;
+	dist.pathToRegexp = pathToRegexp;
+	dist.stringify = stringify;
+	const DEFAULT_DELIMITER = "/";
+	const NOOP_VALUE = (value) => value;
+	const ID_START = /^[$_\p{ID_Start}]$/u;
+	const ID_CONTINUE = /^[$\u200c\u200d\p{ID_Continue}]$/u;
+	const DEBUG_URL = "https://git.new/pathToRegexpError";
+	const SIMPLE_TOKENS = {
+	    // Groups.
+	    "{": "{",
+	    "}": "}",
+	    // Reserved.
+	    "(": "(",
+	    ")": ")",
+	    "[": "[",
+	    "]": "]",
+	    "+": "+",
+	    "?": "?",
+	    "!": "!",
+	};
+	/**
+	 * Escape text for stringify to path.
+	 */
+	function escapeText(str) {
+	    return str.replace(/[{}()\[\]+?!:*]/g, "\\$&");
+	}
+	/**
+	 * Escape a regular expression string.
+	 */
+	function escape(str) {
+	    return str.replace(/[.+*?^${}()[\]|/\\]/g, "\\$&");
+	}
+	/**
+	 * Tokenize input string.
+	 */
+	function* lexer(str) {
+	    const chars = [...str];
+	    let i = 0;
+	    function name() {
+	        let value = "";
+	        if (ID_START.test(chars[++i])) {
+	            value += chars[i];
+	            while (ID_CONTINUE.test(chars[++i])) {
+	                value += chars[i];
+	            }
+	        }
+	        else if (chars[i] === '"') {
+	            let pos = i;
+	            while (i < chars.length) {
+	                if (chars[++i] === '"') {
+	                    i++;
+	                    pos = 0;
+	                    break;
+	                }
+	                if (chars[i] === "\\") {
+	                    value += chars[++i];
+	                }
+	                else {
+	                    value += chars[i];
+	                }
+	            }
+	            if (pos) {
+	                throw new TypeError(`Unterminated quote at ${pos}: ${DEBUG_URL}`);
+	            }
+	        }
+	        if (!value) {
+	            throw new TypeError(`Missing parameter name at ${i}: ${DEBUG_URL}`);
+	        }
+	        return value;
+	    }
+	    while (i < chars.length) {
+	        const value = chars[i];
+	        const type = SIMPLE_TOKENS[value];
+	        if (type) {
+	            yield { type, index: i++, value };
+	        }
+	        else if (value === "\\") {
+	            yield { type: "ESCAPED", index: i++, value: chars[i++] };
+	        }
+	        else if (value === ":") {
+	            const value = name();
+	            yield { type: "PARAM", index: i, value };
+	        }
+	        else if (value === "*") {
+	            const value = name();
+	            yield { type: "WILDCARD", index: i, value };
+	        }
+	        else {
+	            yield { type: "CHAR", index: i, value: chars[i++] };
+	        }
+	    }
+	    return { type: "END", index: i, value: "" };
+	}
+	class Iter {
+	    constructor(tokens) {
+	        this.tokens = tokens;
+	    }
+	    peek() {
+	        if (!this._peek) {
+	            const next = this.tokens.next();
+	            this._peek = next.value;
+	        }
+	        return this._peek;
+	    }
+	    tryConsume(type) {
+	        const token = this.peek();
+	        if (token.type !== type)
+	            return;
+	        this._peek = undefined; // Reset after consumed.
+	        return token.value;
+	    }
+	    consume(type) {
+	        const value = this.tryConsume(type);
+	        if (value !== undefined)
+	            return value;
+	        const { type: nextType, index } = this.peek();
+	        throw new TypeError(`Unexpected ${nextType} at ${index}, expected ${type}: ${DEBUG_URL}`);
+	    }
+	    text() {
+	        let result = "";
+	        let value;
+	        while ((value = this.tryConsume("CHAR") || this.tryConsume("ESCAPED"))) {
+	            result += value;
+	        }
+	        return result;
+	    }
+	}
+	/**
+	 * Tokenized path instance.
+	 */
+	class TokenData {
+	    constructor(tokens) {
+	        this.tokens = tokens;
+	    }
+	}
+	dist.TokenData = TokenData;
+	/**
+	 * Parse a string for the raw tokens.
+	 */
+	function parse(str, options = {}) {
+	    const { encodePath = NOOP_VALUE } = options;
+	    const it = new Iter(lexer(str));
+	    function consume(endType) {
+	        const tokens = [];
+	        while (true) {
+	            const path = it.text();
+	            if (path)
+	                tokens.push({ type: "text", value: encodePath(path) });
+	            const param = it.tryConsume("PARAM");
+	            if (param) {
+	                tokens.push({
+	                    type: "param",
+	                    name: param,
+	                });
+	                continue;
+	            }
+	            const wildcard = it.tryConsume("WILDCARD");
+	            if (wildcard) {
+	                tokens.push({
+	                    type: "wildcard",
+	                    name: wildcard,
+	                });
+	                continue;
+	            }
+	            const open = it.tryConsume("{");
+	            if (open) {
+	                tokens.push({
+	                    type: "group",
+	                    tokens: consume("}"),
+	                });
+	                continue;
+	            }
+	            it.consume(endType);
+	            return tokens;
+	        }
+	    }
+	    const tokens = consume("END");
+	    return new TokenData(tokens);
+	}
+	/**
+	 * Compile a string to a template function for the path.
+	 */
+	function compile(path, options = {}) {
+	    const { encode = encodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+	    const data = path instanceof TokenData ? path : parse(path, options);
+	    const fn = tokensToFunction(data.tokens, delimiter, encode);
+	    return function path(data = {}) {
+	        const [path, ...missing] = fn(data);
+	        if (missing.length) {
+	            throw new TypeError(`Missing parameters: ${missing.join(", ")}`);
+	        }
+	        return path;
+	    };
+	}
+	function tokensToFunction(tokens, delimiter, encode) {
+	    const encoders = tokens.map((token) => tokenToFunction(token, delimiter, encode));
+	    return (data) => {
+	        const result = [""];
+	        for (const encoder of encoders) {
+	            const [value, ...extras] = encoder(data);
+	            result[0] += value;
+	            result.push(...extras);
+	        }
+	        return result;
+	    };
+	}
+	/**
+	 * Convert a single token into a path building function.
+	 */
+	function tokenToFunction(token, delimiter, encode) {
+	    if (token.type === "text")
+	        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 [""];
+	        };
+	    }
+	    const encodeValue = encode || NOOP_VALUE;
+	    if (token.type === "wildcard" && encode !== false) {
+	        return (data) => {
+	            const value = data[token.name];
+	            if (value == null)
+	                return ["", token.name];
+	            if (!Array.isArray(value) || value.length === 0) {
+	                throw new TypeError(`Expected "${token.name}" to be a non-empty array`);
+	            }
+	            return [
+	                value
+	                    .map((value, index) => {
+	                    if (typeof value !== "string") {
+	                        throw new TypeError(`Expected "${token.name}/${index}" to be a string`);
+	                    }
+	                    return encodeValue(value);
+	                })
+	                    .join(delimiter),
+	            ];
+	        };
+	    }
+	    return (data) => {
+	        const value = data[token.name];
+	        if (value == null)
+	            return ["", token.name];
+	        if (typeof value !== "string") {
+	            throw new TypeError(`Expected "${token.name}" to be a string`);
+	        }
+	        return [encodeValue(value)];
+	    };
+	}
+	/**
+	 * Transform a path into a match function.
+	 */
+	function match(path, options = {}) {
+	    const { decode = decodeURIComponent, delimiter = DEFAULT_DELIMITER } = options;
+	    const { regexp, keys } = pathToRegexp(path, options);
+	    const decoders = keys.map((key) => {
+	        if (decode === false)
+	            return NOOP_VALUE;
+	        if (key.type === "param")
+	            return decode;
+	        return (value) => value.split(delimiter).map(decode);
+	    });
+	    return function match(input) {
+	        const m = regexp.exec(input);
+	        if (!m)
+	            return false;
+	        const path = m[0];
+	        const params = Object.create(null);
+	        for (let i = 1; i < m.length; i++) {
+	            if (m[i] === undefined)
+	                continue;
+	            const key = keys[i - 1];
+	            const decoder = decoders[i - 1];
+	            params[key.name] = decoder(m[i]);
+	        }
+	        return { path, params };
+	    };
+	}
+	function pathToRegexp(path, options = {}) {
+	    const { delimiter = DEFAULT_DELIMITER, end = true, sensitive = false, trailing = true, } = options;
+	    const keys = [];
+	    const sources = [];
+	    const flags = sensitive ? "" : "i";
+	    const paths = Array.isArray(path) ? path : [path];
+	    const items = paths.map((path) => path instanceof TokenData ? path : parse(path, options));
+	    for (const { tokens } of items) {
+	        for (const seq of flatten(tokens, 0, [])) {
+	            const regexp = sequenceToRegExp(seq, delimiter, keys);
+	            sources.push(regexp);
+	        }
+	    }
+	    let pattern = `^(?:${sources.join("|")})`;
+	    if (trailing)
+	        pattern += `(?:${escape(delimiter)}$)?`;
+	    pattern += end ? "$" : `(?=${escape(delimiter)}|$)`;
+	    const regexp = new RegExp(pattern, flags);
+	    return { regexp, keys };
+	}
+	/**
+	 * Generate a flat list of sequence tokens from the given tokens.
+	 */
+	function* flatten(tokens, index, init) {
+	    if (index === tokens.length) {
+	        return yield init;
+	    }
+	    const token = tokens[index];
+	    if (token.type === "group") {
+	        const fork = init.slice();
+	        for (const seq of flatten(token.tokens, 0, fork)) {
+	            yield* flatten(tokens, index + 1, seq);
+	        }
+	    }
+	    else {
+	        init.push(token);
+	    }
+	    yield* flatten(tokens, index + 1, init);
+	}
+	/**
+	 * Transform a flat sequence of tokens into a regular expression.
+	 */
+	function sequenceToRegExp(tokens, delimiter, keys) {
+	    let result = "";
+	    let backtrack = "";
+	    let isSafeSegmentParam = true;
+	    for (let i = 0; i < tokens.length; i++) {
+	        const token = tokens[i];
+	        if (token.type === "text") {
+	            result += escape(token.value);
+	            backtrack += token.value;
+	            isSafeSegmentParam || (isSafeSegmentParam = token.value.includes(delimiter));
+	            continue;
+	        }
+	        if (token.type === "param" || token.type === "wildcard") {
+	            if (!isSafeSegmentParam && !backtrack) {
+	                throw new TypeError(`Missing text after "${token.name}": ${DEBUG_URL}`);
+	            }
+	            if (token.type === "param") {
+	                result += `(${negate(delimiter, isSafeSegmentParam ? "" : backtrack)}+)`;
+	            }
+	            else {
+	                result += `([\\s\\S]+)`;
+	            }
+	            keys.push(token);
+	            backtrack = "";
+	            isSafeSegmentParam = false;
+	            continue;
+	        }
+	    }
+	    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])`;
+	}
+	/**
+	 * Stringify token data into a path string.
+	 */
+	function stringify(data) {
+	    return data.tokens
+	        .map(function stringifyToken(token, index, tokens) {
+	        if (token.type === "text")
+	            return escapeText(token.value);
+	        if (token.type === "group") {
+	            return `{${token.tokens.map(stringifyToken).join("")}}`;
+	        }
+	        const isSafe = isNameSafe(token.name) && isNextNameSafe(tokens[index + 1]);
+	        const key = isSafe ? token.name : JSON.stringify(token.name);
+	        if (token.type === "param")
+	            return `:${key}`;
+	        if (token.type === "wildcard")
+	            return `*${key}`;
+	        throw new TypeError(`Unexpected token: ${token}`);
+	    })
+	        .join("");
+	}
+	function isNameSafe(name) {
+	    const [first, ...rest] = name;
+	    if (!ID_START.test(first))
+	        return false;
+	    return rest.every((char) => ID_CONTINUE.test(char));
+	}
+	function isNextNameSafe(token) {
+	    if ((token === null || token === void 0 ? void 0 : token.type) !== "text")
+	        return true;
+	    return !ID_CONTINUE.test(token.value[0]);
+	}
+	
+	return dist;
+}
+
+var distExports = requireDist();
+
+/**
+ * SimpleRouter
+ */
+class SimpleRouter {
+    routes = [];
+    constructor() {
+        // console.log('AppSimple initialized');
+    }
+    use(method, route, ...fns) {
+        const handlers = Array.isArray(fns) ? fns.flat() : [];
+        const pattern = distExports.pathToRegexp(route);
+        this.routes.push({ method: method.toLowerCase(), regexp: pattern.regexp, keys: pattern.keys, handlers });
+        return this;
+    }
+    get(route, ...fns) {
+        return this.use('get', route, ...fns);
+    }
+    post(route, ...fns) {
+        return this.use('post', route, ...fns);
+    }
+    parse(req, res) {
+        const { pathname } = new URL(req.url, 'http://localhost');
+        const method = req.method.toLowerCase();
+        const route = this.routes.find((route) => {
+            const matchResult = route.regexp.exec(pathname);
+            if (matchResult && route.method === method) {
+                const params = {};
+                route.keys.forEach((key, i) => {
+                    params[key.name] = matchResult[i + 1];
+                });
+                req.params = params;
+                return true;
+            }
+        });
+        if (route) {
+            const { handlers } = route;
+            return handlers.reduce((promiseChain, handler) => promiseChain.then(() => Promise.resolve(handler(req, res))), Promise.resolve());
+        }
+        if (!res?.headersSent && res && res?.end) {
+            res.statusCode = 404;
+            res.end('Not Found');
+        }
+        else {
+            console.error('Not Found');
+        }
+    }
+}
+
+export { SimpleRouter };

package/dist/router.d.ts

@@ -1,6 +1,7 @@
 import { Schema } from 'zod';
 export { Schema } from 'zod';
 import http, { IncomingMessage, ServerResponse } from 'http';
+import https from 'https';
 import { WebSocketServer, WebSocket } from 'ws';
 
 type BaseRule = {
@@ -190,6 +191,7 @@ declare class Route {
 declare class QueryRouter {
     routes: Route[];
     maxNextRoute: number;
+    context?: RouteContext;
     constructor();
     add(route: Route): void;
     /**
@@ -233,6 +235,7 @@ declare class QueryRouter {
     }, ctx?: RouteContext & {
         [key: string]: any;
     }): Promise<any>;
+    setContext(ctx: RouteContext): Promise<void>;
     getList(): RouteInfo[];
     getHandle<T = any>(router: QueryRouter, wrapperFn?: HandleFn<T>, ctx?: RouteContext): (msg: {
         path: string;
@@ -345,6 +348,9 @@ type ServerOpts = {
         [key: string]: any;
     }) => any;
     cors?: Cors;
+    isHTTPS?: boolean;
+    httpsKey?: string;
+    httpsCert?: string;
 };
 declare class Server {
     path: string;
@@ -353,6 +359,8 @@ declare class Server {
     private _callback;
     private cors;
     private hasOn;
+    private isHTTPS;
+    private options;
     constructor(opts?: ServerOpts);
     listen(port: number, hostname?: string, backlog?: number, listeningListener?: () => void): void;
     listen(port: number, hostname?: string, listeningListener?: () => void): void;
@@ -362,6 +370,7 @@ declare class Server {
     listen(path: string, listeningListener?: () => void): void;
     listen(handle: any, backlog?: number, listeningListener?: () => void): void;
     listen(handle: any, listeningListener?: () => void): void;
+    createServer(): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
     setHandle(handle?: any): void;
     /**
      * get callback
@@ -462,6 +471,9 @@ type AppOptions<T = {}> = {
         path?: string;
         cors?: Cors;
         handle?: any;
+        isHTTPS?: boolean;
+        httpsKey?: string;
+        httpsCert?: string;
     };
     io?: boolean;
     ioOpts?: {

package/dist/router.js

@@ -1,5 +1,6 @@
 import { webcrypto } from 'node:crypto';
 import http from 'http';
+import https from 'https';
 import url from 'url';
 import { WebSocketServer } from 'ws';
 
@@ -5659,6 +5660,7 @@ class Route {
 class QueryRouter {
     routes;
     maxNextRoute = 40;
+    context = {}; // default context for call
     constructor() {
         this.routes = [];
     }
@@ -5885,7 +5887,10 @@ class QueryRouter {
         return await this.runRoute(path, key, ctx);
     }
     async call(message, ctx) {
-        return await this.parse(message, ctx);
+        return await this.parse(message, { ...this.context, ...ctx });
+    }
+    async setContext(ctx) {
+        this.context = ctx;
     }
     getList() {
         return this.routes.map((r) => {
@@ -5930,6 +5935,7 @@ class QueryRouterServer extends QueryRouter {
     constructor(opts) {
         super();
         this.handle = this.getHandle(this, opts?.handleFn, opts?.context);
+        this.setContext(opts?.context);
     }
     setHandle(wrapperFn, ctx) {
         this.handle = this.getHandle(this, wrapperFn, ctx);
@@ -6129,17 +6135,46 @@ class Server {
     _callback;
     cors;
     hasOn = false;
+    isHTTPS = false;
+    options = {
+        key: '',
+        cert: '',
+    };
     constructor(opts) {
         this.path = opts?.path || '/api/router';
         this.handle = opts?.handle;
         this.cors = opts?.cors;
+        this.isHTTPS = opts?.isHTTPS || false;
+        this.options = {
+            key: opts?.httpsKey || '',
+            cert: opts?.httpsCert || '',
+        };
     }
     listen(...args) {
-        this._server = http.createServer();
+        this._server = this.createServer();
         const callback = this.createCallback();
         this._server.on('request', callback);
         this._server.listen(...args);
     }
+    createServer() {
+        let server;
+        if (this.isHTTPS) {
+            if (this.options.key && this.options.cert) {
+                server = https.createServer({
+                    key: this.options.key,
+                    cert: this.options.cert,
+                });
+                console.log('https server');
+                return server;
+            }
+            else {
+                console.error('https key and cert is required');
+                console.log('downgrade to http');
+            }
+        }
+        server = http.createServer();
+        return server;
+    }
     setHandle(handle) {
         this.handle = handle;
     }
@@ -6221,7 +6256,7 @@ class Server {
      * @param listener
      */
     on(listener) {
-        this._server = this._server || http.createServer();
+        this._server = this._server || this.createServer();
         this._server.removeAllListeners('request');
         this.hasOn = true;
         if (Array.isArray(listener)) {
@@ -6402,6 +6437,7 @@ class App {
         const router = opts?.router || new QueryRouter();
         const server = opts?.server || new Server(opts?.serverOptions || {});
         server.setHandle(router.getHandle(router, opts?.routerHandle, opts?.routerContext));
+        router.setContext(opts?.routerContext);
         this.router = router;
         this.server = server;
         if (opts?.io) {
@@ -6443,7 +6479,7 @@ class App {
     }
     async call(message, ctx) {
         const router = this.router;
-        return await router.parse(message, ctx);
+        return await router.call(message, ctx);
     }
     exportRoutes() {
         return this.router.exportRoutes();

package/package.json

@@ -1,7 +1,7 @@
 {
   "$schema": "https://json.schemastore.org/package",
   "name": "@kevisual/router",
-  "version": "0.0.4-alpha-7",
+  "version": "0.0.5-alpha-0",
   "description": "",
   "main": "dist/index.js",
   "module": "dist/index.js",
@@ -41,6 +41,8 @@
     "url": "git+https://github.com/abearxiong/kevisual-router.git"
   },
   "dependencies": {
+    "path-to-regexp": "^8.2.0",
+    "selfsigned": "^2.4.1",
     "ws": "^8.18.0"
   },
   "publishConfig": {
@@ -54,6 +56,14 @@
     "./browser": {
       "import": "./dist/router-browser.js",
       "require": "./dist/router-browser.js"
+    },
+    "./sign": {
+      "import": "./dist/router-sign.js",
+      "require": "./dist/router-sign.js"
+    },
+    "./simple": {
+      "import": "./dist/router-simple.js",
+      "require": "./dist/router-simple.js"
     }
   }
-}
+}