better-call 0.2.13-beta.8 → 0.2.14-beta.1

package/dist/index.cjs

@@ -1,187 +1,124 @@
-'use strict';
-
-const crypto = require('uncrypto');
-const zodToOpenapi = require('@asteasolutions/zod-to-openapi');
-const zod = require('zod');
-const rou3 = require('rou3');
+"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 __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);
 
-function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
+// 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);
 
-const crypto__default = /*#__PURE__*/_interopDefaultCompat(crypto);
+// src/endpoint.ts
+var import_zod = require("zod");
 
-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)
-      };
-    }
-    request.body = result.data;
-  }
-  if (options.query) {
-    const result = options.query.safeParse(context.query);
-    if (result.error) {
-      return {
-        data: null,
-        error: fromError(result.error)
-      };
-    }
-    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);
+// 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");
+    this.status = status;
+    this.body = body ?? {};
+    this.stack = "";
+    this.headers = headers ?? new Headers();
+    if (!this.headers.has("Content-Type")) {
+      this.headers.set("Content-Type", "application/json");
     }
+    this.name = "BetterCallAPIError";
   }
-  return {
-    message: `Validation error: ${errorMessages.join(", ")}`
-  };
-}
+};
 
-function createSetHeader(headers) {
-  return (key, value) => {
-    headers.set(key, value);
-  };
-}
-function createGetHeader(headers) {
-  return (key) => {
-    return headers.get(key);
+// 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"
   };
-}
-
-const _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
 };
-class APIError extends Error {
-  constructor(status = "INTERNAL_SERVER_ERROR", body = void 0, headers = {}, statusCode = _statusCode[status]) {
-    super(body?.message || status);
-    this.status = status;
-    this.body = body;
-    this.headers = headers;
-    this.statusCode = statusCode;
-    this.name = "APIError";
-    this.status = status;
-    this.headers = headers;
-    this.statusCode = statusCode;
-    this.stack = "";
-  }
-}
 
