@paykit-sdk/stripe 1.1.9 → 1.1.92

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { schema, validateRequiredKeys, AbstractPayKitProvider, NotImplementedError, createCustomerSchema, ValidationError, createSubscriptionSchema, InvalidTypeError, updateSubscriptionSchema, retrieveSubscriptionSchema, createPaymentSchema, updatePaymentSchema, retrievePaymentSchema, deletePaymentSchema, capturePaymentSchema, createRefundSchema, headersExtractor, WebhookError, paykitEvent$InboundSchema, billingModeSchema, invoiceStatusSchema, omitInternalMetadata } from '@paykit-sdk/core';
+import { schema, validateRequiredKeys, AbstractPayKitProvider, createCheckoutSchema, ValidationError, stringifyMetadataValues, InvalidTypeError, updateCheckoutSchema, ResourceNotFoundError, createCustomerSchema, createSubscriptionSchema, updateSubscriptionSchema, retrieveSubscriptionSchema, createPaymentSchema, PAYKIT_METADATA_KEY, updatePaymentSchema, retrievePaymentSchema, tryCatchAsync, deletePaymentSchema, capturePaymentSchema, createRefundSchema, WebhookError, paykitEvent$InboundSchema, billingModeSchema, omitInternalMetadata, invoiceStatusSchema } from '@paykit-sdk/core';
 import Stripe from 'stripe';
 
 var __defProp = Object.defineProperty;
