hono 2.1.4 → 2.2.1

package/dist/cjs/middleware/validator/validator.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VObject = exports.VBoolean = exports.VNumber = exports.VString = exports.VBase = exports.Validator = void 0;
+const json_1 = require("../../utils/json");
+const rule_1 = require("./rule");
+const sanitizer_1 = require("./sanitizer");
+class Validator {
+    constructor() {
+        this.query = (key) => new VString({ target: 'query', key: key });
+        this.header = (key) => new VString({ target: 'header', key: key });
+        this.body = (key) => new VString({ target: 'body', key: key });
+        this.json = (key) => new VString({ target: 'json', key: key });
+    }
+}
+exports.Validator = Validator;
+class VBase {
+    constructor(options) {
+        this.addRule = (rule) => {
+            this.rules.push(rule);
+            return this;
+        };
+        this.addSanitizer = (sanitizer) => {
+            this.sanitizers.push(sanitizer);
+            return this;
+        };
+        this.isRequired = () => {
+            return this.addRule((value) => {
+                if (value)
+                    return true;
+                return false;
+            });
+        };
+        this.isOptional = () => {
+            return this.addRule(() => true);
+        };
+        this.isEqual = (comparison) => {
+            return this.addRule((value) => {
+                return value === comparison;
+            });
+        };
+        this.asNumber = () => {
+            const newVNumber = new VNumber(this);
+            return newVNumber;
+        };
+        this.asBoolean = () => {
+            const newVBoolean = new VBoolean(this);
+            return newVBoolean;
+        };
+        this.asObject = () => {
+            const newVObject = new VObject(this);
+            return newVObject;
+        };
+        this.validate = async (req) => {
+            const result = {
+                isValid: true,
+                message: undefined,
+                target: this.target,
+                key: this.key,
+                value: undefined,
+            };
+            let value = undefined;
+            if (this.target === 'query') {
+                value = req.query(this.key);
+            }
+            if (this.target === 'header') {
+                value = req.header(this.key);
+            }
+            if (this.target === 'body') {
+                const body = await req.parseBody();
+                value = body[this.key];
+            }
+            if (this.target === 'json') {
+                const obj = await req.json();
+                value = (0, json_1.JSONPath)(obj, this.key);
+            }
+            result.value = value;
+            result.isValid = this.validateValue(value);
+            if (result.isValid == false) {
+                if (this._message) {
+                    result.message = this._message;
+                }
+                else {
+                    switch (this.target) {
+                        case 'query':
+                            result.message = `Invalid Value: the query parameter "${this.key}" is invalid - ${value}`;
+                            break;
+                        case 'header':
+                            result.message = `Invalid Value: the request header "${this.key}" is invalid - ${value}`;
+                            break;
+                        case 'body':
+                            result.message = `Invalid Value: the request body "${this.key}" is invalid - ${value}`;
+                            break;
+                        case 'json':
+                            result.message = `Invalid Value: the JSON body "${this.key}" is invalid - ${value}`;
+                            break;
+                    }
+                }
+            }
+            return result;
+        };
+        this.validateValue = (value) => {
+            // Check type
+            if (typeof value !== this.type) {
+                return false;
+            }
+            // Sanitize
+            for (const sanitizer of this.sanitizers) {
+                value = sanitizer(value);
+            }
+            for (const rule of this.rules) {
+                if (!rule(value)) {
+                    return false;
+                }
+            }
+            return true;
+        };
+        this.target = options.target;
+        this.key = options.key;
+        this.type = options.type || 'string';
+        this.rules = [];
+        this.sanitizers = [];
+    }
+    message(value) {
+        this._message = value;
+        return this;
+    }
+}
+exports.VBase = VBase;
+class VString extends VBase {
+    constructor(options) {
+        super(options);
+        this.isEmpty = (options = { ignore_whitespace: false }) => {
+            return this.addRule((value) => rule_1.rule.isEmpty(value, options));
+        };
+        this.isLength = (options, arg2) => {
+            return this.addRule((value) => rule_1.rule.isLength(value, options, arg2));
+        };
+        this.isAlpha = () => {
+            return this.addRule((value) => rule_1.rule.isAlpha(value));
+        };
+        this.isNumeric = () => {
+            return this.addRule((value) => rule_1.rule.isNumeric(value));
+        };
+        this.contains = (elem, options = {
+            ignoreCase: false,
+            minOccurrences: 1,
+        }) => {
+            return this.addRule((value) => rule_1.rule.contains(value, elem, options));
+        };
+        this.isIn = (options) => {
+            return this.addRule((value) => rule_1.rule.isIn(value, options));
+        };
+        this.match = (regExp) => {
+            return this.addRule((value) => rule_1.rule.match(value, regExp));
+        };
+        this.trim = () => {
+            return this.addSanitizer((value) => sanitizer_1.sanitizer.trim(value));
+        };
+        this.type = 'string';
+    }
+}
+exports.VString = VString;
+class VNumber extends VBase {
+    constructor(options) {
+        super(options);
+        this.isGte = (min) => {
+            return this.addRule((value) => rule_1.rule.isGte(value, min));
+        };
+        this.isLte = (min) => {
+            return this.addRule((value) => rule_1.rule.isLte(value, min));
+        };
+        this.type = 'number';
+    }
+}
+exports.VNumber = VNumber;
+class VBoolean extends VBase {
+    constructor(options) {
+        super(options);
+        this.isTrue = () => {
+            return this.addRule((value) => rule_1.rule.isTrue(value));
+        };
+        this.isFalse = () => {
+            return this.addRule((value) => rule_1.rule.isFalse(value));
+        };
+        this.type = 'boolean';
+    }
+}
+exports.VBoolean = VBoolean;
+class VObject extends VBase {
+    constructor(options) {
+        super(options);
+        this.type = 'object';
+    }
+}
+exports.VObject = VObject;

