better-call 0.2.13-beta.8 → 0.2.13

package/dist/index.mjs

@@ -1,768 +0,0 @@
-import crypto from 'uncrypto';
-import { extendZodWithOpenApi, OpenAPIRegistry } from '@asteasolutions/zod-to-openapi';
-import { z } from 'zod';
-import { createRouter as createRouter$1, addRoute, findRoute, findAllRoutes } from 'rou3';
-
-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);
-    }
-  }
-  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);
-  };
-}
-
-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) => {
-  const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
-  return await crypto.subtle.importKey("raw", secretBuf, algorithm, false, [
-    "sign",
-    "verify"
-  ]);
-};
-const makeSignature = async (value, secret) => {
-  const key = await getCryptoKey(secret);
-  const signature = await crypto.subtle.sign(
-    algorithm.name,
-    key,
-    new TextEncoder().encode(value)
-  );
-  return btoa(String.fromCharCode(...new Uint8Array(signature)));
-};
-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 crypto.subtle.verify(
-      algorithm,
-      secret,
-      signature,
-      new TextEncoder().encode(value)
-    );
-  } catch (e) {
-    return false;
-  }
-};
-const validCookieNameRegEx = /^[\w!#$%&'*.^`|~+-]+$/;
-const validCookieValueRegEx = /^[ !#-:<-[\]-~]*$/;
-const parse = (cookie, name) => {
-  const pairs = cookie.trim().split(";");
-  return pairs.reduce((parsedCookie, pairStr) => {
-    pairStr = pairStr.trim();
-    const valueStartPos = pairStr.indexOf("=");
-    if (valueStartPos === -1) {
-      return parsedCookie;
-    }
-    const cookieName = pairStr.substring(0, valueStartPos).trim();
-    if (name && name !== cookieName || !validCookieNameRegEx.test(cookieName)) {
-      return parsedCookie;
-    }
-    let cookieValue = pairStr.substring(valueStartPos + 1).trim();
-    if (cookieValue.startsWith('"') && cookieValue.endsWith('"')) {
-      cookieValue = cookieValue.slice(1, -1);
-    }
-    if (validCookieValueRegEx.test(cookieValue)) {
-      parsedCookie[cookieName] = decodeURIComponent(cookieValue);
-    }
-    return parsedCookie;
-  }, {});
-};
-const parseSigned = async (cookie, secret, name) => {
-  const parsedCookie = {};
-  const secretKey = await getCryptoKey(secret);
-  for (const [key, value] of Object.entries(parse(cookie, name))) {
-    const signatureStartPos = value.lastIndexOf(".");
-    if (signatureStartPos < 1) {
-      continue;
-    }
-    const signedValue = value.substring(0, signatureStartPos);
-    const signature = value.substring(signatureStartPos + 1);
-    if (signature.length !== 44 || !signature.endsWith("=")) {
-      continue;
-    }
-    const isVerified = await verifySignature(signature, signedValue, secretKey);
-    parsedCookie[key] = isVerified ? signedValue : false;
-  }
-  return parsedCookie;
-};
-const _serialize = (name, value, opt = {}) => {
-  let cookie = `${name}=${value}`;
-  if (name.startsWith("__Secure-") && !opt.secure) {
-    opt.secure = true;
-  }
-  if (name.startsWith("__Host-")) {
-    if (!opt.secure) {
-      opt.secure = true;
-    }
-    if (opt.path !== "/") {
-      opt.path = "/";
-    }
-    if (opt.domain) {
-      opt.domain = void 0;
-    }
-  }
-  if (opt && typeof opt.maxAge === "number" && opt.maxAge >= 0) {
-    if (opt.maxAge > 3456e4) {
-      throw new Error(
-        "Cookies Max-Age SHOULD NOT be greater than 400 days (34560000 seconds) in duration."
-      );
-    }
-    cookie += `; Max-Age=${Math.floor(opt.maxAge)}`;
-  }
-  if (opt.domain && opt.prefix !== "host") {
-    cookie += `; Domain=${opt.domain}`;
-  }
-  if (opt.path) {
-    cookie += `; Path=${opt.path}`;
-  }
-  if (opt.expires) {
-    if (opt.expires.getTime() - Date.now() > 3456e7) {
-      throw new Error(
-        "Cookies Expires SHOULD NOT be greater than 400 days (34560000 seconds) in the future."
-      );
-    }
-    cookie += `; Expires=${opt.expires.toUTCString()}`;
-  }
-  if (opt.httpOnly) {
-    cookie += "; HttpOnly";
-  }
-  if (opt.secure) {
-    cookie += "; Secure";
-  }
-  if (opt.sameSite) {
-    cookie += `; SameSite=${opt.sameSite.charAt(0).toUpperCase() + opt.sameSite.slice(1)}`;
-  }
-  if (opt.partitioned) {
-    if (!opt.secure) {
-      throw new Error("Partitioned Cookie must have Secure attributes");
-    }
-    cookie += "; Partitioned";
-  }
-  return cookie;
-};
-const serialize = (name, value, opt) => {
-  value = encodeURIComponent(value);
-  return _serialize(name, value, 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);
-};
-
-const getCookie = (cookie, key, prefix) => {
-  if (!cookie) {
-    return void 0;
-  }
-  let finalKey = key;
-  if (prefix) {
-    if (prefix === "secure") {
-      finalKey = "__Secure-" + key;
-    } else if (prefix === "host") {
-      finalKey = "__Host-" + key;
-    } else {
-      return void 0;
-    }
-  }
-  const obj = parse(cookie, finalKey);
-  return obj[finalKey];
-};
-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}=`)
-    );
-    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
-    });
-  } else if (opt?.prefix === "host") {
-    cookie = serialize("__Host-" + name, value, {
-      ...opt,
-      path: "/",
-      secure: true,
-      domain: void 0
-    });
-  } else {
-    cookie = serialize(name, value, { path: "/", ...opt });
-  }
-  header.append("Set-Cookie", cookie);
-};
-const setSignedCookie = async (header, name, value, secret, opt) => {
-  let cookie;
-  if (opt?.prefix === "secure") {
-    cookie = await serializeSigned("__Secure-" + name, value, secret, {
-      path: "/",
-      ...opt,
-      secure: true
-    });
-  } else if (opt?.prefix === "host") {
-    cookie = await serializeSigned("__Host-" + name, value, secret, {
-      ...opt,
-      path: "/",
-      secure: true,
-      domain: void 0
-    });
-  } else {
-    cookie = await serializeSigned(name, value, secret, { path: "/", ...opt });
-  }
-  header.append("Set-Cookie", cookie);
-};
-const getSignedCookie = async (header, secret, key, prefix) => {
-  const cookie = header.get("cookie");
-  if (!cookie) {
-    return void 0;
-  }
-  let finalKey = key;
-  if (prefix) {
-    if (prefix === "secure") {
-      finalKey = "__Secure-" + key;
-    } else if (prefix === "host") {
-      finalKey = "__Host-" + key;
-    }
-  }
-  const obj = await parseSigned(cookie, secret, finalKey);
-  return obj[finalKey];
-};
-
-function paramToZod(path) {
-  const parts = path.split("/");
-  const params = parts.filter((part) => part.startsWith(":"));
-  const zod = z.object({});
-  for (const param of params) {
-    zod.merge(z.object({ [param.slice(1)]: z.string() }));
-  }
-  return zod;
-}
-
-extendZodWithOpenApi(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
-      ),
-      {
-        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"
-        };
-      },
-      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: (name, value, options2) => {
-        setCookie(response.headers, name, value, options2);
-      },
-      getCookie(key, prefix) {
-        const headers = context.headers?.get("cookie");
-        if (!headers)
-          return void 0;
-        return getCookie(headers, key, prefix);
-      },
-      setSignedCookie(key, value, secret, options2) {
-        return setSignedCookie(response.headers, 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) => {
-        const apiError = new APIError("FOUND", void 0, {
-          Location: url,
-          ...response.headers
-        });
-        return apiError;
-      },
-      context: {}
-    };
-    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);
-        }
-        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 OpenAPIRegistry();
-  registry.registerPath({
-    path,
-    method: Array.isArray(options.method) ? options.method[0].toLowerCase() : options.method.toLowerCase(),
-    request: {
-      ...options.body ? {
-        body: {
-          content: {
-            "application/json": {
-              schema: options.body
-            }
-          }
-        }
-      } : {},
-      ...options.query ? {
-        query: options.query
-      } : {},
-      params: paramToZod(path)
-    },
-    responses: {
-      200: {
-        description: "Successful response",
-        content: {
-          "application/json": {
-            schema: z.record(z.unknown())
-          }
-        }
-      },
-      400: {
-        description: "Bad request",
-        content: {
-          "application/json": {
-            schema: z.object({
-              message: z.string()
-            })
-          }
-        }
-      },
-      ...options.openAPI?.responses
-    }
-  });
-  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;
-  };
-}
-createEndpoint.creator = createEndpointCreator;
-
-async function getBody(request) {
-  const contentType = request.headers.get("content-type") || "";
-  if (!request.body) {
-    return void 0;
-  }
-  if (contentType.includes("application/json")) {
-    return await request.json();
-  }
-  if (contentType.includes("application/x-www-form-urlencoded")) {
-    const formData = await request.formData();
-    const result = {};
-    formData.forEach((value, key) => {
-      result[key] = value.toString();
-    });
-    return result;
-  }
-  if (contentType.includes("multipart/form-data")) {
-    const formData = await request.formData();
-    const result = {};
-    formData.forEach((value, key) => {
-      result[key] = value;
-    });
-    return result;
-  }
-  if (contentType.includes("text/plain")) {
-    return await request.text();
-  }
-  if (contentType.includes("application/octet-stream")) {
-    return await request.arrayBuffer();
-  }
-  if (contentType.includes("application/pdf") || contentType.includes("image/") || contentType.includes("video/")) {
-    const blob = await request.blob();
-    return blob;
-  }
-  if (contentType.includes("application/stream") || request.body instanceof ReadableStream) {
-    return request.body;
-  }
-  return await request.text();
-}
-
-const createRouter = (endpoints, config) => {
-  const _endpoints = Object.values(endpoints);
-  const router = createRouter$1();
-  for (const endpoint of _endpoints) {
-    if (Array.isArray(endpoint.options?.method)) {
-      for (const method of endpoint.options.method) {
-        addRoute(router, method, endpoint.path, endpoint);
-      }
-    } else {
-      addRoute(router, endpoint.options.method, endpoint.path, endpoint);
-    }
-  }
-  const middlewareRouter = createRouter$1();
-  for (const route of config?.routerMiddleware || []) {
-    addRoute(middlewareRouter, "*", route.path, route.middleware);
-  }
-  const handler = async (request) => {
-    const url = new URL(request.url);
-    let path = url.pathname;
-    if (config?.basePath) {
-      path = path.split(config.basePath)[1];
-    }
-    if (!path?.length) {
-      config?.onError?.(new APIError("NOT_FOUND"));
-      console.warn(
-        `[better-call]: Make sure the URL has the basePath (${config?.basePath}).`
-      );
-      return new Response(null, {
-        status: 404,
-        statusText: "Not Found"
-      });
-    }
-    const method = request.method;
-    const route = 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 = findAllRoutes(middlewareRouter, "*", path);
-    if (!handler2) {
-      return new Response(null, {
-        status: 404,
-        statusText: "Not Found"
-      });
-    }
-    try {
-      let middlewareContext = {};
-      if (routerMiddleware?.length) {
-        for (const route2 of routerMiddleware) {
-          const middleware = route2.data;
-          const res = await middleware({
-            path,
-            method,
-            headers,
-            params: route2?.params,
-            request,
-            body,
-            query,
-            context: {
-              ...config?.extraContext
-            }
-          });
-          if (res instanceof Response) {
-            return res;
-          }
-          if (res?._flag === "json") {
-            return new Response(JSON.stringify(res), {
-              headers: res.headers
-            });
-          }
-          if (res) {
-            middlewareContext = {
-              ...res,
-              ...middlewareContext
-            };
-          }
-        }
-      }
-      const handlerRes = await handler2({
-        path,
-        method,
-        headers,
-        params: route?.params,
-        request,
-        body,
-        query,
-        context: {
-          ...middlewareContext,
-          ...config?.extraContext
-        },
-        asResponse: true
-      });
-      if (handlerRes instanceof Response) {
-        return handlerRes;
-      }
-      return new Response(handlerRes ? JSON.stringify(handlerRes) : void 0, {
-        status: 200
-      });
-    } catch (e) {
-      if (config?.onError) {
-        const onErrorRes = await config.onError(e);
-        if (onErrorRes instanceof Response) {
-          return onErrorRes;
-        }
-      }
-      if (e instanceof APIError) {
-        return new Response(e.body ? JSON.stringify(e.body) : null, {
-          status: e.statusCode,
-          headers: e.headers
-        });
-      }
-      if (config?.throwError) {
-        throw e;
-      }
-      return new Response(null, {
-        status: 500,
-        statusText: "Internal Server Error"
-      });
-    }
-  };
-  return {
-    handler,
-    endpoints
-  };
-};
-
-function createMiddleware(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;
-}
-function createMiddlewareCreator(opts) {
-  return (handler) => {
-    const res = createMiddleware(
-      {
-        method: "*",
-        use: opts.use
-      },
-      handler
-    );
-    return res;
-  };
-}
-createMiddleware.creator = createMiddlewareCreator;
-
-export { APIError, _statusCode, createEndpoint, createGetHeader, createMiddleware, createRouter, createSetHeader, fromError, getCookie, getSignedCookie, parse, parseSigned, runValidation, serialize, serializeSigned, setCookie, setSignedCookie };