@@ -4046,13 +4046,16 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-var paykitCheckout$InboundSchema = (checkout) => {
+var paykitCheckout$InboundSchema = (checkout, lineItems) => {
   return {
     id: checkout.id,
     customer: typeof checkout.customer === "string" ? checkout.customer : checkout.customer?.id ?? "",
     session_type: checkout.mode === "subscription" ? "recurring" : "one_time",
     payment_url: checkout.url,
-    products: checkout.line_items.data.map((item) => ({ id: item.price.id, quantity: item.quantity })),
+    products: lineItems.map((item) => ({
+      id: item.id,
+      quantity: item.quantity
+    })),
     currency: checkout.currency,
     amount: checkout.amount_total,
     subscription: null,
@@ -4071,10 +4074,13 @@ var paykitCustomer$InboundSchema = (customer) => {
 var paykitSubscription$InboundSchema = (subscription) => {
   const status = (() => {
     if (["active", "trialing"].includes(subscription.status)) return "active";
-    if (["incomplete_expired", "incomplete", "past_due"].includes(subscription.status)) return "past_due";
+    if (["incomplete_expired", "incomplete", "past_due"].includes(subscription.status)) {
+      return "past_due";
+    }
     if (["canceled"].includes(subscription.status)) return "canceled";
     if (["expired"].includes(subscription.status)) return "expired";
-    throw new Error(`Unknown status: ${subscription.status}`);
+    console.log(`Unknown subscription status: ${subscription.status}`);
+    return "pending";
   })();
   const metadata = omitInternalMetadata(subscription.metadata ?? {});
   return {
@@ -4094,7 +4100,8 @@ var paykitSubscription$InboundSchema = (subscription) => {
 var paykitInvoice$InboundSchema = (invoice) => {
   const status = (() => {
     if (invoice.status == "paid") return "paid";
-    if (["draft", "open", "uncollectible", "void"].includes(invoice.status)) return "open";
+    if (["draft", "open", "uncollectible", "void"].includes(invoice.status))
+      return "open";
     throw new Error(`Unknown status: ${invoice.status}`);
   })();
   const customerId = (() => {
@@ -4108,7 +4115,10 @@ var paykitInvoice$InboundSchema = (invoice) => {
     customer: customerId,
     billing_mode: invoice.billingMode,
     amount_paid: invoice.amount_paid,
-    line_items: invoice.lines.data.map((line) => ({ id: line.id, quantity: line.quantity })),
+    line_items: invoice.lines.data.map((line) => ({
+      id: line.id,
+      quantity: line.quantity
+    })),
     subscription_id: invoice.parent?.subscription_details?.subscription?.toString() ?? null,
     status,
     paid_at: new Date(invoice.created * 1e3).toISOString(),
@@ -4142,6 +4152,7 @@ var stripeToPaykitStatus = (status) => {
   }
 };
 var paykitPayment$InboundSchema = (intent) => {
+  const itemId = JSON.parse(intent.metadata?.[PAYKIT_METADATA_KEY] ?? "{}").itemId;
   return {
     id: intent.id,
     amount: intent.amount,
@@ -4149,7 +4160,7 @@ var paykitPayment$InboundSchema = (intent) => {
     customer: intent.customer ?? "",
     status: stripeToPaykitStatus(intent.status),
     metadata: omitInternalMetadata(intent.metadata ?? {}),
-    product_id: intent.metadata?.product_id
+    item_id: itemId
   };
 };
 var paykitRefund$InboundSchema = (refund) => {
@@ -4161,6 +4172,22 @@ var paykitRefund$InboundSchema = (refund) => {
     metadata: omitInternalMetadata(refund.metadata ?? {})
   };
 };
+var paykitRefundReason$OutboundSchema = (reason) => {
+  if (!reason) return void 0;
+  const normalized = reason.toLowerCase().trim();
+  if (/duplicate|duplicated|double.*charge|charged.*twice/i.test(normalized)) {
+    return "duplicate";
+  }
+  if (/fraud|fraudulent|unauthorized|scam|stolen.*card|not.*authorized/i.test(normalized)) {
+    return "fraudulent";
+  }
+  if (/customer.*request|requested.*customer|customer.*want|cancel|refund.*request|changed.*mind/i.test(
+    normalized
+  )) {
+    return "requested_by_customer";
+  }
+  return "requested_by_customer";
+};
 
 // src/stripe-provider.ts
 var stripeOptionsSchema = schema()(
@@ -4171,26 +4198,53 @@ var stripeOptionsSchema = schema()(
 );
 var providerName = "stripe";
 var StripeProvider = class extends AbstractPayKitProvider {
-  constructor(config) {
-    super(stripeOptionsSchema, config, providerName);
+  constructor(opts) {
+    super(stripeOptionsSchema, opts, providerName);
     this.providerName = providerName;
     /**
      * Checkout management
      */
     this.createCheckout = async (params) => {
-      const metadata = Object.fromEntries(Object.entries(params.metadata ?? {}).map(([key, value]) => [key, JSON.stringify(value)]));
+      const { error, data } = createCheckoutSchema.safeParse(params);
+      if (error) {
+        throw ValidationError.fromZodError(error, this.providerName, "createCheckout");
+      }
+      const checkoutMetadata = stringifyMetadataValues(data.metadata ?? {});
       const checkoutOptions = {
-        ...typeof params.customer === "string" && { customer: params.customer },
-        ...typeof params.customer === "object" && { customer: params.customer.email },
-        mode: params.session_type === "one_time" ? "payment" : "subscription",
-        line_items: [{ price: params.item_id, quantity: params.quantity }],
-        ...params.session_type == "one_time" && { metadata },
-        ...params.session_type == "recurring" && { subscription_data: { metadata } },
-        ...params.provider_metadata
+        ...data.provider_metadata,
+        mode: data.session_type === "one_time" ? "payment" : "subscription",
+        line_items: [{ price: data.item_id, quantity: data.quantity }],
+        success_url: data.success_url,
+        cancel_url: data.cancel_url
       };
+      if (params.session_type == "recurring") {
+        checkoutOptions.subscription_data = { metadata: checkoutMetadata };
+      } else if (params.session_type == "one_time") {
+        checkoutOptions.metadata = checkoutMetadata;
+        checkoutOptions.payment_intent_data = {
+          setup_future_usage: "off_session"
+        };
+      }
+      if (typeof params.customer === "string") {
+        checkoutOptions.customer = params.customer;
+      } else if (typeof params.customer === "object" && "email" in params.customer) {
+        checkoutOptions.customer_email = params.customer.email;
+      } else {
+        throw new InvalidTypeError(
+          "customer",
+          "string (customer ID) or object (customer) with email",
+          "object",
+          {
+            provider: this.providerName,
+            method: "createCheckout"
+          }
+        );
+      }
       if (params.billing) {
         checkoutOptions.shipping_address_collection = {
-          allowed_countries: [params.billing.address.country]
+          allowed_countries: [
+            params.billing.address.country
+          ]
         };
         checkoutOptions.shipping_options = [
           {
@@ -4203,18 +4257,48 @@ var StripeProvider = class extends AbstractPayKitProvider {
         ];
       }
       const checkout = await this.stripe.checkout.sessions.create(checkoutOptions);
-      return paykitCheckout$InboundSchema(checkout);
+      return paykitCheckout$InboundSchema(checkout, [
+        { id: params.item_id, quantity: params.quantity }
+      ]);
     };
     this.retrieveCheckout = async (id) => {
-      const checkout = await this.stripe.checkout.sessions.retrieve(id);
-      return paykitCheckout$InboundSchema(checkout);
+      const checkout = await this.stripe.checkout.sessions.retrieve(id, {
+        expand: ["line_items"]
+      });
+      return paykitCheckout$InboundSchema(
+        checkout,
+        checkout.line_items?.data.map((item) => ({
+          id: item.price?.id ?? "",
+          quantity: item.quantity ?? 0
+        })) ?? []
+      );
     };
     this.updateCheckout = async (id, params) => {
-      const checkout = await this.stripe.checkout.sessions.update(id, params);
-      return paykitCheckout$InboundSchema(checkout);
+      const { error, data } = updateCheckoutSchema.safeParse(params);
+      if (error) {
+        throw ValidationError.fromZodError(error, this.providerName, "updateCheckout");
+      }
+      const originalCheckout = await this.stripe.checkout.sessions.retrieve(id, {
+        expand: ["line_items"]
+      });
+      if (!originalCheckout) {
+        throw new ResourceNotFoundError("checkout", id, this.providerName);
+      }
+      const updatedCheckout = await this.stripe.checkout.sessions.update(id, {
+        ...data,
+        metadata: stringifyMetadataValues(data.metadata ?? {})
+      });
+      return paykitCheckout$InboundSchema(
+        updatedCheckout,
+        updatedCheckout.line_items?.data.map((item) => ({
+          id: item.price?.id ?? "",
+          quantity: item.quantity ?? 0
+        })) ?? []
+      );
     };
     this.deleteCheckout = async (id) => {
-      throw new NotImplementedError("deleteCheckout", "stripe", { futureSupport: false });
+      await this.stripe.checkout.sessions.expire(id);
+      return null;
     };
     /**
      * Customer management
@@ -4230,7 +4314,11 @@ var StripeProvider = class extends AbstractPayKitProvider {
     };
     this.updateCustomer = async (id, params) => {
       const { provider_metadata, ...rest } = params;
-      const customer = await this.stripe.customers.update(id, { ...rest, ...provider_metadata });
+      const customer = await this.stripe.customers.update(id, {
+        ...provider_metadata,
+        ...rest,
+        metadata: stringifyMetadataValues(rest.metadata ?? {})
+      });
       return paykitCustomer$InboundSchema(customer);
     };
     this.deleteCustomer = async (id) => {
@@ -4256,11 +4344,20 @@ var StripeProvider = class extends AbstractPayKitProvider {
           method: "createSubscription"
         });
       }
+      if (this.opts.debug) {
+        console.info(
+          "Creating subscription with default payment method, this can be overridden by passing `default_payment_method` in the provider_metadata e.g pm_xxx"
+        );
+      }
+      const defaultPaymentMethod = data.provider_metadata?.default_payment_method;
       const subscription = await this.stripe.subscriptions.create({
+        ...data.provider_metadata,
+        ...defaultPaymentMethod && { default_payment_method: defaultPaymentMethod },
         customer: data.customer,
         items: [{ price: data.item_id }],
-        metadata: Object.fromEntries(Object.entries(data.metadata ?? {}).map(([key, value]) => [key, JSON.stringify(value)])),
-        ...data.provider_metadata
+        metadata: stringifyMetadataValues(data.metadata ?? {}),
+        payment_behavior: "default_incomplete"
+        // customer's default payment method will be used if available
       });
       return paykitSubscription$InboundSchema(subscription);
     };
@@ -4273,19 +4370,19 @@ var StripeProvider = class extends AbstractPayKitProvider {
       if (error) {
         throw ValidationError.fromZodError(error, this.providerName, "updateSubscription");
       }
-      const subscription = await this.stripe.subscriptions.retrieve(id);
-      const metadata = Object.fromEntries(
-        Object.entries({ ...subscription.metadata ?? {}, ...data.metadata ?? {} }).map(([key, value]) => [key, JSON.stringify(value)])
-      );
       const updatedSubscription = await this.stripe.subscriptions.update(id, {
-        metadata
+        metadata: stringifyMetadataValues(data.metadata ?? {})
       });
       return paykitSubscription$InboundSchema(updatedSubscription);
     };
     this.retrieveSubscription = async (id) => {
       const { error, data } = retrieveSubscriptionSchema.safeParse({ id });
       if (error) {
-        throw ValidationError.fromZodError(error, this.providerName, "retrieveSubscription");
+        throw ValidationError.fromZodError(
+          error,
+          this.providerName,
+          "retrieveSubscription"
+        );
       }
       const subscription = await this.stripe.subscriptions.retrieve(data.id);
       return paykitSubscription$InboundSchema(subscription);
@@ -4303,20 +4400,56 @@ var StripeProvider = class extends AbstractPayKitProvider {
      */
     this.createPayment = async (params) => {
       const { error, data } = createPaymentSchema.safeParse(params);
-      if (error) throw new ValidationError(error.message.split("\n").join(" "), { provider: this.providerName, method: "createPayment" });
-      const { provider_metadata, customer, ...rest } = data;
+      if (error)
+        throw new ValidationError(error.message.split("\n").join(" "), {
+          provider: this.providerName,
+          method: "createPayment"
+        });
+      const { provider_metadata, customer, capture_method, ...rest } = data;
       if (typeof customer === "object") {
         throw new InvalidTypeError("customer", "string (customer ID)", "object", {
           provider: this.providerName,
           method: "createPayment"
         });
       }
-      const metadata = Object.fromEntries(
-        Object.entries({ ...rest.metadata ?? {}, ...provider_metadata?.metadata ?? {}, product_id: params.product_id ?? null }).map(
-          ([key, value]) => [key, JSON.stringify(value)]
-        )
+      const paymentMetadata = stringifyMetadataValues({
+        ...rest.metadata,
+        ...provider_metadata?.metadata ?? {},
+        [PAYKIT_METADATA_KEY]: JSON.stringify({ itemId: data.item_id ?? null })
+      });
+      const customerWithDefaultPaymentMethod = await this.stripe.customers.retrieve(
+        customer,
+        { expand: ["invoice_settings.default_payment_method"] }
       );
-      const paymentIntentOptions = { ...provider_metadata, ...rest, metadata, customer };
+      if ("deleted" in customerWithDefaultPaymentMethod) {
+        throw new ValidationError("Customer has been deleted", {
+          provider: this.providerName,
+          method: "createPayment"
+        });
+      }
+      let defaultPaymentMethod = customerWithDefaultPaymentMethod.invoice_settings?.default_payment_method;
+      if (!defaultPaymentMethod) {
+        const paymentMethods = await this.stripe.paymentMethods.list({ customer });
+        if (paymentMethods.data.length === 0) {
+          throw new ValidationError(
+            `Customer ${customer} has no payment methods. Add a payment method for the customer before creating a payment intent`,
+            { provider: this.providerName, method: "createPayment" }
+          );
+        }
+        defaultPaymentMethod = paymentMethods.data[0].id;
+      }
+      const paymentIntentOptions = {
+        currency: rest.currency,
+        amount: rest.amount,
+        metadata: paymentMetadata,
+        customer,
+        capture_method,
+        confirm: true,
+        // automatically confirms the payment
+        payment_method: defaultPaymentMethod,
+        off_session: true
+        // uses customer's default payment method, avoids 3Ds/authentication
+      };
       if (data.billing) {
         paymentIntentOptions.shipping = {
           name: data.billing.address.name,
@@ -4340,21 +4473,38 @@ var StripeProvider = class extends AbstractPayKitProvider {
         throw ValidationError.fromZodError(error, this.providerName, "updatePayment");
       }
       const { provider_metadata, customer, ...rest } = data;
-      if (typeof customer === "object") {
-        throw new InvalidTypeError("customer", "string (customer ID)", "object", {
-          provider: this.providerName,
-          method: "updatePayment"
-        });
+      const payment = await this.stripe.paymentIntents.retrieve(id);
+      const paymentOptions = {
+        ...provider_metadata,
+        metadata: stringifyMetadataValues({
+          ...rest.metadata,
+          ...provider_metadata?.metadata ?? {}
+        })
+      };
+      if (["requires_payment_method", "requires_confirmation", "requires_action"].includes(
+        payment.status
+      )) {
+        paymentOptions.amount = rest.amount;
+        paymentOptions.currency = rest.currency;
       }
-      const payment = await this.stripe.paymentIntents.update(id, { ...rest, ...provider_metadata, customer });
-      return paykitPayment$InboundSchema(payment);
+      if (typeof customer === "string") {
+        paymentOptions.customer = customer;
+      } else if (typeof customer == "object" && "email" in customer) {
+        paymentOptions.receipt_email = customer.email;
+      }
+      const updatedPayment = await this.stripe.paymentIntents.update(id, paymentOptions);
+      return paykitPayment$InboundSchema(updatedPayment);
     };
     this.retrievePayment = async (id) => {
       const { error, data } = retrievePaymentSchema.safeParse({ id });
       if (error) {
         throw ValidationError.fromZodError(error, this.providerName, "retrievePayment");
       }
-      const payment = await this.stripe.paymentIntents.retrieve(data.id);
+      const [payment, paymentError] = await tryCatchAsync(
+        this.stripe.paymentIntents.retrieve(data.id)
+      );
+      if (!payment || paymentError?.code === "resource_missing")
+        return null;
       return paykitPayment$InboundSchema(payment);
     };
     this.deletePayment = async (id) => {
@@ -4367,13 +4517,17 @@ var StripeProvider = class extends AbstractPayKitProvider {
     };
     this.capturePayment = async (id, params) => {
       const { error, data } = capturePaymentSchema.safeParse(params);
-      if (error) throw new ValidationError(error.message, { provider: this.providerName, method: "capturePayment" });
-      const payment = await this.stripe.paymentIntents.capture(id, { amount_to_capture: data.amount });
+      if (error) {
+        throw ValidationError.fromZodError(error, this.providerName, "capturePayment");
+      }
+      const payment = await this.stripe.paymentIntents.capture(id, {
+        amount_to_capture: data.amount
+      });
       return paykitPayment$InboundSchema(payment);
     };
     this.cancelPayment = async (id) => {
-      const payment = await this.stripe.paymentIntents.cancel(id);
-      return paykitPayment$InboundSchema(payment);
+      const canceledPayment = await this.stripe.paymentIntents.cancel(id);
+      return paykitPayment$InboundSchema(canceledPayment);
     };
     /**
      * Refund management
@@ -4383,8 +4537,19 @@ var StripeProvider = class extends AbstractPayKitProvider {
       if (error) {
         throw ValidationError.fromZodError(error, this.providerName, "createRefund");
       }
-      const { provider_metadata, ...rest } = params;
-      const refund = await this.stripe.refunds.create({ ...rest, reason: rest.reason, ...provider_metadata });
+      const { provider_metadata, ...rest } = data;
+      const stripeRefundOptions = {
+        ...provider_metadata,
+        reason: paykitRefundReason$OutboundSchema(rest.reason),
+        amount: rest.amount,
+        metadata: stringifyMetadataValues(rest.metadata ?? {})
+      };
+      if (data.payment_id.startsWith("pi_")) {
+        stripeRefundOptions.payment_intent = data.payment_id;
+      } else {
+        stripeRefundOptions.charge = data.payment_id;
+      }
+      const refund = await this.stripe.refunds.create(stripeRefundOptions);
       return paykitRefund$InboundSchema(refund);
     };
     /**
@@ -4392,9 +4557,17 @@ var StripeProvider = class extends AbstractPayKitProvider {
      */
     this.handleWebhook = async (params) => {
       const { body, headers, webhookSecret } = params;
-      const stripeHeaders = headersExtractor(headers, ["x-stripe-signature"]);
-      const signature = stripeHeaders[0].value;
-      const event = this.stripe.webhooks.constructEvent(body, signature, webhookSecret);
+      const stripeSignature = headers.get("stripe-signature");
+      if (!stripeSignature) {
+        throw new WebhookError("Missing Stripe signature", {
+          provider: this.providerName
+        });
+      }
+      const event = this.stripe.webhooks.constructEvent(
+        body,
+        stripeSignature,
+        webhookSecret
+      );
       const stripePaymentIntentUpdateEventsWithHandlers = [
         "payment_intent.processing",
         "payment_intent.requires_action",
@@ -4429,20 +4602,29 @@ var StripeProvider = class extends AbstractPayKitProvider {
             paid_at: new Date(event2.created * 1e3).toISOString(),
             amount_paid: data.amount_total ?? 0,
             currency: data.currency ?? "",
-            metadata: Object.fromEntries(Object.entries(data.metadata ?? {}).map(([key, value]) => [key, JSON.stringify(value)])),
+            metadata: omitInternalMetadata(data.metadata ?? {}),
             customer: typeof data.customer === "string" ? data.customer : data.customer?.id ?? "",
             billing_mode: billingModeSchema.parse("one_time"),
             subscription_id: null,
             custom_fields: customFields ?? null,
-            line_items: data.line_items?.data.map((item) => ({ id: item.price.id, quantity: item.quantity })) ?? []
+            line_items: data.line_items?.data.map((item) => ({
+              id: item.price.id,
+              quantity: item.quantity
+            })) ?? []
+          };
+          const invoice = {
+            type: "invoice.generated",
+            created: event2.created,
+            id: event2.id,
+            data: invoiceData
           };
-          const invoice = { type: "invoice.generated", created: event2.created, id: event2.id, data: invoiceData };
           return [paykitEvent$InboundSchema(invoice)];
         },
         "invoice.paid": async (event2) => {
           const data = event2.data.object;
           const relevantBillingReasons = ["subscription_create", "subscription_cycle"];
-          if (data.status !== "paid" && !relevantBillingReasons.includes(data.billing_reason)) return null;
+          if (data.status !== "paid" && !relevantBillingReasons.includes(data.billing_reason))
+            return null;
           const invoice = {
             type: "invoice.generated",
             created: event2.created,
@@ -4456,16 +4638,31 @@ var StripeProvider = class extends AbstractPayKitProvider {
          */
         "customer.created": async (event2) => {
           const data = event2.data.object;
-          const customer = { type: "customer.created", created: event2.created, id: event2.id, data: paykitCustomer$InboundSchema(data) };
+          const customer = {
+            type: "customer.created",
+            created: event2.created,
+            id: event2.id,
+            data: paykitCustomer$InboundSchema(data)
+          };
           return [paykitEvent$InboundSchema(customer)];
         },
         "customer.updated": async (event2) => {
           const data = event2.data.object;
-          const customer = { type: "customer.updated", created: event2.created, id: event2.id, data: paykitCustomer$InboundSchema(data) };
+          const customer = {
+            type: "customer.updated",
+            created: event2.created,
+            id: event2.id,
+            data: paykitCustomer$InboundSchema(data)
+          };
           return [paykitEvent$InboundSchema(customer)];
         },
         "customer.deleted": async (event2) => {
-          const customer = { type: "customer.deleted", created: event2.created, id: event2.id, data: null };
+          const customer = {
+            type: "customer.deleted",
+            created: event2.created,
+            id: event2.id,
+            data: null
+          };
           return [paykitEvent$InboundSchema(customer)];
         },
         /**
@@ -4474,46 +4671,104 @@ var StripeProvider = class extends AbstractPayKitProvider {
         "customer.subscription.created": async (event2) => {
           const data = event2.data.object;
           const subscription = paykitSubscription$InboundSchema(data);
-          return [paykitEvent$InboundSchema({ type: "subscription.created", created: event2.created, id: event2.id, data: subscription })];
+          return [
+            paykitEvent$InboundSchema({
+              type: "subscription.created",
+              created: event2.created,
+              id: event2.id,
+              data: subscription
+            })
+          ];
         },
         "customer.subscription.updated": async (event2) => {
           const data = event2.data.object;
           const subscription = paykitSubscription$InboundSchema(data);
-          return [paykitEvent$InboundSchema({ type: "subscription.updated", created: event2.created, id: event2.id, data: subscription })];
+          return [
+            paykitEvent$InboundSchema({
+              type: "subscription.updated",
+              created: event2.created,
+              id: event2.id,
+              data: subscription
+            })
+          ];
         },
         "customer.subscription.deleted": async (event2) => {
           const subscription = null;
-          return [paykitEvent$InboundSchema({ type: "subscription.canceled", created: event2.created, id: event2.id, data: subscription })];
+          return [
+            paykitEvent$InboundSchema({
+              type: "subscription.canceled",
+              created: event2.created,
+              id: event2.id,
+              data: subscription
+            })
+          ];
         },
         "payment_intent.created": async (event2) => {
           const data = event2.data.object;
           const payment = paykitPayment$InboundSchema(data);
-          return [paykitEvent$InboundSchema({ type: "payment.created", created: event2.created, id: event2.id, data: payment })];
+          return [
+            paykitEvent$InboundSchema({
+              type: "payment.created",
+              created: event2.created,
+              id: event2.id,
+              data: payment
+            })
+          ];
         },
-        ...stripePaymentIntentUpdateEventsWithHandlers.map(() => async (event2) => {
-          const data = event2.data.object;
-          const payment = paykitPayment$InboundSchema(data);
-          return [paykitEvent$InboundSchema({ type: "payment.updated", created: event2.created, id: event2.id, data: payment })];
-        }),
+        ...stripePaymentIntentUpdateEventsWithHandlers.map(
+          () => async (event2) => {
+            const data = event2.data.object;
+            const payment = paykitPayment$InboundSchema(data);
+            return [
+              paykitEvent$InboundSchema({
+                type: "payment.updated",
+                created: event2.created,
+                id: event2.id,
+                data: payment
+              })
+            ];
+          }
+        ),
         "payment_intent.canceled": async (event2) => {
           const data = event2.data.object;
           const payment = paykitPayment$InboundSchema(data);
-          return [paykitEvent$InboundSchema({ type: "payment.canceled", created: event2.created, id: event2.id, data: payment })];
+          return [
+            paykitEvent$InboundSchema({
+              type: "payment.canceled",
+              created: event2.created,
+              id: event2.id,
+              data: payment
+            })
+          ];
         },
         "refund.created": async (event2) => {
           const data = event2.data.object;
           const refund = paykitRefund$InboundSchema(data);
-          return [paykitEvent$InboundSchema({ type: "refund.created", created: event2.created, id: event2.id, data: refund })];
+          return [
+            paykitEvent$InboundSchema({
+              type: "refund.created",
+              created: event2.created,
+              id: event2.id,
+              data: refund
+            })
+          ];
         }
       };
       const handler = webhookHandlers[event.type];
-      if (!handler) throw new WebhookError(`Unhandled event type: ${event.type}`, { provider: this.providerName });
+      if (!handler)
+        throw new WebhookError(`Unhandled event type: ${event.type}`, {
+          provider: this.providerName
+        });
       const result = await handler(event);
-      if (!result) throw new WebhookError(`Unhandled event type: ${event.type}`, { provider: this.providerName });
+      if (!result)
+        throw new WebhookError(`Unhandled event type: ${event.type}`, {
+          provider: this.providerName
+        });
       return result;
     };
-    const { debug, apiKey, ...rest } = config;
+    const { debug = true, apiKey, ...rest } = opts;
     this.stripe = new Stripe(apiKey, rest);
+    this.opts = opts;
   }
 };
 
@@ -4522,9 +4777,17 @@ var createStripe = (config) => {
   return new StripeProvider(config);
 };
 var stripe = () => {
-  const envVars = validateRequiredKeys(["STRIPE_API_KEY"], process.env, "Missing required environment variables: {keys}");
+  const envVars = validateRequiredKeys(
+    ["STRIPE_API_KEY"],
+    process.env,
+    "Missing required environment variables: {keys}"
+  );
   const isSandbox = process.env.NODE_ENV === "development";
-  return createStripe({ apiKey: envVars.STRIPE_API_KEY, debug: isSandbox, apiVersion: "2025-07-30.basil" });
+  return createStripe({
+    apiKey: envVars.STRIPE_API_KEY,
+    debug: isSandbox,
+    apiVersion: "2025-07-30.basil"
+  });
 };
 
 export { createStripe, stripe };

package/dist/stripe-provider.d.mts

@@ -6,7 +6,8 @@ interface StripeOptions extends PaykitProviderOptions<Stripe.StripeConfig> {
 }
 declare class StripeProvider extends AbstractPayKitProvider implements PayKitProvider {
     private stripe;
-    constructor(config: StripeOptions);
+    private opts;
+    constructor(opts: StripeOptions);
     readonly providerName = "stripe";
     /**
      * Checkout management