package/dist/cjs/request.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extendRequestPrototype = void 0;
+const body_1 = require("./utils/body");
+const cookie_1 = require("./utils/cookie");
+const url_1 = require("./utils/url");
+function extendRequestPrototype() {
+    if (!!Request.prototype.param) {
+        // already extended
+        return;
+    }
+    Request.prototype.param = function (key) {
+        if (this.paramData) {
+            if (key) {
+                return this.paramData[key];
+            }
+            else {
+                return this.paramData;
+            }
+        }
+        return null;
+    };
+    Request.prototype.header = function (name) {
+        if (!this.headerData) {
+            this.headerData = {};
+            for (const [key, value] of this.headers) {
+                this.headerData[key] = value;
+            }
+        }
+        if (name) {
+            return this.headerData[name.toLowerCase()];
+        }
+        else {
+            return this.headerData;
+        }
+    };
+    Request.prototype.query = function (key) {
+        const queryString = (0, url_1.getQueryStringFromURL)(this.url);
+        const searchParams = new URLSearchParams(queryString);
+        if (!this.queryData) {
+            this.queryData = {};
+            for (const key of searchParams.keys()) {
+                this.queryData[key] = searchParams.get(key) || '';
+            }
+        }
+        if (key) {
+            return this.queryData[key];
+        }
+        else {
+            return this.queryData;
+        }
+    };
+    Request.prototype.queries = function (key) {
+        const queryString = (0, url_1.getQueryStringFromURL)(this.url);
+        const searchParams = new URLSearchParams(queryString);
+        if (key) {
+            return searchParams.getAll(key);
+        }
+        else {
+            const result = {};
+            for (const key of searchParams.keys()) {
+                result[key] = searchParams.getAll(key);
+            }
+            return result;
+        }
+    };
+    Request.prototype.cookie = function (key) {
+        const cookie = this.headers.get('Cookie') || '';
+        const obj = (0, cookie_1.parse)(cookie);
+        if (key) {
+            const value = obj[key];
+            return value;
+        }
+        else {
+            return obj;
+        }
+    };
+    Request.prototype.parseBody = async function () {
+        // Cache the parsed body
+        let body;
+        if (!this.bodyData) {
+            body = await (0, body_1.parseBody)(this);
+            this.bodyData = body;
+        }
+        else {
+            body = this.bodyData;
+        }
+        return body;
+    };
+    Request.prototype.json = async function () {
+        // Cache the JSON body
+        let jsonData;
+        if (!this.jsonData) {
+            jsonData = JSON.parse(await this.text());
+            this.jsonData = jsonData;
+        }
+        else {
+            jsonData = this.jsonData;
+        }
+        return jsonData;
+    };
+    Request.prototype.valid = function (keys, value) {
+        var _a;
+        if (!this.data) {
+            this.data = {};
+        }
+        if (keys !== undefined) {
+            if (typeof keys === 'string') {
+                keys = [keys];
+            }
+            let data = this.data;
+            for (let i = 0; i < keys.length - 1; i++) {
+                data = data[_a = keys[i]] || (data[_a] = {});
+            }
+            data[keys[keys.length - 1]] = value;
+        }
+        return this.data;
+    };
+}
+exports.extendRequestPrototype = extendRequestPrototype;

