better-call 1.0.18 → 1.0.20

package/README.md

@@ -314,9 +314,48 @@ const router = createRouter({
 
 **basePath**: The base path for the router. All paths will be relative to this path.
 
-**onError**: The router will call this function if an error occurs in the middleware or the endpoint.
+**onError**: The router will call this function if an error occurs in the middleware or the endpoint. This function receives the error as a parameter and can return different types of values:
 
-**throwError**: If true, the router will throw an error if an error occurs in the middleware or the endpoint.
+- If it returns a `Response` object, the router will use it as the HTTP response.
+- If it throws a new error, the router will handle it based on its type (if it's an `APIError`, it will be converted to a response; otherwise, it will be re-thrown).
+- If it returns nothing (void), the router will proceed with default error handling (checking `throwError` setting).
+
+```ts
+const router = createRouter({
+    /**
+     * This error handler can be set as async function or not.
+     */
+    onError: async (error) => {
+        // Log the error
+        console.error("An error occurred:", error);
+        
+        // Return a custom response
+        return new Response(JSON.stringify({ message: "Something went wrong" }), {
+            status: 500,
+            headers: { "Content-Type": "application/json" }
+        });
+    }
+});
+```
+
+**throwError**: If true, the router will throw an error if an error occurs in the middleware or the endpoint. If false (default), the router will handle errors internally. This setting is still relevant even when `onError` is provided, as it determines the behavior when:
+
+1. No `onError` handler is provided, or
+2. The `onError` handler returns void (doesn't return a Response or throw an error)
+
+- For `APIError` instances, it will convert them to appropriate HTTP responses.
+- For other errors, it will return a 500 Internal Server Error response.
+
+```ts
+const router = createRouter({
+    throwError: true, // Errors will be propagated to higher-level handlers
+    onError: (error) => {
+        // Log the error but let throwError handle it
+        console.error("An error occurred:", error);
+        // No return value, so throwError setting will determine behavior
+    }
+});
+```
 
 #### Node Adapter
 

package/dist/client.d.cts

@@ -1,5 +1,5 @@
 import { BetterFetchOption, BetterFetchResponse } from '@better-fetch/fetch';
-import { j as Router, Z as UnionToIntersection, b as Endpoint, W as HasRequiredKeys } from './router-DcqXHY8X.cjs';
+import { j as Router, Z as UnionToIntersection, b as Endpoint, W as HasRequiredKeys } from './router-BDQGRZdc.cjs';
 
 type HasRequired<T extends {
     body?: any;

package/dist/client.d.ts

@@ -1,5 +1,5 @@
 import { BetterFetchOption, BetterFetchResponse } from '@better-fetch/fetch';
-import { j as Router, Z as UnionToIntersection, b as Endpoint, W as HasRequiredKeys } from './router-DcqXHY8X.js';
+import { j as Router, Z as UnionToIntersection, b as Endpoint, W as HasRequiredKeys } from './router-BDQGRZdc.js';
 
 type HasRequired<T extends {
     body?: any;

package/dist/index.cjs

@@ -383,11 +383,14 @@ function fromError(error, validating) {
 }
 
 // src/crypto.ts
-var import_uncrypto = require("uncrypto");
+var import_utils2 = require("@better-auth/utils");
 var algorithm = { name: "HMAC", hash: "SHA-256" };
 var getCryptoKey = async (secret) => {
   const secretBuf = typeof secret === "string" ? new TextEncoder().encode(secret) : secret;
-  return await import_uncrypto.subtle.importKey("raw", secretBuf, algorithm, false, ["sign", "verify"]);
+  return await (0, import_utils2.getWebcryptoSubtle)().importKey("raw", secretBuf, algorithm, false, [
+    "sign",
+    "verify"
+  ]);
 };
 var verifySignature = async (base64Signature, value, secret) => {
   try {
@@ -396,14 +399,23 @@ var verifySignature = async (base64Signature, value, secret) => {
     for (let i = 0, len = signatureBinStr.length; i < len; i++) {
       signature[i] = signatureBinStr.charCodeAt(i);
     }
-    return await import_uncrypto.subtle.verify(algorithm, secret, signature, new TextEncoder().encode(value));
+    return await (0, import_utils2.getWebcryptoSubtle)().verify(
+      algorithm,
+      secret,
+      signature,
+      new TextEncoder().encode(value)
+    );
   } catch (e) {
     return false;
   }
 };
 var makeSignature = async (value, secret) => {
   const key = await getCryptoKey(secret);
-  const signature = await import_uncrypto.subtle.sign(algorithm.name, key, new TextEncoder().encode(value));
+  const signature = await (0, import_utils2.getWebcryptoSubtle)().sign(
+    algorithm.name,
+    key,
+    new TextEncoder().encode(value)
+  );
   return btoa(String.fromCharCode(...new Uint8Array(signature)));
 };
 var signCookieValue = async (value, secret) => {
@@ -688,6 +700,7 @@ createMiddleware.create = (opts) => {
 };
 
 // src/endpoint.ts
+var originalHandlerSymbol = Symbol("kOriginalHandler");
 var createEndpoint2 = (path, options, handler) => {
   const internalHandler = async (...inputCtx) => {
     const context = inputCtx[0] || {};
@@ -695,7 +708,9 @@ var createEndpoint2 = (path, options, handler) => {
       options,
       path
     });
-    const response = await handler(internalContext).catch(async (e) => {
+    const response = await internalHandler[originalHandlerSymbol](
+      internalContext
+    ).catch(async (e) => {
       if (isAPIError(e)) {
         const onAPIError = options.onAPIError;
         if (onAPIError) {
@@ -715,6 +730,13 @@ var createEndpoint2 = (path, options, handler) => {
       response
     } : response;
   };
+  internalHandler[originalHandlerSymbol] = handler;
+  internalHandler.wrap = (fn) => {
+    const wrappedFn = async (context) => {
+      return fn(context, internalHandler[originalHandlerSymbol]);
+    };
+    return createEndpoint2(path, options, wrappedFn);
+  };
   internalHandler.options = options;
   internalHandler.path = path;
   return internalHandler;
@@ -3174,6 +3196,22 @@ var createRouter = (endpoints, config2) => {
       const response = await handler(context);
       return response;
     } catch (error) {
+      if (config2?.onError) {
+        try {
+          const errorResponse = await config2.onError(error);
+          if (errorResponse instanceof Response) {
+            return toResponse(errorResponse);
+          }
+        } catch (error2) {
+          if (isAPIError(error2)) {
+            return toResponse(error2);
+          }
+          throw error2;
+        }
+      }
+      if (config2?.throwError) {
+        throw error;
+      }
       if (isAPIError(error)) {
         return toResponse(error);
       }