hono 2.3.2 → 2.4.0

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

@@ -1,100 +1,134 @@
 "use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validatorMiddleware = void 0;
-const http_status_1 = require("../../utils/http-status");
-const object_1 = require("../../utils/object");
-const validator_1 = require("../../validator/validator");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var middleware_exports = {};
+__export(middleware_exports, {
+  validatorMiddleware: () => validatorMiddleware
+});
+module.exports = __toCommonJS(middleware_exports);
+var import_http_status = require("../../utils/http-status");
+var import_object = require("../../utils/object");
+var import_validator = require("../../validator/validator");
 const validatorMiddleware = (validationFunction, options) => {
-    const v = new validator_1.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((0, http_status_1.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 = (0, object_1.mergeObjects)(dst, jsonData);
-                }
-                else {
-                    c.req.valid(keys, value);
-                }
-            }
-        }
-        if (!resultSet.hasError) {
-            Object.keys(data).map((key) => {
-                c.req.valid(key, data[key]);
-            });
+  const v = new import_validator.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((0, import_http_status.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 = (0, import_object.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;
 };
-exports.validatorMiddleware = validatorMiddleware;
 function getValidatorList(schema) {
-    const map = [];
-    for (const [key, value] of Object.entries(schema)) {
-        if (value instanceof validator_1.VObjectBase) {
-            const validators = value.getValidators();
-            for (const validator of validators) {
-                map.push([value.keys, validator]);
-            }
-        }
-        else if (value instanceof validator_1.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 import_validator.VObjectBase) {
+      const validators = value.getValidators();
+      for (const validator of validators) {
+        map.push([value.keys, validator]);
+      }
+    } else if (value instanceof import_validator.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;
 }
+const getErrorResult = (e) => {
+  const result = {
+    isValid: false,
+    message: e.message,
+    target: "unknown",
+    key: null,
+    value: null,
+    ruleName: e.message,
+    ruleType: "value"
+  };
+  return result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  validatorMiddleware
+});

package/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/cjs/request.js

@@ -1,120 +1,133 @@
 "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");
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var request_exports = {};
+__export(request_exports, {
+  extendRequestPrototype: () => extendRequestPrototype
+});
+module.exports = __toCommonJS(request_exports);
+var import_body = require("./utils/body");
+var import_cookie = require("./utils/cookie");
+var import_url = require("./utils/url");
 function extendRequestPrototype() {
-    if (!!Request.prototype.param) {
-        // already extended
-        return;
+  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 = (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;
-    };
+    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, import_url.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 = (0, import_url.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 = (0, import_cookie.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 (0, import_body.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;
+  };
 }
-exports.extendRequestPrototype = extendRequestPrototype;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  extendRequestPrototype
+});

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

@@ -1,5 +1,28 @@
 "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; } });
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var reg_exp_router_exports = {};
+__export(reg_exp_router_exports, {
+  RegExpRouter: () => import_router.RegExpRouter
+});
+module.exports = __toCommonJS(reg_exp_router_exports);
+var import_router = require("./router");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RegExpRouter
+});