package/dist/cjs/router/reg-exp-router/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegExpRouter = void 0;
+var router_1 = require("./router");
+Object.defineProperty(exports, "RegExpRouter", { enumerable: true, get: function () { return router_1.RegExpRouter; } });

package/dist/cjs/router/reg-exp-router/node.js

@@ -0,0 +1,108 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Node = exports.PATH_ERROR = void 0;
+const LABEL_REG_EXP_STR = '[^/]+';
+const ONLY_WILDCARD_REG_EXP_STR = '.*';
+const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)';
+exports.PATH_ERROR = Symbol();
+/**
+ * Sort order:
+ * 1. literal
+ * 2. special pattern (e.g. :label{[0-9]+})
+ * 3. common label pattern (e.g. :label)
+ * 4. wildcard
+ */
+function compareKey(a, b) {
+    if (a.length === 1) {
+        return b.length === 1 ? (a < b ? -1 : 1) : -1;
+    }
+    if (b.length === 1) {
+        return 1;
+    }
+    // wildcard
+    if (a === ONLY_WILDCARD_REG_EXP_STR || a === TAIL_WILDCARD_REG_EXP_STR) {
+        return 1;
+    }
+    else if (b === ONLY_WILDCARD_REG_EXP_STR || b === TAIL_WILDCARD_REG_EXP_STR) {
+        return -1;
+    }
+    // label
+    if (a === LABEL_REG_EXP_STR) {
+        return 1;
+    }
+    else if (b === LABEL_REG_EXP_STR) {
+        return -1;
+    }
+    return a.length === b.length ? (a < b ? -1 : 1) : b.length - a.length;
+}
+class Node {
+    constructor() {
+        this.children = {};
+    }
+    insert(tokens, index, paramMap, context) {
+        if (tokens.length === 0) {
+            if (this.index !== undefined) {
+                throw exports.PATH_ERROR;
+            }
+            this.index = index;
+            return;
+        }
+        const [token, ...restTokens] = tokens;
+        const pattern = token === '*'
+            ? restTokens.length === 0
+                ? ['', '', ONLY_WILDCARD_REG_EXP_STR] // '*' matches to all the trailing paths
+                : ['', '', LABEL_REG_EXP_STR]
+            : token === '/*'
+                ? ['', '', TAIL_WILDCARD_REG_EXP_STR] // '/path/to/*' is /\/path\/to(?:|/.*)$
+                : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+        let node;
+        if (pattern) {
+            const name = pattern[1];
+            const regexpStr = pattern[2] || LABEL_REG_EXP_STR;
+            node = this.children[regexpStr];
+            if (!node) {
+                if (Object.keys(this.children).some((k) => k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
+                    throw exports.PATH_ERROR;
+                }
+                node = this.children[regexpStr] = new Node();
+                if (name !== '') {
+                    node.varIndex = context.varIndex++;
+                }
+            }
+            if (name !== '') {
+                if (paramMap.some((p) => p[0] === name)) {
+                    throw new Error('Duplicate param name');
+                }
+                paramMap.push([name, node.varIndex]);
+            }
+        }
+        else {
+            node = this.children[token];
+            if (!node) {
+                if (Object.keys(this.children).some((k) => k.length > 1 && k !== ONLY_WILDCARD_REG_EXP_STR && k !== TAIL_WILDCARD_REG_EXP_STR)) {
+                    throw exports.PATH_ERROR;
+                }
+                node = this.children[token] = new Node();
+            }
+        }
+        node.insert(restTokens, index, paramMap, context);
+    }
+    buildRegExpStr() {
+        const childKeys = Object.keys(this.children).sort(compareKey);
+        const strList = childKeys.map((k) => {
+            const c = this.children[k];
+            return (typeof c.varIndex === 'number' ? `(${k})@${c.varIndex}` : k) + c.buildRegExpStr();
+        });
+        if (typeof this.index === 'number') {
+            strList.unshift(`#${this.index}`);
+        }
+        if (strList.length === 0) {
+            return '';
+        }
+        if (strList.length === 1) {
+            return strList[0];
+        }
+        return '(?:' + strList.join('|') + ')';
+    }
+}
+exports.Node = Node;

package/dist/cjs/router/reg-exp-router/router.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegExpRouter = void 0;
+const router_1 = require("../../router");
+const url_1 = require("../../utils/url");
+const node_1 = require("./node");
+const trie_1 = require("./trie");
+const METHOD_NAMES = [router_1.METHOD_NAME_ALL, ...router_1.METHODS].map((method) => method.toUpperCase());
+const emptyParam = {};
+const nullMatcher = [/^$/, []];
+function buildWildcardRegExp(path) {
+    return new RegExp(path === '*' ? '' : `^${path.replace(/\/\*/, '(?:|/.*)')}$`);
+}
+function buildMatcherFromPreprocessedRoutes(routes) {
+    const trie = new trie_1.Trie();
+    const handlers = [];
+    if (routes.length === 0) {
+        return nullMatcher;
+    }
+    for (let i = 0, len = routes.length; i < len; i++) {
+        let paramMap;
+        try {
+            paramMap = trie.insert(routes[i][0], i);
+        }
+        catch (e) {
+            throw e === node_1.PATH_ERROR ? new router_1.UnsupportedPathError(routes[i][0]) : e;
+        }
+        handlers[i] = [routes[i][1], paramMap.length !== 0 ? paramMap : null];
+    }
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (let i = 0, len = handlers.length; i < len; i++) {
+        const paramMap = handlers[i][1];
+        if (paramMap) {
+            for (let j = 0, len = paramMap.length; j < len; j++) {
+                paramMap[j][1] = paramReplacementMap[paramMap[j][1]];
+            }
+        }
+    }
+    const handlerMap = [];
+    // using `in` because indexReplacementMap is a sparse array
+    for (const i in indexReplacementMap) {
+        handlerMap[i] = handlers[indexReplacementMap[i]];
+    }
+    return [regexp, handlerMap];
+}
+function findMiddleware(middleware, path) {
+    if (!middleware) {
+        return undefined;
+    }
+    for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length)) {
+        if (buildWildcardRegExp(k).test(path)) {
+            return [...middleware[k]];
+        }
+    }
+    return undefined;
+}
+class RegExpRouter {
+    constructor() {
+        this.middleware = { [router_1.METHOD_NAME_ALL]: {} };
+        this.routes = { [router_1.METHOD_NAME_ALL]: {} };
+    }
+    add(method, path, handler) {
+        var _a, _b;
+        const { middleware, routes } = this;
+        if (!middleware || !routes) {
+            throw new Error('Can not add a route since the matcher is already built.');
+        }
+        if (path === '/*') {
+            path = '*';
+        }
+        if (/\*$/.test(path)) {
+            middleware[method] || (middleware[method] = {});
+            const re = buildWildcardRegExp(path);
+            (_a = middleware[method])[path] || (_a[path] = findMiddleware(middleware[router_1.METHOD_NAME_ALL], path) || []);
+            Object.keys(middleware).forEach((m) => {
+                if (method === router_1.METHOD_NAME_ALL || method === m) {
+                    Object.keys(middleware[m]).forEach((p) => {
+                        ;
+                        (path === '*' || path === p) && middleware[m][p].push(handler);
+                    });
+                }
+            });
+            Object.keys(routes).forEach((m) => {
+                if (method === router_1.METHOD_NAME_ALL || method === m) {
+                    Object.keys(routes[m]).forEach((p) => (path === '*' || re.test(p)) && routes[m][p].push(handler));
+                }
+            });
+            return;
+        }
+        const paths = (0, url_1.checkOptionalParameter)(path) || [path];
+        for (let i = 0, len = paths.length; i < len; i++) {
+            const path = paths[i];
+            routes[method] || (routes[method] = {});
+            (_b = routes[method])[path] || (_b[path] = [
+                ...(routes[router_1.METHOD_NAME_ALL][path] ||
+                    findMiddleware(middleware[method], path) ||
+                    findMiddleware(middleware[router_1.METHOD_NAME_ALL], path) ||
+                    []),
+            ]);
+            Object.keys(routes).forEach((m) => {
+                ;
+                (method === router_1.METHOD_NAME_ALL || method === m) &&
+                    routes[m][path] &&
+                    routes[m][path].push(handler);
+            });
+        }
+    }
+    match(method, path) {
+        const matchers = this.buildAllMatchers();
+        this.match = (method, path) => {
+            const matcher = matchers[method];
+            const match = path.match(matcher[0]);
+            if (!match) {
+                return null;
+            }
+            const index = match.indexOf('', 1);
+            const [handlers, paramMap] = matcher[1][index];
+            if (!paramMap) {
+                return { handlers, params: emptyParam };
+            }
+            const params = {};
+            for (let i = 0, len = paramMap.length; i < len; i++) {
+                params[paramMap[i][0]] = match[paramMap[i][1]];
+            }
+            return { handlers, params };
+        };
+        return this.match(method, path);
+    }
+    buildAllMatchers() {
+        const matchers = {};
+        METHOD_NAMES.forEach((method) => {
+            matchers[method] = this.buildMatcher(method) || matchers[router_1.METHOD_NAME_ALL];
+        });
+        // Release cache
+        this.middleware = this.routes = undefined;
+        return matchers;
+    }
+    buildMatcher(method) {
+        const routes = [];
+        let hasOwnRoute = method === router_1.METHOD_NAME_ALL;
+        [this.middleware, this.routes].forEach((r) => {
+            const ownRoute = r[method]
+                ? Object.keys(r[method]).map((path) => [path, r[method][path]])
+                : [];
+            if (ownRoute.length !== 0) {
+                hasOwnRoute || (hasOwnRoute = true);
+                routes.push(...ownRoute);
+            }
+            else if (method !== router_1.METHOD_NAME_ALL) {
+                routes.push(...Object.keys(r[router_1.METHOD_NAME_ALL]).map((path) => [path, r[router_1.METHOD_NAME_ALL][path]]));
+            }
+        });
+        if (!hasOwnRoute) {
+            return null;
+        }
+        else {
+            return buildMatcherFromPreprocessedRoutes(routes);
+        }
+    }
+}
+exports.RegExpRouter = RegExpRouter;

