@solvapay/server 1.0.0-preview.17 → 1.0.0-preview.19

package/dist/index.js

@@ -1,6 +1,4 @@
-import {
-  __require
-} from "./chunk-R5U7XKVJ.js";
+import "./chunk-MLKGABMK.js";
 
 // src/index.ts
 import crypto from "crypto";
@@ -9,11 +7,11 @@ import { SolvaPayError as SolvaPayError5 } from "@solvapay/core";
 // src/client.ts
 import { SolvaPayError } from "@solvapay/core";
 function createSolvaPayClient(opts) {
-  const base = opts.apiBaseUrl ?? "https://api-dev.solvapay.com";
+  const base = opts.apiBaseUrl ?? "https://api.solvapay.com";
   if (!opts.apiKey) throw new SolvaPayError("Missing apiKey");
   const headers = {
     "Content-Type": "application/json",
-    "Authorization": `Bearer ${opts.apiKey}`
+    Authorization: `Bearer ${opts.apiKey}`
   };
   const debug = process.env.SOLVAPAY_DEBUG === "true";
   const log = (...args) => {
@@ -68,9 +66,18 @@ function createSolvaPayClient(opts) {
       const result = await res.json();
       return result;
     },
-    // GET: /v1/sdk/customers/{reference}
+    // GET: /v1/sdk/customers/{reference} or /v1/sdk/customers?externalRef={externalRef}
     async getCustomer(params) {
-      const url = `${base}/v1/sdk/customers/${params.customerRef}`;
+      let url;
+      let isByExternalRef = false;
+      if (params.externalRef) {
+        url = `${base}/v1/sdk/customers?externalRef=${encodeURIComponent(params.externalRef)}`;
+        isByExternalRef = true;
+      } else if (params.customerRef) {
+        url = `${base}/v1/sdk/customers/${params.customerRef}`;
+      } else {
+        throw new SolvaPayError("Either customerRef or externalRef must be provided");
+      }
       const res = await fetch(url, {
         method: "GET",
         headers
@@ -81,28 +88,14 @@ function createSolvaPayClient(opts) {
         throw new SolvaPayError(`Get customer failed (${res.status}): ${error}`);
       }
       const result = await res.json();
-      return {
-        customerRef: result.reference || result.customerRef,
-        email: result.email,
-        name: result.name,
-        externalRef: result.externalRef,
-        subscriptions: result.subscriptions || []
-      };
-    },
-    // GET: /v1/sdk/customers?externalRef={externalRef}
-    async getCustomerByExternalRef(params) {
-      const url = `${base}/v1/sdk/customers?externalRef=${encodeURIComponent(params.externalRef)}`;
-      const res = await fetch(url, {
-        method: "GET",
-        headers
-      });
-      if (!res.ok) {
-        const error = await res.text();
-        log(`\u274C API Error: ${res.status} - ${error}`);
-        throw new SolvaPayError(`Get customer by externalRef failed (${res.status}): ${error}`);
+      let customer = result;
+      if (isByExternalRef) {
+        const customers = Array.isArray(result) ? result : result.customers || [];
+        if (customers.length === 0) {
+          throw new SolvaPayError(`No customer found with externalRef: ${params.externalRef}`);
+        }
+        customer = customers[0];
       }
-      const result = await res.json();
-      const customer = Array.isArray(result) ? result[0] : result;
       return {
         customerRef: customer.reference || customer.customerRef,
         email: customer.email,
@@ -280,7 +273,9 @@ function createSolvaPayClient(opts) {
           throw new SolvaPayError(`Subscription not found: ${error}`);
         }
         if (res.status === 400) {
-          throw new SolvaPayError(`Subscription cannot be cancelled or does not belong to provider: ${error}`);
+          throw new SolvaPayError(
+            `Subscription cannot be cancelled or does not belong to provider: ${error}`
+          );
         }
         throw new SolvaPayError(`Cancel subscription failed (${res.status}): ${error}`);
       }
@@ -290,7 +285,9 @@ function createSolvaPayClient(opts) {
         responseData = JSON.parse(responseText);
       } catch (parseError) {
         log(`\u274C Failed to parse response as JSON: ${parseError}`);
-        throw new SolvaPayError(`Invalid JSON response from cancel subscription endpoint: ${responseText.substring(0, 200)}`);
+        throw new SolvaPayError(
+          `Invalid JSON response from cancel subscription endpoint: ${responseText.substring(0, 200)}`
+        );
       }
       if (!responseData || typeof responseData !== "object") {
         log(`\u274C Invalid response structure: ${JSON.stringify(responseData)}`);
@@ -392,34 +389,35 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function createRequestDeduplicator(options = {}) {
-  const {
-    cacheTTL = 2e3,
-    maxCacheSize = 1e3,
-    cacheErrors = true
-  } = options;
+  const { cacheTTL = 2e3, maxCacheSize = 1e3, cacheErrors = true } = options;
   const inFlightRequests = /* @__PURE__ */ new Map();
   const resultCache = /* @__PURE__ */ new Map();
-  let cleanupInterval = null;
+  let _cleanupInterval = null;
   if (cacheTTL > 0) {
-    cleanupInterval = setInterval(() => {
-      const now = Date.now();
-      const entriesToDelete = [];
-      for (const [key, cached] of resultCache.entries()) {
-        if (now - cached.timestamp >= cacheTTL) {
-          entriesToDelete.push(key);
+    _cleanupInterval = setInterval(
+      () => {
+        const now = Date.now();
+        const entriesToDelete = [];
+        for (const [key, cached] of resultCache.entries()) {
+          if (now - cached.timestamp >= cacheTTL) {
+            entriesToDelete.push(key);
+          }
         }
-      }
-      for (const key of entriesToDelete) {
-        resultCache.delete(key);
-      }
-      if (resultCache.size > maxCacheSize) {
-        const sortedEntries = Array.from(resultCache.entries()).sort((a, b) => a[1].timestamp - b[1].timestamp);
-        const toRemove = sortedEntries.slice(0, resultCache.size - maxCacheSize);
-        for (const [key] of toRemove) {
+        for (const key of entriesToDelete) {
           resultCache.delete(key);
         }
-      }
-    }, Math.min(cacheTTL, 1e3));
+        if (resultCache.size > maxCacheSize) {
+          const sortedEntries = Array.from(resultCache.entries()).sort(
+            (a, b) => a[1].timestamp - b[1].timestamp
+          );
+          const toRemove = sortedEntries.slice(0, resultCache.size - maxCacheSize);
+          for (const [key] of toRemove) {
+            resultCache.delete(key);
+          }
+        }
+      },
+      Math.min(cacheTTL, 1e3)
+    );
   }
   const deduplicate = async (key, fn) => {
     if (cacheTTL > 0) {
@@ -482,7 +480,15 @@ function createRequestDeduplicator(options = {}) {
 }
 
 // src/paywall.ts
+import { readFileSync } from "fs";
+import { join } from "path";
 var PaywallError = class extends Error {
+  /**
+   * Creates a new PaywallError instance.
+   *
+   * @param message - Error message
+   * @param structuredContent - Structured content with checkout URLs and metadata
+   */
   constructor(message, structuredContent) {
     super(message);
     this.structuredContent = structuredContent;
@@ -516,7 +522,12 @@ var SolvaPayPaywall = class {
   }
   getPackageJsonName() {
     try {
-      const pkg = __require(process.cwd() + "/package.json");
+      if (typeof process === "undefined" || typeof process.cwd !== "function") {
+        return void 0;
+      }
+      const packageJsonPath = join(process.cwd(), "package.json");
+      const pkgContent = readFileSync(packageJsonPath, "utf-8");
+      const pkg = JSON.parse(pkgContent);
       return pkg.name;
     } catch {
       return void 0;
@@ -537,7 +548,12 @@ var SolvaPayPaywall = class {
       const startTime = Date.now();
       const requestId = this.generateRequestId();
       const inputCustomerRef = getCustomerRef ? getCustomerRef(args) : args.auth?.customer_ref || "anonymous";
-      const backendCustomerRef = await this.ensureCustomer(inputCustomerRef);
+      let backendCustomerRef;
+      if (inputCustomerRef.startsWith("cus_")) {
+        backendCustomerRef = inputCustomerRef;
+      } else {
+        backendCustomerRef = await this.ensureCustomer(inputCustomerRef, inputCustomerRef);
+      }
       try {
         const planRef = metadata.plan || toolName;
         const limitsCheck = await this.apiClient.checkLimits({
@@ -546,7 +562,15 @@ var SolvaPayPaywall = class {
         });
         if (!limitsCheck.withinLimits) {
           const latencyMs2 = Date.now() - startTime;
-          await this.trackUsage(backendCustomerRef, agent, planRef, toolName, "paywall", requestId, latencyMs2);
+          await this.trackUsage(
+            backendCustomerRef,
+            agent,
+            planRef,
+            toolName,
+            "paywall",
+            requestId,
+            latencyMs2
+          );
           throw new PaywallError("Payment required", {
             kind: "payment_required",
             agent,
@@ -556,7 +580,15 @@ var SolvaPayPaywall = class {
         }
         const result = await handler(args);
         const latencyMs = Date.now() - startTime;
-        await this.trackUsage(backendCustomerRef, agent, planRef, toolName, "success", requestId, latencyMs);
+        await this.trackUsage(
+          backendCustomerRef,
+          agent,
+          planRef,
+          toolName,
+          "success",
+          requestId,
+          latencyMs
+        );
         return result;
       } catch (error) {
         if (error instanceof Error) {
@@ -568,7 +600,15 @@ var SolvaPayPaywall = class {
         const latencyMs = Date.now() - startTime;
         const outcome = error instanceof PaywallError ? "paywall" : "fail";
         const planRef = metadata.plan || toolName;
-        await this.trackUsage(backendCustomerRef, agent, planRef, toolName, outcome, requestId, latencyMs);
+        await this.trackUsage(
+          backendCustomerRef,
+          agent,
+          planRef,
+          toolName,
+          outcome,
+          requestId,
+          latencyMs
+        );
         throw error;
       }
     };
@@ -578,7 +618,7 @@ var SolvaPayPaywall = class {
    * This is a public helper for testing, pre-creating customers, and internal use.
    * Only attempts creation once per customer (idempotent).
    * Returns the backend customer reference to use in API calls.
-   * 
+   *
    * @param customerRef - The customer reference used as a cache key (e.g., Supabase user ID)
    * @param externalRef - Optional external reference for backend lookup (e.g., Supabase user ID)
    *   If provided, will lookup existing customer by externalRef before creating new one.
@@ -592,62 +632,80 @@ var SolvaPayPaywall = class {
     if (customerRef === "anonymous") {
       return customerRef;
     }
+    if (customerRef.startsWith("cus_")) {
+      return customerRef;
+    }
     const cacheKey = externalRef || customerRef;
     if (this.customerRefMapping.has(customerRef)) {
       const cached = this.customerRefMapping.get(customerRef);
       return cached;
     }
-    const backendRef = await sharedCustomerLookupDeduplicator.deduplicate(
-      cacheKey,
-      async () => {
-        if (externalRef && this.apiClient.getCustomerByExternalRef) {
-          try {
-            const existingCustomer = await this.apiClient.getCustomerByExternalRef({ externalRef });
-            if (existingCustomer && existingCustomer.customerRef) {
-              const ref = existingCustomer.customerRef;
-              this.customerRefMapping.set(customerRef, ref);
-              this.customerCreationAttempts.add(customerRef);
-              if (externalRef !== customerRef) {
-                this.customerCreationAttempts.add(externalRef);
-              }
-              return ref;
-            }
-          } catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            if (!errorMessage.includes("404") && !errorMessage.includes("not found")) {
-              this.log(`\u26A0\uFE0F  Error looking up customer by externalRef: ${errorMessage}`);
+    const backendRef = await sharedCustomerLookupDeduplicator.deduplicate(cacheKey, async () => {
+      if (externalRef) {
+        try {
+          const existingCustomer = await this.apiClient.getCustomer({ externalRef });
+          if (existingCustomer && existingCustomer.customerRef) {
+            const ref = existingCustomer.customerRef;
+            this.customerRefMapping.set(customerRef, ref);
+            this.customerCreationAttempts.add(customerRef);
+            if (externalRef !== customerRef) {
+              this.customerCreationAttempts.add(externalRef);
             }
+            return ref;
+          }
+        } catch (error) {
+          const errorMessage = error instanceof Error ? error.message : String(error);
+          if (!errorMessage.includes("404") && !errorMessage.includes("not found")) {
+            this.log(`\u26A0\uFE0F  Error looking up customer by externalRef: ${errorMessage}`);
           }
         }
-        if (this.customerCreationAttempts.has(customerRef) || externalRef && this.customerCreationAttempts.has(externalRef)) {
-          const mappedRef = this.customerRefMapping.get(customerRef);
-          return mappedRef || customerRef;
+      }
+      if (this.customerCreationAttempts.has(customerRef) || externalRef && this.customerCreationAttempts.has(externalRef)) {
+        const mappedRef = this.customerRefMapping.get(customerRef);
+        return mappedRef || customerRef;
+      }
+      if (!this.apiClient.createCustomer) {
+        console.warn(
+          `\u26A0\uFE0F  Cannot auto-create customer ${customerRef}: createCustomer method not available on API client`
+        );
+        return customerRef;
+      }
+      this.customerCreationAttempts.add(customerRef);
+      try {
+        const createParams = {
+          email: options?.email || `${customerRef}-${Date.now()}@auto-created.local`
+        };
+        if (options?.name) {
+          createParams.name = options.name;
         }
-        if (!this.apiClient.createCustomer) {
-          console.warn(`\u26A0\uFE0F  Cannot auto-create customer ${customerRef}: createCustomer method not available on API client`);
-          return customerRef;
+        if (externalRef) {
+          createParams.externalRef = externalRef;
         }
-        this.customerCreationAttempts.add(customerRef);
-        try {
-          const createParams = {
-            email: options?.email || `${customerRef}@auto-created.local`
-          };
-          if (options?.name) {
-            createParams.name = options.name;
-          }
+        const result = await this.apiClient.createCustomer(createParams);
+        const ref = result.customerRef || result.reference || customerRef;
+        this.customerRefMapping.set(customerRef, ref);
+        return ref;
+      } catch (error) {
+        if (error.message && (error.message.includes("409") || error.message.includes("already exists"))) {
           if (externalRef) {
-            createParams.externalRef = externalRef;
+            try {
+              const searchResult = await this.apiClient.getCustomer({ externalRef });
+              if (searchResult && searchResult.customerRef) {
+                this.customerRefMapping.set(customerRef, searchResult.customerRef);
+                return searchResult.customerRef;
+              }
+            } catch (lookupError) {
+              this.log(`\u26A0\uFE0F Failed to lookup existing customer by externalRef after 409:`, lookupError instanceof Error ? lookupError.message : lookupError);
+            }
           }
-          const result = await this.apiClient.createCustomer(createParams);
-          const ref = result.customerRef || result.reference || customerRef;
-          this.customerRefMapping.set(customerRef, ref);
-          return ref;
-        } catch (error) {
-          this.log(`\u274C Failed to auto-create customer ${customerRef}:`, error instanceof Error ? error.message : error);
-          return customerRef;
         }
+        this.log(
+          `\u274C Failed to auto-create customer ${customerRef}:`,
+          error instanceof Error ? error.message : error
+        );
+        return customerRef;
       }
-    );
+    });
     if (backendRef !== customerRef) {
       this.customerRefMapping.set(customerRef, backendRef);
     }
@@ -669,7 +727,7 @@ var SolvaPayPaywall = class {
         maxRetries: 2,
         initialDelay: 500,
         shouldRetry: (error) => error.message.includes("Customer not found"),
-        // TODO: review if this is needed and what to check for 
+        // TODO: review if this is needed and what to check for
         onRetry: (error, attempt) => {
           console.warn(`\u26A0\uFE0F  Customer not found (attempt ${attempt + 1}/3), retrying in 500ms...`);
         }
@@ -689,9 +747,6 @@ var AdapterUtils = class {
     if (!customerRef || customerRef === "anonymous") {
       return "anonymous";
     }
-    if (!customerRef.startsWith("customer_") && !customerRef.startsWith("demo_")) {
-      return `customer_${customerRef.replace(/[^a-zA-Z0-9]/g, "_")}`;
-    }
     return customerRef;
   }
   /**
@@ -699,7 +754,7 @@ var AdapterUtils = class {
    */
   static async extractFromJWT(token, options) {
     try {
-      const { jwtVerify } = await import("./esm-5GYCIXIY.js");
+      const { jwtVerify } = await import("./esm-UW7WCMEK.js");
       const jwtSecret = new TextEncoder().encode(
         options?.secret || process.env.OAUTH_JWKS_SECRET || "test-jwt-secret"
       );
@@ -708,7 +763,7 @@ var AdapterUtils = class {
         audience: options?.audience || process.env.OAUTH_CLIENT_ID || "test-client-id"
       });
       return payload.sub || null;
-    } catch (error) {
+    } catch {
       return null;
     }
   }
@@ -822,7 +877,7 @@ var NextAdapter = class {
       if (request.method !== "GET" && request.headers.get("content-type")?.includes("application/json")) {
         body = await request.json();
       }
-    } catch (error) {
+    } catch {
     }
     let routeParams = {};
     if (context?.params) {
@@ -851,6 +906,10 @@ var NextAdapter = class {
         return AdapterUtils.ensureCustomerRef(jwtSub);
       }
     }
+    const userId = request.headers.get("x-user-id");
+    if (userId) {
+      return AdapterUtils.ensureCustomerRef(userId);
+    }
     const headerRef = request.headers.get("x-customer-ref");
     if (headerRef) {
       return AdapterUtils.ensureCustomerRef(headerRef);
@@ -866,24 +925,30 @@ var NextAdapter = class {
   }
   formatError(error, _context) {
     if (error instanceof PaywallError) {
-      return new Response(JSON.stringify({
+      return new Response(
+        JSON.stringify({
+          success: false,
+          error: "Payment required",
+          agent: error.structuredContent.agent,
+          checkoutUrl: error.structuredContent.checkoutUrl,
+          message: error.structuredContent.message
+        }),
+        {
+          status: 402,
+          headers: { "Content-Type": "application/json" }
+        }
+      );
+    }
+    return new Response(
+      JSON.stringify({
         success: false,
-        error: "Payment required",
-        agent: error.structuredContent.agent,
-        checkoutUrl: error.structuredContent.checkoutUrl,
-        message: error.structuredContent.message
-      }), {
-        status: 402,
+        error: error instanceof Error ? error.message : "Internal server error"
+      }),
+      {
+        status: 500,
         headers: { "Content-Type": "application/json" }
-      });
-    }
-    return new Response(JSON.stringify({
-      success: false,
-      error: error instanceof Error ? error.message : "Internal server error"
-    }), {
-      status: 500,
-      headers: { "Content-Type": "application/json" }
-    });
+      }
+    );
   }
 };
 
@@ -906,37 +971,51 @@ var McpAdapter = class {
   formatResponse(result, _context) {
     const transformed = this.options.transformResponse ? this.options.transformResponse(result) : result;
     return {
-      content: [{
-        type: "text",
-        text: JSON.stringify(transformed, null, 2)
-      }]
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(transformed, null, 2)
+        }
+      ]
     };
   }
   formatError(error, _context) {
     if (error instanceof PaywallError) {
       return {
-        content: [{
-          type: "text",
-          text: JSON.stringify({
-            success: false,
-            error: "Payment required",
-            agent: error.structuredContent.agent,
-            checkoutUrl: error.structuredContent.checkoutUrl,
-            message: error.structuredContent.message
-          }, null, 2)
-        }],
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: false,
+                error: "Payment required",
+                agent: error.structuredContent.agent,
+                checkoutUrl: error.structuredContent.checkoutUrl,
+                message: error.structuredContent.message
+              },
+              null,
+              2
+            )
+          }
+        ],
         isError: true,
         structuredContent: error.structuredContent
       };
     }
     return {
-      content: [{
-        type: "text",
-        text: JSON.stringify({
-          success: false,
-          error: error instanceof Error ? error.message : "Unknown error occurred"
-        }, null, 2)
-      }],
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: false,
+              error: error instanceof Error ? error.message : "Unknown error occurred"
+            },
+            null,
+            2
+          )
+        }
+      ],
       isError: true
     };
   }
@@ -944,6 +1023,8 @@ var McpAdapter = class {
 
 // src/factory.ts
 import { SolvaPayError as SolvaPayError2, getSolvaPayConfig } from "@solvapay/core";
+import { readFileSync as readFileSync2 } from "fs";
+import { join as join2 } from "path";
 function createSolvaPay(config) {
   let resolvedConfig;
   if (!config) {
@@ -994,9 +1075,6 @@ function createSolvaPay(config) {
       return apiClient.createCustomer(params);
     },
     getCustomer(params) {
-      if (!apiClient.getCustomer) {
-        throw new SolvaPayError2("getCustomer is not available on this API client");
-      }
       return apiClient.getCustomer(params);
     },
     createCheckoutSession(params) {
@@ -1015,12 +1093,7 @@ function createSolvaPay(config) {
         http(businessLogic, adapterOptions) {
           const adapter = new HttpAdapter(adapterOptions);
           return async (req, reply) => {
-            const handler = await createAdapterHandler(
-              adapter,
-              paywall,
-              metadata,
-              businessLogic
-            );
+            const handler = await createAdapterHandler(adapter, paywall, metadata, businessLogic);
             return handler([req, reply]);
           };
         },
@@ -1028,12 +1101,7 @@ function createSolvaPay(config) {
         next(businessLogic, adapterOptions) {
           const adapter = new NextAdapter(adapterOptions);
           return async (request, context) => {
-            const handler = await createAdapterHandler(
-              adapter,
-              paywall,
-              metadata,
-              businessLogic
-            );
+            const handler = await createAdapterHandler(adapter, paywall, metadata, businessLogic);
             return handler([request, context]);
           };
         },
@@ -1041,12 +1109,7 @@ function createSolvaPay(config) {
         mcp(businessLogic, adapterOptions) {
           const adapter = new McpAdapter(adapterOptions);
           return async (args) => {
-            const handler = await createAdapterHandler(
-              adapter,
-              paywall,
-              metadata,
-              businessLogic
-            );
+            const handler = await createAdapterHandler(adapter, paywall, metadata, businessLogic);
             return handler(args);
           };
         },
@@ -1061,7 +1124,12 @@ function createSolvaPay(config) {
 }
 function getPackageJsonName() {
   try {
-    const pkg = __require(process.cwd() + "/package.json");
+    if (typeof process === "undefined" || typeof process.cwd !== "function") {
+      return void 0;
+    }
+    const packageJsonPath = join2(process.cwd(), "package.json");
+    const pkgContent = readFileSync2(packageJsonPath, "utf-8");
+    const pkg = JSON.parse(pkgContent);
     return pkg.name;
   } catch {
     return void 0;
@@ -1076,10 +1144,11 @@ function isErrorResult(result) {
 function handleRouteError(error, operationName, defaultMessage) {
   console.error(`[${operationName}] Error:`, error);
   if (error instanceof SolvaPayError3) {
+    const errorMessage2 = error.message;
     return {
-      error: error.message,
+      error: errorMessage2,
       status: 500,
-      details: error.message
+      details: errorMessage2
     };
   }
   const errorMessage = error instanceof Error ? error.message : "Unknown error";
@@ -1222,11 +1291,20 @@ async function createCheckoutSessionCore(request, body, options = {}) {
       return customerResult;
     }
     const customerRef = customerResult;
+    let returnUrl = body.returnUrl || options.returnUrl;
+    if (!returnUrl) {
+      try {
+        const url = new URL(request.url);
+        returnUrl = url.origin;
+      } catch {
+      }
+    }
     const solvaPay = options.solvaPay || createSolvaPay();
     const session = await solvaPay.createCheckoutSession({
       agentRef: body.agentRef,
       customerRef,
-      planRef: body.planRef || void 0
+      planRef: body.planRef || void 0,
+      returnUrl
     });
     return {
       sessionId: session.sessionId,
@@ -1261,11 +1339,6 @@ async function createCustomerSessionCore(request, options = {}) {
 import { SolvaPayError as SolvaPayError4 } from "@solvapay/core";
 async function cancelSubscriptionCore(request, body, options = {}) {
   try {
-    const userResult = await getAuthenticatedUserCore(request);
-    if (isErrorResult(userResult)) {
-      return userResult;
-    }
-    const { userId } = userResult;
     if (!body.subscriptionRef) {
       return {
         error: "Missing required parameter: subscriptionRef is required",
@@ -1377,7 +1450,11 @@ async function listPlansCore(request) {
 }
 
 // src/index.ts
-function verifyWebhook({ body, signature, secret }) {
+function verifyWebhook({
+  body,
+  signature,
+  secret
+}) {
   const hmac = crypto.createHmac("sha256", secret).update(body).digest("hex");
   const ok = crypto.timingSafeEqual(Buffer.from(hmac), Buffer.from(signature));
   if (!ok) throw new SolvaPayError5("Invalid webhook signature");