-const algorithm = { name: "HMAC", hash: "SHA-256" };
-const getCryptoKey = async (secret) => {
+// src/cookie.ts
+var import_uncrypto = require("uncrypto");
+var algorithm = { name: "HMAC", hash: "SHA-256" };
+var getCryptoKey = async (secret) => {
   const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
-  return await crypto__default.subtle.importKey("raw", secretBuf, algorithm, false, [
-    "sign",
-    "verify"
-  ]);
+  return await import_uncrypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
 };
-const makeSignature = async (value, secret) => {
+var makeSignature = async (value, secret) => {
   const key = await getCryptoKey(secret);
-  const signature = await crypto__default.subtle.sign(
-    algorithm.name,
-    key,
-    new TextEncoder().encode(value)
-  );
+  const signature = await import_uncrypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
   return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
-const verifySignature = async (base64Signature, value, secret) => {
+var 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 crypto__default.subtle.verify(
-      algorithm,
-      secret,
-      signature,
-      new TextEncoder().encode(value)
-    );
+    return await import_uncrypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
   } catch (e) {
     return false;
   }
 };
-const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-const parse = (cookie, name) => {
+var validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
+var validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
+var parse = (cookie, name) => {
   const pairs = cookie.trim().split(";");
   return pairs.reduce((parsedCookie, pairStr) => {
     pairStr = pairStr.trim();
@@ -203,7 +140,7 @@ const parse = (cookie, name) => {
     return parsedCookie;
   }, {});
 };
-const parseSigned = async (cookie, secret, name) => {
+var parseSigned = async (cookie, secret, name) => {
   const parsedCookie = {};
   const secretKey = await getCryptoKey(secret);
   for (const [key, value] of Object.entries(parse(cookie, name))) {
@@ -221,7 +158,7 @@ const parseSigned = async (cookie, secret, name) => {
   }
   return parsedCookie;
 };
-const _serialize = (name, value, opt = {}) => {
+var _serialize = (name, value, opt = {}) => {
   let cookie = `${name}=${value}`;
   if (name.startsWith("__Secure-") && !opt.secure) {
     opt.secure = true;
@@ -276,18 +213,19 @@ const _serialize = (name, value, opt = {}) => {
   }
   return cookie;
 };
-const serialize = (name, value, opt) => {
+var serialize = (name, value, opt) => {
   value = encodeURIComponent(value);
   return _serialize(name, value, opt);
 };
-const serializeSigned = async (name, value, secret, opt = {}) => {
+var serializeSigned = async (name, value, secret, opt = {}) => {
   const signature = await makeSignature(value, secret);
   value = `${value}.${signature}`;
   value = encodeURIComponent(value);
   return _serialize(name, value, opt);
 };
 
-const getCookie = (cookie, key, prefix) => {
+// src/cookie-utils.ts
+var getCookie = (cookie, key, prefix) => {
   if (!cookie) {
     return void 0;
   }
@@ -304,23 +242,17 @@ const getCookie = (cookie, key, prefix) => {
   const obj = parse(cookie, finalKey);
   return obj[finalKey];
 };
-const setCookie = (header, name, value, opt) => {
+var 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,
@@ -333,7 +265,7 @@ const setCookie = (header, name, value, opt) => {
   }
   header.append("Set-Cookie", cookie);
 };
-const setSignedCookie = async (header, name, value, secret, opt) => {
+var setSignedCookie = async (header, name, value, secret, opt) => {
   let cookie;
   if (opt?.prefix === "secure") {
     cookie = await serializeSigned("__Secure-" + name, value, secret, {
@@ -353,7 +285,7 @@ const setSignedCookie = async (header, name, value, secret, opt) => {
   }
   header.append("Set-Cookie", cookie);
 };
-const getSignedCookie = async (header, secret, key, prefix) => {
+var getSignedCookie = async (header, secret, key, prefix) => {
   const cookie = header.get("cookie");
   if (!cookie) {
     return void 0;
@@ -370,204 +302,163 @@ const getSignedCookie = async (header, secret, key, prefix) => {
   return obj[finalKey];
 };
 
-function paramToZod(path) {
-  const parts = path.split("/");
-  const params = parts.filter((part) => part.startsWith(":"));
-  const zod$1 = zod.z.object({});
-  for (const param of params) {
-    zod$1.merge(zod.z.object({ [param.slice(1)]: zod.z.string() }));
-  }
-  return zod$1;
-}
-
-zodToOpenapi.extendZodWithOpenApi(zod.z);
-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
-      ),
+// src/endpoint.ts
+function createEndpointCreator(opts) {
+  return (path, options, handler) => {
+    return createEndpoint(
+      path,
       {
-        status: handlerResponse.routerResponse?.status || 200,
-        headers: handlerResponse.routerResponse?.headers
-      }
-    );
-    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("BAD_REQUEST", {
-        message: error.message
-      });
-    }
-    const context = {
-      json: (json, routerResponse) => {
-        if (!asResponse) {
-          return json;
-        }
-        return {
-          body: json,
-          routerResponse,
-          _flag: "json"
-        };
+        ...options,
+        use: [...options?.use || [], ...opts?.use || []]
       },
-      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);
+      handler
+    );
+  };
+}
+function createEndpoint(path, options, handler) {
+  let responseHeader = new Headers();
+  const handle = async (...ctx) => {
+    let internalCtx = {
+      setHeader(key, value) {
+        responseHeader.set(key, value);
       },
-      setCookie: (name, value, options2) => {
-        setCookie(response.headers, name, value, options2);
+      setCookie(key, value, options2) {
+        setCookie(responseHeader, key, value, options2);
       },
       getCookie(key, prefix) {
-        const headers = context.headers?.get("cookie");
-        if (!headers)
-          return void 0;
-        return getCookie(headers, key, prefix);
+        const header = ctx[0]?.headers;
+        const cookieH = header?.get("cookie");
+        const cookie = getCookie(cookieH || "", key, prefix);
+        return cookie;
       },
-      setSignedCookie(key, value, secret, options2) {
-        return setSignedCookie(response.headers, key, value, secret, options2);
+      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;
       },
-      async getSignedCookie(key, secret, prefix) {
-        const headers = context.headers;
-        if (!headers)
-          return void 0;
-        return getSignedCookie(headers, secret, key, prefix);
+      async setSignedCookie(key, value, secret, options2) {
+        await setSignedCookie(responseHeader, key, value, secret, options2);
       },
-      redirect: (url) => {
-        const apiError = new APIError("FOUND", void 0, {
-          Location: url,
-          ...response.headers
-        });
-        return apiError;
+      redirect(url) {
+        responseHeader.set("Location", url);
+        return new APIError("FOUND");
       },
-      context: {}
+      json,
+      context: ctx[0]?.context || {},
+      _flag: ctx[0]?.asResponse ? "router" : ctx[0]?._flag,
+      responseHeader,
+      path,
+      ...ctx[0] || {}
     };
-    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);
+    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
+          };
         }
-        return new Response(null, {
-          status: e.statusCode,
-          headers
-        });
       }
-      throw e;
-    });
-    response = createResponse(handlerResponse, response);
-    const res = asResponse ? response : handlerResponse;
-    return res;
-  };
-  internalHandler.path = path;
-  internalHandler.options = options;
-  const registry = new zodToOpenapi.OpenAPIRegistry();
-  registry.registerPath({
-    path,
-    method: Array.isArray(options.method) ? options.method[0].toLowerCase() : options.method.toLowerCase(),
-    request: {
-      ...options.body ? {
+      internalCtx = {
+        ...internalCtx,
         body: {
-          content: {
-            "application/json": {
-              schema: options.body
-            }
-          }
-        }
-      } : {},
-      ...options.query ? {
-        query: options.query
-      } : {},
-      params: paramToZod(path)
-    },
-    responses: {
-      200: {
-        description: "Successful response",
-        content: {
-          "application/json": {
-            schema: zod.z.record(zod.z.unknown())
-          }
+          ...middlewareBody,
+          ...internalCtx.body
+        },
+        context: {
+          ...internalCtx.context || {},
+          ...middlewareContexts
         }
-      },
-      400: {
-        description: "Bad request",
-        content: {
-          "application/json": {
-            schema: zod.z.object({
-              message: zod.z.string()
-            })
-          }
+      };
+    }
+    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
+        });
+      }
+      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;
         }
-      },
-      ...options.openAPI?.responses
+      }
+      responseHeader = new Headers();
+      return actualResponse;
+    } catch (e) {
+      if (e instanceof APIError) {
+        responseHeader.set("Content-Type", "application/json");
+        e.headers = responseHeader;
+        responseHeader = new Headers();
+        throw e;
+      }
+      throw e;
     }
-  });
-  internalHandler.openAPI = {
-    definitions: registry.definitions
-  };
-  return internalHandler;
-};
-function createEndpointCreator(opts) {
-  return (path, options, handler) => {
-    const res = createEndpoint(
-      path,
-      {
-        ...options,
-        use: [...options?.use || [], ...opts?.use || []]
-      },
-      handler
-    );
-    return res;
   };
+  handle.path = path;
+  handle.options = options;
+  handle.method = options.method;
+  handle.headers = responseHeader;
+  return handle;
 }
-createEndpoint.creator = createEndpointCreator;
 
+// src/router.ts
+var import_rou3 = require("rou3");
+
+// src/utils.ts
 async function getBody(request) {
   const contentType = request.headers.get("content-type") || "";
   if (!request.body) {
@@ -607,22 +498,79 @@ 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
+};
 
-const createRouter = (endpoints, config) => {
+// src/router.ts
+var createRouter = (endpoints, config) => {
   const _endpoints = Object.values(endpoints);
-  const router = rou3.createRouter();
+  const router = (0, import_rou3.createRouter)();
   for (const endpoint of _endpoints) {
+    if (endpoint.options.metadata?.SERVER_ONLY) continue;
     if (Array.isArray(endpoint.options?.method)) {
       for (const method of endpoint.options.method) {
-        rou3.addRoute(router, method, endpoint.path, endpoint);
+        (0, import_rou3.addRoute)(router, method, endpoint.path, endpoint);
       }
     } else {
-      rou3.addRoute(router, endpoint.options.method, endpoint.path, endpoint);
+      (0, import_rou3.addRoute)(router, endpoint.options.method, endpoint.path, endpoint);
     }
   }
-  const middlewareRouter = rou3.createRouter();
+  const middlewareRouter = (0, import_rou3.createRouter)();
   for (const route of config?.routerMiddleware || []) {
-    rou3.addRoute(middlewareRouter, "*", route.path, route.middleware);
+    (0, import_rou3.addRoute)(middlewareRouter, "*", route.path, route.middleware);
   }
   const handler = async (request) => {
     const url = new URL(request.url);
@@ -641,12 +589,12 @@ const createRouter = (endpoints, config) => {
       });
     }
     const method = request.method;
-    const route = rou3.findRoute(router, method, path);
+    const route = (0, import_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 = rou3.findAllRoutes(middlewareRouter, "*", path);
+    const routerMiddleware = (0, import_rou3.findAllRoutes)(middlewareRouter, "*", path);
     if (!handler2) {
       return new Response(null, {
         status: 404,
@@ -694,17 +642,18 @@ const createRouter = (endpoints, config) => {
         request,
         body,
         query,
+        _flag: "router",
         context: {
           ...middlewareContext,
           ...config?.extraContext
-        },
-        asResponse: true
+        }
       });
       if (handlerRes instanceof Response) {
         return handlerRes;
       }
-      return new Response(handlerRes ? JSON.stringify(handlerRes) : void 0, {
-        status: 200
+      const resBody = shouldSerialize(handlerRes) ? JSON.stringify(handlerRes) : handlerRes;
+      return new Response(resBody, {
+        headers: handler2.headers
       });
     } catch (e) {
       if (config?.onError) {
@@ -715,7 +664,8 @@ const createRouter = (endpoints, config) => {
       }
       if (e instanceof APIError) {
         return new Response(e.body ? JSON.stringify(e.body) : null, {
-          status: e.statusCode,
+          status: statusCode[e.status],
+          statusText: e.status,
           headers: e.headers
         });
       }
@@ -729,11 +679,24 @@ const createRouter = (endpoints, config) => {
     }
   };
   return {
-    handler,
+    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;
+    },
     endpoints
   };
 };
 
+// src/middleware.ts
 function createMiddleware(optionsOrHandler, handler) {
   if (typeof optionsOrHandler === "function") {
     return createEndpoint(
@@ -757,34 +720,202 @@ function createMiddleware(optionsOrHandler, handler) {
   );
   return endpoint;
 }
-function createMiddlewareCreator(opts) {
-  return (handler) => {
-    const res = createMiddleware(
+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(
+      "*",
       {
-        method: "*",
-        use: opts.use
+        ...optionsOrHandler,
+        method: "*"
       },
       handler
     );
-    return res;
+    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-parser"), 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)));
+    }
+  }
 }
-createMiddleware.creator = createMiddlewareCreator;
 
-exports.APIError = APIError;
-exports._statusCode = _statusCode;
-exports.createEndpoint = createEndpoint;
-exports.createGetHeader = createGetHeader;
-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;
+// 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