package/dist/cjs/router/reg-exp-router/trie.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Trie = void 0;
+const node_1 = require("./node");
+class Trie {
+    constructor() {
+        this.context = { varIndex: 0 };
+        this.root = new node_1.Node();
+    }
+    insert(path, index) {
+        const paramMap = [];
+        /**
+         *  - pattern (:label, :label{0-9]+}, ...)
+         *  - /* wildcard
+         *  - character
+         */
+        const tokens = path.match(/(?::[^\/]+)|(?:\/\*$)|./g);
+        // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+        // @ts-ignore
+        this.root.insert(tokens, index, paramMap, this.context);
+        return paramMap;
+    }
+    buildRegExp() {
+        let regexp = this.root.buildRegExpStr();
+        let captureIndex = 0;
+        const indexReplacementMap = [];
+        const paramReplacementMap = [];
+        regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+            if (typeof handlerIndex !== 'undefined') {
+                indexReplacementMap[++captureIndex] = Number(handlerIndex);
+                return '$()';
+            }
+            if (typeof paramIndex !== 'undefined') {
+                paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+                return '';
+            }
+            return '';
+        });
+        return [new RegExp(`^${regexp}`), indexReplacementMap, paramReplacementMap];
+    }
+}
+exports.Trie = Trie;

