hono 2.3.2 → 2.4.1

package/dist/middleware/validator/middleware.js

@@ -1,96 +1,111 @@
-import { getStatusText } from '../../utils/http-status';
-import { mergeObjects } from '../../utils/object';
-import { Validator, VBase, VObjectBase } from '../../validator/validator';
-export const validatorMiddleware = (validationFunction, options) => {
-    const v = new Validator();
-    const handler = async (c, next) => {
-        const resultSet = {
-            hasError: false,
-            messages: [],
-            results: [],
-        };
-        const schema = validationFunction(v, c);
-        const validatorList = getValidatorList(schema);
-        let data = {};
-        for (const [keys, validator] of validatorList) {
-            let results;
-            try {
-                results = await validator.validate(c.req);
-            }
-            catch (e) {
-                // Invalid JSON request
-                return c.text(getStatusText(400), 400);
-            }
-            let isValid = true;
-            const value = results[0].value;
-            const jsonData = results[0].jsonData;
-            for (const result of results) {
-                if (!result.isValid) {
-                    isValid = false;
-                    resultSet.hasError = true;
-                    if (result.ruleType === 'value' && result.message !== undefined) {
-                        resultSet.messages.push(result.message);
-                    }
-                }
-                resultSet.results.push(result);
-            }
-            // If it's invalid but it has no "value" messages, have to set the "type" messages.
-            // This approach is verbose, but if do not so, the response body will be empty.
-            if (!isValid && resultSet.messages.length === 0) {
-                resultSet.results.map((r) => {
-                    if (!r.isValid && r.ruleType === 'type' && r.message) {
-                        resultSet.messages.push(r.message);
-                    }
-                });
-            }
-            // Set data on request object
-            if (isValid) {
-                // Set data on request object
-                if (jsonData) {
-                    const dst = data;
-                    data = mergeObjects(dst, jsonData);
-                }
-                else {
-                    c.req.valid(keys, value);
-                }
-            }
-        }
-        if (!resultSet.hasError) {
-            Object.keys(data).map((key) => {
-                c.req.valid(key, data[key]);
-            });
+// src/middleware/validator/middleware.ts
+import { getStatusText } from "../../utils/http-status.js";
+import { mergeObjects } from "../../utils/object.js";
+import { Validator, VBase, VObjectBase } from "../../validator/validator.js";
+var validatorMiddleware = (validationFunction, options) => {
+  const v = new Validator();
+  const handler = async (c, next) => {
+    const resultSet = {
+      hasError: false,
+      messages: [],
+      results: []
+    };
+    const schema = validationFunction(v, c);
+    const validatorList = getValidatorList(schema);
+    let data = {};
+    for (const [keys, validator] of validatorList) {
+      let results;
+      try {
+        results = await validator.validate(c.req);
+      } catch (e) {
+        if (e instanceof Error) {
+          const result = getErrorResult(e);
+          resultSet.hasError = true;
+          resultSet.messages = [result.message || ""];
+          resultSet.results = [result];
+          break;
+        } else {
+          return c.text(getStatusText(400), 400);
         }
-        if (options && options.done) {
-            const res = options.done(resultSet, c);
-            if (res) {
-                return res;
-            }
+      }
+      let isValid = true;
+      const value = results[0].value;
+      const jsonData = results[0].jsonData;
+      for (const result of results) {
+        if (!result.isValid) {
+          isValid = false;
+          resultSet.hasError = true;
+          if (result.ruleType === "value" && result.message !== void 0) {
+            resultSet.messages.push(result.message);
+          }
         }
-        if (resultSet.hasError) {
-            return c.text(resultSet.messages.join('\n'), 400);
+        resultSet.results.push(result);
+      }
+      if (!isValid && resultSet.messages.length === 0) {
+        resultSet.results.map((r) => {
+          if (!r.isValid && r.ruleType === "type" && r.message) {
+            resultSet.messages.push(r.message);
+          }
+        });
+      }
+      if (isValid) {
+        if (jsonData) {
+          const dst = data;
+          data = mergeObjects(dst, jsonData);
+        } else {
+          c.req.valid(keys, value);
         }
-        await next();
-    };
-    return handler;
+      }
+    }
+    if (!resultSet.hasError) {
+      Object.keys(data).map((key) => {
+        c.req.valid(key, data[key]);
+      });
+    }
+    if (options && options.done) {
+      const res = options.done(resultSet, c);
+      if (res) {
+        return res;
+      }
+    }
+    if (resultSet.hasError) {
+      return c.text(resultSet.messages.join("\n"), 400);
+    }
+    await next();
+  };
+  return handler;
 };
 function getValidatorList(schema) {
-    const map = [];
-    for (const [key, value] of Object.entries(schema)) {
-        if (value instanceof VObjectBase) {
-            const validators = value.getValidators();
-            for (const validator of validators) {
-                map.push([value.keys, validator]);
-            }
-        }
-        else if (value instanceof VBase) {
-            map.push([[key], value]);
-        }
-        else {
-            const children = getValidatorList(value);
-            for (const [keys, validator] of children) {
-                map.push([[key, ...keys], validator]);
-            }
-        }
+  const map = [];
+  for (const [key, value] of Object.entries(schema)) {
+    if (value instanceof VObjectBase) {
+      const validators = value.getValidators();
+      for (const validator of validators) {
+        map.push([value.keys, validator]);
+      }
+    } else if (value instanceof VBase) {
+      map.push([[key], value]);
+    } else {
+      const children = getValidatorList(value);
+      for (const [keys, validator] of children) {
+        map.push([[key, ...keys], validator]);
+      }
     }
-    return map;
+  }
+  return map;
 }
+var getErrorResult = (e) => {
+  const result = {
+    isValid: false,
+    message: e.message,
+    target: "unknown",
+    key: null,
+    value: null,
+    ruleName: e.message,
+    ruleType: "value"
+  };
+  return result;
+};
+export {
+  validatorMiddleware
+};

package/dist/request.js

@@ -1,116 +1,110 @@
-import { parseBody } from './utils/body';
-import { parse } from './utils/cookie';
-import { getQueryStringFromURL } from './utils/url';
-export function extendRequestPrototype() {
-    if (!!Request.prototype.param) {
-        // already extended
-        return;
+// src/request.ts
+import { parseBody } from "./utils/body.js";
+import { parse } from "./utils/cookie.js";
+import { getQueryStringFromURL } from "./utils/url.js";
+function extendRequestPrototype() {
+  if (!!Request.prototype.param) {
+    return;
+  }
+  Request.prototype.param = function(key) {
+    if (this.paramData) {
+      if (key) {
+        return this.paramData[key];
+      } else {
+        return this.paramData;
+      }
     }
-    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 = 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 = 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 = 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 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;
-    };
+    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 = getQueryStringFromURL(this.url);
+    const searchParams = new URLSearchParams(queryString);
+    if (!this.queryData) {
+      this.queryData = {};
+      for (const key2 of searchParams.keys()) {
+        this.queryData[key2] = searchParams.get(key2) || "";
+      }
+    }
+    if (key) {
+      return this.queryData[key];
+    } else {
+      return this.queryData;
+    }
+  };
+  Request.prototype.queries = function(key) {
+    const queryString = getQueryStringFromURL(this.url);
+    const searchParams = new URLSearchParams(queryString);
+    if (key) {
+      return searchParams.getAll(key);
+    } else {
+      const result = {};
+      for (const key2 of searchParams.keys()) {
+        result[key2] = searchParams.getAll(key2);
+      }
+      return result;
+    }
+  };
+  Request.prototype.cookie = function(key) {
+    const cookie = this.headers.get("Cookie") || "";
+    const obj = parse(cookie);
+    if (key) {
+      const value = obj[key];
+      return value;
+    } else {
+      return obj;
+    }
+  };
+  Request.prototype.parseBody = async function() {
+    let body;
+    if (!this.bodyData) {
+      body = await parseBody(this);
+      this.bodyData = body;
+    } else {
+      body = this.bodyData;
+    }
+    return body;
+  };
+  Request.prototype.json = async function() {
+    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 !== void 0) {
+      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;
+  };
 }
+export {
+  extendRequestPrototype
+};

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

@@ -1 +1,5 @@
-export { RegExpRouter } from './router';
+// src/router/reg-exp-router/index.ts
+import { RegExpRouter } from "./router.js";
+export {
+  RegExpRouter
+};

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

@@ -1,104 +1,95 @@
-const LABEL_REG_EXP_STR = '[^/]+';
-const ONLY_WILDCARD_REG_EXP_STR = '.*';
-const TAIL_WILDCARD_REG_EXP_STR = '(?:|/.*)';
-export const PATH_ERROR = Symbol();
-/**
- * Sort order:
- * 1. literal
- * 2. special pattern (e.g. :label{[0-9]+})
- * 3. common label pattern (e.g. :label)
- * 4. wildcard
- */
+// src/router/reg-exp-router/node.ts
+var LABEL_REG_EXP_STR = "[^/]+";
+var ONLY_WILDCARD_REG_EXP_STR = ".*";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = Symbol();
 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;
+  if (a.length === 1) {
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  }
+  if (b.length === 1) {
+    return 1;
+  }
+  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;
+  }
+  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;
 }
-export class Node {
-    constructor() {
-        this.children = {};
+var Node = class {
+  constructor() {
+    this.children = {};
+  }
+  insert(tokens, index, paramMap, context) {
+    if (tokens.length === 0) {
+      if (this.index !== void 0) {
+        throw PATH_ERROR;
+      }
+      this.index = index;
+      return;
     }
-    insert(tokens, index, paramMap, context) {
-        if (tokens.length === 0) {
-            if (this.index !== undefined) {
-                throw PATH_ERROR;
-            }
-            this.index = index;
-            return;
+    const [token, ...restTokens] = tokens;
+    const pattern = token === "*" ? restTokens.length === 0 ? ["", "", ONLY_WILDCARD_REG_EXP_STR] : ["", "", LABEL_REG_EXP_STR] : token === "/*" ? ["", "", TAIL_WILDCARD_REG_EXP_STR] : 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 PATH_ERROR;
         }
-        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 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]);
-            }
+        node = this.children[regexpStr] = new Node();
+        if (name !== "") {
+          node.varIndex = context.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 PATH_ERROR;
-                }
-                node = this.children[token] = new Node();
-            }
+      }
+      if (name !== "") {
+        if (paramMap.some((p) => p[0] === name)) {
+          throw new Error("Duplicate param name");
         }
-        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}`);
+        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 PATH_ERROR;
         }
-        if (strList.length === 0) {
-            return '';
-        }
-        if (strList.length === 1) {
-            return strList[0];
-        }
-        return '(?:' + strList.join('|') + ')';
+        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("|") + ")";
+  }
+};
+export {
+  Node,
+  PATH_ERROR
+};