better-call 0.2.11 → 0.2.13-beta.2

package/dist/index.mjs

@@ -0,0 +1,646 @@
+import crypto from 'uncrypto';
+import { createRouter as createRouter$1, addRoute, findRoute, findAllRoutes } from 'rou3';
+
+function createJSON({
+  asResponse,
+  response
+}) {
+  return async function json(json, routerResponse) {
+    if (!asResponse) {
+      return json;
+    }
+    return {
+      body: json,
+      routerResponse,
+      _flag: "json"
+    };
+  };
+}
+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);
+  };
+}
+
+class APIError extends Error {
+  constructor(message, status = 500, code = "INTERNAL_SERVER_ERROR", headers = {}) {
+    super(message);
+    this.message = message;
+    this.status = status;
+    this.code = code;
+    this.headers = headers;
+    this.name = "APIError";
+    this.message = message;
+    this.status = status;
+    this.code = code;
+    this.headers = headers;
+    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];
+};
+
+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(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: (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("Redirecting", 302, "FOUND", {
+          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.status,
+          headers
+        });
+      }
+      throw e;
+    });
+    response = createResponse(handlerResponse, response);
+    const res = asResponse ? response : handlerResponse;
+    return res;
+  };
+  internalHandler.path = path;
+  internalHandler.options = options;
+  return internalHandler;
+};
+
+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.message ? JSON.stringify({
+            message: e.message,
+            code: e.code
+          }) : null,
+          {
+            status: e.status,
+            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;
+}
+
+export { createEndpoint, createGetHeader, createJSON, createMiddleware, createRouter, createSetHeader, fromError, getCookie, getSignedCookie, parse, parseSigned, runValidation, serialize, serializeSigned, setCookie, setSignedCookie };