better-call 0.2.10 → 0.2.13-beta.1

package/dist/index.cjs

@@ -1,291 +1,137 @@
-"use strict";
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+'use strict';
+
+const crypto = require('uncrypto');
+const rou3 = require('rou3');
+
+function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
-// node_modules/set-cookie-parser/lib/set-cookie.js
-var require_set_cookie = __commonJS({
-  "node_modules/set-cookie-parser/lib/set-cookie.js"(exports2, module2) {
-    "use strict";
-    var defaultParseOptions = {
-      decodeValues: true,
-      map: false,
-      silent: false
+const crypto__default = /*#__PURE__*/_interopDefaultCompat(crypto);
+
+function createJSON({
+  asResponse,
+  response
+}) {
+  return async function json(json, routerResponse) {
+    if (!asResponse) {
+      return json;
+    }
+    return {
+      body: json,
+      routerResponse,
+      _flag: "json"
     };
-    function isNonEmptyString(str) {
-      return typeof str === "string" && !!str.trim();
-    }
-    function parseString(setCookieValue, options) {
-      var parts = setCookieValue.split(";").filter(isNonEmptyString);
-      var nameValuePairStr = parts.shift();
-      var parsed = parseNameValuePair(nameValuePairStr);
-      var name = parsed.name;
-      var value = parsed.value;
-      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-      try {
-        value = options.decodeValues ? decodeURIComponent(value) : value;
-      } catch (e) {
-        console.error(
-          "set-cookie-parser encountered an error while decoding a cookie with value '" + value + "'. Set options.decodeValues to false to disable this feature.",
-          e
-        );
-      }
-      var cookie = {
-        name,
-        value
+  };
+}
+function runValidation(options, context) {
+  let request = {
+    body: void 0,
+    query: void 0
+  };
+  if (options.body) {
+    const result = options.body.safeParse(context.body);
+    if (result.error) {
+      return {
+        data: null,
+        error: fromError(result.error)
       };
-      parts.forEach(function(part) {
-        var sides = part.split("=");
-        var key = sides.shift().trimLeft().toLowerCase();
-        var value2 = sides.join("=");
-        if (key === "expires") {
-          cookie.expires = new Date(value2);
-        } else if (key === "max-age") {
-          cookie.maxAge = parseInt(value2, 10);
-        } else if (key === "secure") {
-          cookie.secure = true;
-        } else if (key === "httponly") {
-          cookie.httpOnly = true;
-        } else if (key === "samesite") {
-          cookie.sameSite = value2;
-        } else if (key === "partitioned") {
-          cookie.partitioned = true;
-        } else {
-          cookie[key] = value2;
-        }
-      });
-      return cookie;
-    }
-    function parseNameValuePair(nameValuePairStr) {
-      var name = "";
-      var value = "";
-      var nameValueArr = nameValuePairStr.split("=");
-      if (nameValueArr.length > 1) {
-        name = nameValueArr.shift();
-        value = nameValueArr.join("=");
-      } else {
-        value = nameValuePairStr;
-      }
-      return { name, value };
     }
-    function parse2(input, options) {
-      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-      if (!input) {
-        if (!options.map) {
-          return [];
-        } else {
-          return {};
-        }
-      }
-      if (input.headers) {
-        if (typeof input.headers.getSetCookie === "function") {
-          input = input.headers.getSetCookie();
-        } else if (input.headers["set-cookie"]) {
-          input = input.headers["set-cookie"];
-        } else {
-          var sch = input.headers[Object.keys(input.headers).find(function(key) {
-            return key.toLowerCase() === "set-cookie";
-          })];
-          if (!sch && input.headers.cookie && !options.silent) {
-            console.warn(
-              "Warning: set-cookie-parser appears to have been called on a request object. It is designed to parse Set-Cookie headers from responses, not Cookie headers from requests. Set the option {silent: true} to suppress this warning."
-            );
-          }
-          input = sch;
-        }
-      }
-      if (!Array.isArray(input)) {
-        input = [input];
-      }
-      options = options ? Object.assign({}, defaultParseOptions, options) : defaultParseOptions;
-      if (!options.map) {
-        return input.filter(isNonEmptyString).map(function(str) {
-          return parseString(str, options);
-        });
-      } else {
-        var cookies = {};
-        return input.filter(isNonEmptyString).reduce(function(cookies2, str) {
-          var cookie = parseString(str, options);
-          cookies2[cookie.name] = cookie;
-          return cookies2;
-        }, cookies);
-      }
+    request.body = result.data;
+  }
+  if (options.query) {
+    const result = options.query.safeParse(context.query);
+    if (result.error) {
+      return {
+        data: null,
+        error: fromError(result.error)
+      };
     }
-    function splitCookiesString2(cookiesString) {
-      if (Array.isArray(cookiesString)) {
-        return cookiesString;
-      }
-      if (typeof cookiesString !== "string") {
-        return [];
-      }
-      var cookiesStrings = [];
-      var pos = 0;
-      var start;
-      var ch;
-      var lastComma;
-      var nextStart;
-      var cookiesSeparatorFound;
-      function skipWhitespace() {
-        while (pos < cookiesString.length && /\s/.test(cookiesString.charAt(pos))) {
-          pos += 1;
-        }
-        return pos < cookiesString.length;
-      }
-      function notSpecialChar() {
-        ch = cookiesString.charAt(pos);
-        return ch !== "=" && ch !== ";" && ch !== ",";
-      }
-      while (pos < cookiesString.length) {
-        start = pos;
-        cookiesSeparatorFound = false;
-        while (skipWhitespace()) {
-          ch = cookiesString.charAt(pos);
-          if (ch === ",") {
-            lastComma = pos;
-            pos += 1;
-            skipWhitespace();
-            nextStart = pos;
-            while (pos < cookiesString.length && notSpecialChar()) {
-              pos += 1;
-            }
-            if (pos < cookiesString.length && cookiesString.charAt(pos) === "=") {
-              cookiesSeparatorFound = true;
-              pos = nextStart;
-              cookiesStrings.push(cookiesString.substring(start, lastComma));
-              start = pos;
-            } else {
-              pos = lastComma + 1;
-            }
-          } else {
-            pos += 1;
-          }
-        }
-        if (!cookiesSeparatorFound || pos >= cookiesString.length) {
-          cookiesStrings.push(cookiesString.substring(start, cookiesString.length));
-        }
-      }
-      return cookiesStrings;
+    request.query = result.data;
+  }
+  if (options.requireHeaders && !(context.headers instanceof Headers)) {
+    return {
+      data: null,
+      error: { message: "Validation Error: Headers are required" }
+    };
+  }
+  if (options.requireRequest && !context.request) {
+    return {
+      data: null,
+      error: { message: "Validation Error: Request is required" }
+    };
+  }
+  return {
+    data: request,
+    error: null
+  };
+}
+function fromError(error) {
+  const errorMessages = [];
+  for (const issue of error.issues) {
+    const path = issue.path.join(".");
+    const message = issue.message;
+    if (path) {
+      errorMessages.push(`${message} at "${path}"`);
+    } else {
+      errorMessages.push(message);
     }
-    module2.exports = parse2;
-    module2.exports.parse = parse2;
-    module2.exports.parseString = parseString;
-    module2.exports.splitCookiesString = splitCookiesString2;
   }
-});
-
-// src/index.ts
-var src_exports = {};
-__export(src_exports, {
-  APIError: () => APIError,
-  createEndpoint: () => createEndpoint,
-  createEndpointCreator: () => createEndpointCreator,
-  createMiddleware: () => createMiddleware,
-  createMiddlewareCreator: () => createMiddlewareCreator,
-  createRouter: () => createRouter,
-  getBody: () => getBody,
-  getCookie: () => getCookie,
-  getRequest: () => getRequest,
-  getSignedCookie: () => getSignedCookie,
-  parse: () => parse,
-  parseSigned: () => parseSigned,
-  serialize: () => serialize,
-  serializeSigned: () => serializeSigned,
-  setCookie: () => setCookie,
-  setResponse: () => setResponse,
-  setSignedCookie: () => setSignedCookie,
-  shouldSerialize: () => shouldSerialize,
-  statusCode: () => statusCode,
-  toNodeHandler: () => toNodeHandler
-});
-module.exports = __toCommonJS(src_exports);
+  return {
+    message: `Validation error: ${errorMessages.join(", ")}`
+  };
+}
 
-// src/endpoint.ts
-var import_zod = require("zod");
+function createSetHeader(headers) {
+  return (key, value) => {
+    headers.set(key, value);
+  };
+}
+function createGetHeader(headers) {
+  return (key) => {
+    return headers.get(key);
+  };
+}
 
-// src/error.ts
-var APIError = class extends Error {
-  constructor(status, body, headers) {
-    super(`API Error: ${status} ${body?.message ?? ""}`, {
-      cause: body
-    });
-    __publicField(this, "status");
-    __publicField(this, "headers");
-    __publicField(this, "body");
+class APIError extends Error {
+  constructor(message, status = 500, code = "INTERNAL_SERVER_ERROR", headers = {}) {
+    super(message);
+    this.message = message;
     this.status = status;
-    this.body = body ?? {};
+    this.code = code;
+    this.headers = headers;
+    this.name = "APIError";
+    this.message = message;
+    this.status = status;
+    this.code = code;
+    this.headers = headers;
     this.stack = "";
-    this.headers = headers || new Headers();
-    this.name = "BetterCallAPIError";
   }
-};
-
-// src/helper.ts
-var json = (body, option) => {
-  return {
-    response: {
-      body: option?.body ?? body,
-      status: option?.status ?? 200,
-      statusText: option?.statusText ?? "OK",
-      headers: option?.headers
-    },
-    body,
-    _flag: "json"
-  };
-};
+}
 
-// src/cookie.ts
-var import_uncrypto = __toESM(require("uncrypto"), 1);
-var algorithm = { name: "HMAC", hash: "SHA-256" };
-var getCryptoKey = async (secret) => {
+const algorithm = { name: "HMAC", hash: "SHA-256" };
+const getCryptoKey = async (secret) => {
   const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
-  return await import_uncrypto.default.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+  return await crypto__default.subtle.importKey("raw", secretBuf, algorithm, false, [
+    "sign",
+    "verify"
+  ]);
 };
-var makeSignature = async (value, secret) => {
+const makeSignature = async (value, secret) => {
   const key = await getCryptoKey(secret);
-  const signature = await import_uncrypto.default.subtle.sign(
+  const signature = await crypto__default.subtle.sign(
     algorithm.name,
     key,
     new TextEncoder().encode(value)
   );
   return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
-var verifySignature = async (base64Signature, value, secret) => {
+const verifySignature = async (base64Signature, value, secret) => {
   try {
     const signatureBinStr = atob(base64Signature);
     const signature = new Uint8Array(signatureBinStr.length);
     for (let i = 0, len = signatureBinStr.length; i < len; i++) {
       signature[i] = signatureBinStr.charCodeAt(i);
     }
-    return await import_uncrypto.default.subtle.verify(
+    return await crypto__default.subtle.verify(
       algorithm,
       secret,
       signature,
@@ -295,9 +141,9 @@ var verifySignature = async (base64Signature, value, secret) => {
     return false;
   }
 };
-var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-var parse = (cookie, name) => {
+const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+const parse = (cookie, name) => {
   const pairs = cookie.trim().split(";");
   return pairs.reduce((parsedCookie, pairStr) => {
     pairStr = pairStr.trim();
@@ -319,7 +165,7 @@ var parse = (cookie, name) => {
     return parsedCookie;
   }, {});
 };
-var parseSigned = async (cookie, secret, name) => {
+const parseSigned = async (cookie, secret, name) => {
   const parsedCookie = {};
   const secretKey = await getCryptoKey(secret);
   for (const [key, value] of Object.entries(parse(cookie, name))) {
@@ -337,7 +183,7 @@ var parseSigned = async (cookie, secret, name) => {
   }
   return parsedCookie;
 };
-var _serialize = (name, value, opt = {}) => {
+const _serialize = (name, value, opt = {}) => {
   let cookie = `${name}=${value}`;
   if (name.startsWith("__Secure-") && !opt.secure) {
     opt.secure = true;
@@ -392,19 +238,18 @@ var _serialize = (name, value, opt = {}) => {
   }
   return cookie;
 };
-var serialize = (name, value, opt) => {
+const serialize = (name, value, opt) => {
   value = encodeURIComponent(value);
   return _serialize(name, value, opt);
 };
-var serializeSigned = async (name, value, secret, opt = {}) => {
+const serializeSigned = async (name, value, secret, opt = {}) => {
   const signature = await makeSignature(value, secret);
   value = `${value}.${signature}`;
   value = encodeURIComponent(value);
   return _serialize(name, value, opt);
 };
 
-// src/cookie-utils.ts
-var getCookie = (cookie, key, prefix) => {
+const getCookie = (cookie, key, prefix) => {
   if (!cookie) {
     return void 0;
   }
@@ -421,17 +266,23 @@ var getCookie = (cookie, key, prefix) => {
   const obj = parse(cookie, finalKey);
   return obj[finalKey];
 };
-var setCookie = (header, name, value, opt) => {
+const setCookie = (header, name, value, opt) => {
   const existingCookies = header.get("Set-Cookie");
   if (existingCookies) {
     const cookies = existingCookies.split(", ");
-    const updatedCookies = cookies.filter((cookie2) => !cookie2.startsWith(`${name}=`));
+    const updatedCookies = cookies.filter(
+      (cookie2) => !cookie2.startsWith(`${name}=`)
+    );
     header.delete("Set-Cookie");
     updatedCookies.forEach((cookie2) => header.append("Set-Cookie", cookie2));
   }
   let cookie;
   if (opt?.prefix === "secure") {
-    cookie = serialize("__Secure-" + name, value, { path: "/", ...opt, secure: true });
+    cookie = serialize("__Secure-" + name, value, {
+      path: "/",
+      ...opt,
+      secure: true
+    });
   } else if (opt?.prefix === "host") {
     cookie = serialize("__Host-" + name, value, {
       ...opt,
@@ -444,7 +295,7 @@ var setCookie = (header, name, value, opt) => {
   }
   header.append("Set-Cookie", cookie);
 };
-var setSignedCookie = async (header, name, value, secret, opt) => {
+const setSignedCookie = async (header, name, value, secret, opt) => {
   let cookie;
   if (opt?.prefix === "secure") {
     cookie = await serializeSigned("__Secure-" + name, value, secret, {
@@ -464,7 +315,7 @@ var setSignedCookie = async (header, name, value, secret, opt) => {
   }
   header.append("Set-Cookie", cookie);
 };
-var getSignedCookie = async (header, secret, key, prefix) => {
+const getSignedCookie = async (header, secret, key, prefix) => {
   const cookie = header.get("cookie");
   if (!cookie) {
     return void 0;
@@ -481,162 +332,127 @@ var getSignedCookie = async (header, secret, key, prefix) => {
   return obj[finalKey];
 };
 
-// src/endpoint.ts
-function createEndpointCreator(opts) {
-  return (path, options, handler) => {
-    return createEndpoint(
-      path,
+const createResponse = (handlerResponse, response) => {
+  if (handlerResponse instanceof Response) {
+    response.headers.forEach((value, key) => {
+      handlerResponse.headers.set(key, value);
+    });
+    return handlerResponse;
+  } else if (handlerResponse?._flag === "json") {
+    const responseObj = new Response(
+      JSON.stringify(
+        handlerResponse.routerResponse?.body || handlerResponse.body
+      ),
       {
-        ...options,
-        use: [...options?.use || [], ...opts?.use || []]
-      },
-      handler
+        status: handlerResponse.routerResponse?.status || 200,
+        headers: handlerResponse.routerResponse?.headers
+      }
     );
-  };
-}
-function createEndpoint(path, options, handler) {
-  let responseHeader = new Headers();
-  const handle = async (...ctx) => {
-    let internalCtx = {
-      setHeader(key, value) {
-        responseHeader.set(key, value);
+    response.headers.forEach((value, key) => {
+      responseObj.headers.set(key, value);
+    });
+    return responseObj;
+  } else {
+    const responseObj = new Response(
+      handlerResponse ? JSON.stringify(handlerResponse) : void 0
+    );
+    response.headers.forEach((value, key) => {
+      responseObj.headers.set(key, value);
+    });
+    return responseObj;
+  }
+};
+const runMiddleware = async (options, context) => {
+  let finalContext = {};
+  for (const middleware of options.use || []) {
+    const result = await middleware(context);
+    if (result?.context && result._flag === "context") {
+      context = { ...context, ...result.context };
+    } else {
+      finalContext = { ...result, ...finalContext };
+      context.context = finalContext;
+    }
+  }
+  return finalContext;
+};
+const createEndpoint = (path, options, handler) => {
+  const internalHandler = async (...inputCtx) => {
+    let response = new Response();
+    const { asResponse, ...ctx } = inputCtx[0] || {};
+    const { data, error } = runValidation(options, ctx);
+    if (error) {
+      throw new APIError(error.message, 400);
+    }
+    const context = {
+      json: createJSON({
+        asResponse,
+        response
+      }),
+      body: "body" in data ? data.body : void 0,
+      path,
+      method: "method" in ctx ? ctx.method : void 0,
+      query: "query" in data ? data.query : void 0,
+      params: "params" in ctx ? ctx.params : void 0,
+      headers: "headers" in ctx ? ctx.headers : void 0,
+      request: "request" in ctx ? ctx.request : void 0,
+      setHeader: createSetHeader(response.headers),
+      getHeader: (key) => {
+        const requestHeaders = "headers" in ctx && ctx.headers instanceof Headers ? ctx.headers : "request" in ctx && ctx.request instanceof Request ? ctx.request.headers : null;
+        if (!requestHeaders)
+          return null;
+        return requestHeaders.get(key);
       },
-      setCookie(key, value, options2) {
-        setCookie(responseHeader, key, value, options2);
+      setCookie: (name, value, options2) => {
+        setCookie(response.headers, name, value, options2);
       },
       getCookie(key, prefix) {
-        const header = ctx[0]?.headers;
-        const cookieH = header?.get("cookie");
-        const cookie = getCookie(cookieH || "", key, prefix);
-        return cookie;
+        const headers = context.headers?.get("cookie");
+        if (!headers)
+          return void 0;
+        return getCookie(headers, key, prefix);
       },
-      getSignedCookie(key, secret, prefix) {
-        const header = ctx[0]?.headers;
-        if (!header) {
-          throw new TypeError("Headers are required");
-        }
-        const cookie = getSignedCookie(header, secret, key, prefix);
-        return cookie;
+      setSignedCookie(key, value, secret, options2) {
+        return setSignedCookie(response.headers, key, value, secret, options2);
       },
-      async setSignedCookie(key, value, secret, options2) {
-        await setSignedCookie(responseHeader, key, value, secret, options2);
+      async getSignedCookie(key, secret, prefix) {
+        const headers = context.headers;
+        if (!headers)
+          return void 0;
+        return getSignedCookie(headers, secret, key, prefix);
       },
-      redirect(url) {
-        responseHeader.set("Location", url);
-        return new APIError("FOUND");
+      redirect: (url) => {
+        const apiError = new APIError("Redirecting", 302, "FOUND", {
+          Location: url,
+          ...response.headers
+        });
+        return apiError;
       },
-      json,
-      context: ctx[0]?.context || {},
-      _flag: ctx[0]?.asResponse ? "router" : ctx[0]?._flag,
-      responseHeader,
-      path,
-      ...ctx[0] || {}
+      context: {}
     };
-    if (options.use?.length) {
-      let middlewareContexts = {};
-      let middlewareBody = {};
-      for (const middleware of options.use) {
-        if (typeof middleware !== "function") {
-          console.warn("Middleware is not a function", {
-            middleware
-          });
-          continue;
-        }
-        const res = await middleware(internalCtx);
-        if (res) {
-          const body = res.options?.body ? res.options.body.parse(internalCtx.body) : void 0;
-          middlewareContexts = {
-            ...middlewareContexts,
-            ...res
-          };
-          middlewareBody = {
-            ...middlewareBody,
-            ...body
-          };
-        }
-      }
-      internalCtx = {
-        ...internalCtx,
-        body: {
-          ...middlewareBody,
-          ...internalCtx.body
-        },
-        context: {
-          ...internalCtx.context || {},
-          ...middlewareContexts
+    const finalContext = await runMiddleware(options, context);
+    context.context = finalContext;
+    const handlerResponse = await handler(context).catch((e) => {
+      if (e instanceof APIError && asResponse) {
+        const headers = response.headers;
+        for (const [key, value] of Object.entries(e.headers)) {
+          headers.set(key, value);
         }
-      };
-    }
-    try {
-      const body = options.body ? options.body.parse(internalCtx.body) : internalCtx.body;
-      internalCtx = {
-        ...internalCtx,
-        body: body ? {
-          ...body,
-          ...internalCtx.body
-        } : internalCtx.body
-      };
-      internalCtx.query = options.query ? options.query.parse(internalCtx.query) : internalCtx.query;
-    } catch (e) {
-      if (e instanceof import_zod.ZodError) {
-        throw new APIError("BAD_REQUEST", {
-          message: e.message,
-          details: e.errors
+        return new Response(null, {
+          status: e.status,
+          headers
         });
       }
       throw e;
-    }
-    if (options.requireHeaders && !internalCtx.headers) {
-      throw new APIError("BAD_REQUEST", {
-        message: "Headers are required"
-      });
-    }
-    if (options.requireRequest && !internalCtx.request) {
-      throw new APIError("BAD_REQUEST", {
-        message: "Request is required"
-      });
-    }
-    try {
-      let res = await handler(internalCtx);
-      let actualResponse = res;
-      if (res && typeof res === "object" && "_flag" in res) {
-        if (res._flag === "json" && internalCtx._flag === "router") {
-          const h = res.response.headers;
-          Object.keys(h || {}).forEach((key) => {
-            responseHeader.set(key, h[key]);
-          });
-          responseHeader.set("Content-Type", "application/json");
-          actualResponse = new Response(JSON.stringify(res.response.body), {
-            status: res.response.status ?? 200,
-            statusText: res.response.statusText,
-            headers: responseHeader
-          });
-        } else {
-          actualResponse = res.body;
-        }
-      }
-      responseHeader = new Headers();
-      return actualResponse;
-    } catch (e) {
-      if (e instanceof APIError) {
-        e.headers = responseHeader;
-        responseHeader = new Headers();
-        throw e;
-      }
-      throw e;
-    }
+    });
+    response = createResponse(handlerResponse, response);
+    const res = asResponse ? response : handlerResponse;
+    return res;
   };
-  handle.path = path;
-  handle.options = options;
-  handle.method = options.method;
-  handle.headers = responseHeader;
-  return handle;
-}
-
-// src/router.ts
-var import_rou3 = require("rou3");
+  internalHandler.path = path;
+  internalHandler.options = options;
+  return internalHandler;
+};
 
-// src/utils.ts
 async function getBody(request) {
   const contentType = request.headers.get("content-type") || "";
   if (!request.body) {
@@ -676,78 +492,22 @@ async function getBody(request) {
   }
   return await request.text();
 }
-function shouldSerialize(body) {
-  return typeof body === "object" && body !== null && !(body instanceof Blob) && !(body instanceof FormData);
-}
-var statusCode = {
-  OK: 200,
-  CREATED: 201,
-  ACCEPTED: 202,
-  NO_CONTENT: 204,
-  MULTIPLE_CHOICES: 300,
-  MOVED_PERMANENTLY: 301,
-  FOUND: 302,
-  SEE_OTHER: 303,
-  NOT_MODIFIED: 304,
-  TEMPORARY_REDIRECT: 307,
-  BAD_REQUEST: 400,
-  UNAUTHORIZED: 401,
-  PAYMENT_REQUIRED: 402,
-  FORBIDDEN: 403,
-  NOT_FOUND: 404,
-  METHOD_NOT_ALLOWED: 405,
-  NOT_ACCEPTABLE: 406,
-  PROXY_AUTHENTICATION_REQUIRED: 407,
-  REQUEST_TIMEOUT: 408,
-  CONFLICT: 409,
-  GONE: 410,
-  LENGTH_REQUIRED: 411,
-  PRECONDITION_FAILED: 412,
-  PAYLOAD_TOO_LARGE: 413,
-  URI_TOO_LONG: 414,
-  UNSUPPORTED_MEDIA_TYPE: 415,
-  RANGE_NOT_SATISFIABLE: 416,
-  EXPECTATION_FAILED: 417,
-  "I'M_A_TEAPOT": 418,
-  MISDIRECTED_REQUEST: 421,
-  UNPROCESSABLE_ENTITY: 422,
-  LOCKED: 423,
-  FAILED_DEPENDENCY: 424,
-  TOO_EARLY: 425,
-  UPGRADE_REQUIRED: 426,
-  PRECONDITION_REQUIRED: 428,
-  TOO_MANY_REQUESTS: 429,
-  REQUEST_HEADER_FIELDS_TOO_LARGE: 431,
-  UNAVAILABLE_FOR_LEGAL_REASONS: 451,
-  INTERNAL_SERVER_ERROR: 500,
-  NOT_IMPLEMENTED: 501,
-  BAD_GATEWAY: 502,
-  SERVICE_UNAVAILABLE: 503,
-  GATEWAY_TIMEOUT: 504,
-  HTTP_VERSION_NOT_SUPPORTED: 505,
-  VARIANT_ALSO_NEGOTIATES: 506,
-  INSUFFICIENT_STORAGE: 507,
-  LOOP_DETECTED: 508,
-  NOT_EXTENDED: 510,
-  NETWORK_AUTHENTICATION_REQUIRED: 511
-};
 
-// src/router.ts
-var createRouter = (endpoints, config) => {
+const createRouter = (endpoints, config) => {
   const _endpoints = Object.values(endpoints);
-  const router = (0, import_rou3.createRouter)();
+  const router = rou3.createRouter();
   for (const endpoint of _endpoints) {
     if (Array.isArray(endpoint.options?.method)) {
       for (const method of endpoint.options.method) {
-        (0, import_rou3.addRoute)(router, method, endpoint.path, endpoint);
+        rou3.addRoute(router, method, endpoint.path, endpoint);
       }
     } else {
-      (0, import_rou3.addRoute)(router, endpoint.options.method, endpoint.path, endpoint);
+      rou3.addRoute(router, endpoint.options.method, endpoint.path, endpoint);
     }
   }
-  const middlewareRouter = (0, import_rou3.createRouter)();
+  const middlewareRouter = rou3.createRouter();
   for (const route of config?.routerMiddleware || []) {
-    (0, import_rou3.addRoute)(middlewareRouter, "*", route.path, route.middleware);
+    rou3.addRoute(middlewareRouter, "*", route.path, route.middleware);
   }
   const handler = async (request) => {
     const url = new URL(request.url);
@@ -766,12 +526,12 @@ var createRouter = (endpoints, config) => {
       });
     }
     const method = request.method;
-    const route = (0, import_rou3.findRoute)(router, method, path);
+    const route = rou3.findRoute(router, method, path);
     const handler2 = route?.data;
     const body = await getBody(request);
     const headers = request.headers;
     const query = Object.fromEntries(url.searchParams);
-    const routerMiddleware = (0, import_rou3.findAllRoutes)(middlewareRouter, "*", path);
+    const routerMiddleware = rou3.findAllRoutes(middlewareRouter, "*", path);
     if (!handler2) {
       return new Response(null, {
         status: 404,
@@ -819,18 +579,17 @@ var createRouter = (endpoints, config) => {
         request,
         body,
         query,
-        _flag: "router",
         context: {
           ...middlewareContext,
           ...config?.extraContext
-        }
+        },
+        asResponse: true
       });
       if (handlerRes instanceof Response) {
         return handlerRes;
       }
-      const resBody = shouldSerialize(handlerRes) ? JSON.stringify(handlerRes) : handlerRes;
-      return new Response(resBody, {
-        headers: handler2.headers
+      return new Response(handlerRes ? JSON.stringify(handlerRes) : void 0, {
+        status: 200
       });
     } catch (e) {
       if (config?.onError) {
@@ -840,12 +599,16 @@ var createRouter = (endpoints, config) => {
         }
       }
       if (e instanceof APIError) {
-        headers.set("Content-Type", "application/json");
-        return new Response(e.body ? JSON.stringify(e.body) : null, {
-          status: statusCode[e.status],
-          statusText: e.status,
-          headers: e.headers
-        });
+        return new Response(
+          e.message ? JSON.stringify({
+            message: e.message,
+            code: e.code
+          }) : null,
+          {
+            status: e.status,
+            headers: e.headers
+          }
+        );
       }
       if (config?.throwError) {
         throw e;
@@ -857,24 +620,11 @@ var createRouter = (endpoints, config) => {
     }
   };
   return {
-    handler: async (request) => {
-      const onReq = await config?.onRequest?.(request);
-      if (onReq instanceof Response) {
-        return onReq;
-      }
-      const req = onReq instanceof Request ? onReq : request;
-      const res = await handler(req);
-      const onRes = await config?.onResponse?.(res);
-      if (onRes instanceof Response) {
-        return onRes;
-      }
-      return res;
-    },
+    handler,
     endpoints
   };
 };
 
-// src/middleware.ts
 function createMiddleware(optionsOrHandler, handler) {
   if (typeof optionsOrHandler === "function") {
     return createEndpoint(
@@ -898,202 +648,20 @@ function createMiddleware(optionsOrHandler, handler) {
   );
   return endpoint;
 }
-var createMiddlewareCreator = (opts) => {
-  function fn(optionsOrHandler, handler) {
-    if (typeof optionsOrHandler === "function") {
-      return createEndpoint(
-        "*",
-        {
-          method: "*"
-        },
-        optionsOrHandler
-      );
-    }
-    if (!handler) {
-      throw new Error("Middleware handler is required");
-    }
-    const endpoint = createEndpoint(
-      "*",
-      {
-        ...optionsOrHandler,
-        method: "*"
-      },
-      handler
-    );
-    return endpoint;
-  }
-  return fn;
-};
-
-// src/types.ts
-var import_zod2 = require("zod");
-
-// src/adapter/node.ts
-var import_node_http2 = require("http");
-
-// src/adapter/request.ts
-var import_node_http = require("http");
-var set_cookie_parser = __toESM(require_set_cookie(), 1);
-function get_raw_body(req, body_size_limit) {
-  const h = req.headers;
-  if (!h["content-type"]) return null;
-  const content_length = Number(h["content-length"]);
-  if (req.httpVersionMajor === 1 && isNaN(content_length) && h["transfer-encoding"] == null || content_length === 0) {
-    return null;
-  }
-  let length = content_length;
-  if (body_size_limit) {
-    if (!length) {
-      length = body_size_limit;
-    } else if (length > body_size_limit) {
-      throw Error(
-        `Received content-length of ${length}, but only accept up to ${body_size_limit} bytes.`
-      );
-    }
-  }
-  if (req.destroyed) {
-    const readable = new ReadableStream();
-    readable.cancel();
-    return readable;
-  }
-  let size = 0;
-  let cancelled = false;
-  return new ReadableStream({
-    start(controller) {
-      req.on("error", (error) => {
-        cancelled = true;
-        controller.error(error);
-      });
-      req.on("end", () => {
-        if (cancelled) return;
-        controller.close();
-      });
-      req.on("data", (chunk) => {
-        if (cancelled) return;
-        size += chunk.length;
-        if (size > length) {
-          cancelled = true;
-          controller.error(
-            new Error(
-              `request body size exceeded ${content_length ? "'content-length'" : "BODY_SIZE_LIMIT"} of ${length}`
-            )
-          );
-          return;
-        }
-        controller.enqueue(chunk);
-        if (controller.desiredSize === null || controller.desiredSize <= 0) {
-          req.pause();
-        }
-      });
-    },
-    pull() {
-      req.resume();
-    },
-    cancel(reason) {
-      cancelled = true;
-      req.destroy(reason);
-    }
-  });
-}
-function getRequest({
-  request,
-  base,
-  bodySizeLimit
-}) {
-  return new Request(base + request.url, {
-    // @ts-expect-error
-    duplex: "half",
-    method: request.method,
-    body: get_raw_body(request, bodySizeLimit),
-    headers: request.headers
-  });
-}
-async function setResponse(res, response) {
-  for (const [key, value] of response.headers) {
-    try {
-      res.setHeader(
-        key,
-        key === "set-cookie" ? set_cookie_parser.splitCookiesString(response.headers.get(key)) : value
-      );
-    } catch (error) {
-      res.getHeaderNames().forEach((name) => res.removeHeader(name));
-      res.writeHead(500).end(String(error));
-      return;
-    }
-  }
-  res.writeHead(response.status);
-  if (!response.body) {
-    res.end();
-    return;
-  }
-  if (response.body.locked) {
-    res.end(
-      "Fatal error: Response body is locked. This can happen when the response was already read (for example through 'response.json()' or 'response.text()')."
-    );
-    return;
-  }
-  const reader = response.body.getReader();
-  if (res.destroyed) {
-    reader.cancel();
-    return;
-  }
-  const cancel = (error) => {
-    res.off("close", cancel);
-    res.off("error", cancel);
-    reader.cancel(error).catch(() => {
-    });
-    if (error) res.destroy(error);
-  };
-  res.on("close", cancel);
-  res.on("error", cancel);
-  next();
-  async function next() {
-    try {
-      for (; ; ) {
-        const { done, value } = await reader.read();
-        if (done) break;
-        if (!res.write(value)) {
-          res.once("drain", next);
-          return;
-        }
-      }
-      res.end();
-    } catch (error) {
-      cancel(error instanceof Error ? error : new Error(String(error)));
-    }
-  }
-}
 
-// src/adapter/node.ts
-function toNodeHandler(handler) {
-  return async (req, res) => {
-    const protocol = req.connection?.encrypted ? "https" : "http";
-    const base = `${protocol}://${req.headers[":authority"] || req.headers.host}`;
-    const response = await handler(getRequest({ base, request: req }));
-    setResponse(res, response);
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  APIError,
-  createEndpoint,
-  createEndpointCreator,
-  createMiddleware,
-  createMiddlewareCreator,
-  createRouter,
-  getBody,
-  getCookie,
-  getRequest,
-  getSignedCookie,
-  parse,
-  parseSigned,
-  serialize,
-  serializeSigned,
-  setCookie,
-  setResponse,
-  setSignedCookie,
-  shouldSerialize,
-  statusCode,
-  toNodeHandler
-});
-//# sourceMappingURL=index.cjs.map
+exports.createEndpoint = createEndpoint;
+exports.createGetHeader = createGetHeader;
+exports.createJSON = createJSON;
+exports.createMiddleware = createMiddleware;
+exports.createRouter = createRouter;
+exports.createSetHeader = createSetHeader;
+exports.fromError = fromError;
+exports.getCookie = getCookie;
+exports.getSignedCookie = getSignedCookie;
+exports.parse = parse;
+exports.parseSigned = parseSigned;
+exports.runValidation = runValidation;
+exports.serialize = serialize;
+exports.serializeSigned = serializeSigned;
+exports.setCookie = setCookie;
+exports.setSignedCookie = setSignedCookie;