package/dist/cjs/router/smart-router/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartRouter = void 0;
+var router_1 = require("./router");
+Object.defineProperty(exports, "SmartRouter", { enumerable: true, get: function () { return router_1.SmartRouter; } });

package/dist/cjs/router/smart-router/router.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SmartRouter = void 0;
+const router_1 = require("../../router");
+class SmartRouter {
+    constructor(init) {
+        this.routers = [];
+        this.routes = [];
+        Object.assign(this, init);
+    }
+    add(method, path, handler) {
+        if (!this.routes) {
+            throw new Error('Can not add a route since the matcher is already built.');
+        }
+        this.routes.push([method, path, handler]);
+    }
+    match(method, path) {
+        if (!this.routes) {
+            throw new Error('Fatal error');
+        }
+        const { routers, routes } = this;
+        const len = routers.length;
+        let i = 0;
+        let res;
+        for (; i < len; i++) {
+            const router = routers[i];
+            try {
+                routes.forEach((args) => {
+                    router.add(...args);
+                });
+                res = router.match(method, path);
+            }
+            catch (e) {
+                if (e instanceof router_1.UnsupportedPathError) {
+                    continue;
+                }
+                throw e;
+            }
+            this.match = router.match.bind(router);
+            this.routers = [router];
+            this.routes = undefined;
+            break;
+        }
+        if (i === len) {
+            // not found
+            throw new Error('Fatal error');
+        }
+        return res || null;
+    }
+    get activeRouter() {
+        if (this.routes || this.routers.length !== 1) {
+            throw new Error('No active router has been determined yet.');
+        }
+        return this.routers[0];
+    }
+}
+exports.SmartRouter = SmartRouter;