@better-auth/stripe 1.3.28 → 1.3.30

package/.turbo/turbo-build.log

@@ -1,17 +1,17 @@
 
-> @better-auth/stripe@1.3.28 build /home/runner/work/better-auth/better-auth/packages/stripe
+> @better-auth/stripe@1.3.30 build /home/runner/work/better-auth/better-auth/packages/stripe
 > unbuild
 
 [info] Automatically detected entries: src/index, src/client [esm] [cjs] [dts]
 [info] Building stripe
 [success] Build succeeded for stripe
-[log]   dist/index.cjs (total size: 49.2 kB, chunk size: 49.2 kB, exports: stripe)
+[log]   dist/index.cjs (total size: 49.4 kB, chunk size: 49.4 kB, exports: stripe)
 
 [log]   dist/client.cjs (total size: 270 B, chunk size: 270 B, exports: stripeClient)
 
-[log]   dist/index.mjs (total size: 48.3 kB, chunk size: 48.3 kB, exports: stripe)
+[log]   dist/index.mjs (total size: 48.5 kB, chunk size: 48.5 kB, exports: stripe)
 
 [log]   dist/client.mjs (total size: 243 B, chunk size: 243 B, exports: stripeClient)
 
-Σ Total dist size (byte size): 236 kB
+Σ Total dist size (byte size): 238 kB
 [log]

package/dist/index.cjs

@@ -1319,11 +1319,15 @@ const stripe = (options) => {
                 message: "Stripe webhook secret not found"
               });
             }
-            event = await client.webhooks.constructEventAsync(
-              buf,
-              sig,
-              webhookSecret
-            );
+            if (typeof client.webhooks.constructEventAsync === "function") {
+              event = await client.webhooks.constructEventAsync(
+                buf,
+                sig,
+                webhookSecret
+              );
+            } else {
+              event = client.webhooks.constructEvent(buf, sig, webhookSecret);
+            }
           } catch (err) {
             ctx.context.logger.error(`${err.message}`);
             throw new api.APIError("BAD_REQUEST", {

package/dist/index.d.cts

@@ -460,6 +460,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     amount_total: number | null;
                     automatic_tax: Stripe.Checkout.Session.AutomaticTax;
                     billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+                    branding_settings?: Stripe.Checkout.Session.BrandingSettings;
                     cancel_url: string | null;
                     client_reference_id: string | null;
                     client_secret: string | null;
@@ -476,6 +477,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     customer_details: Stripe.Checkout.Session.CustomerDetails | null;
                     customer_email: string | null;
                     discounts: Array<Stripe.Checkout.Session.Discount> | null;
+                    excluded_payment_method_types?: Array<string>;
                     expires_at: number;
                     invoice: string | Stripe.Invoice | null;
                     invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
@@ -484,6 +486,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     locale: Stripe.Checkout.Session.Locale | null;
                     metadata: Stripe.Metadata | null;
                     mode: Stripe.Checkout.Session.Mode;
+                    name_collection?: Stripe.Checkout.Session.NameCollection;
                     optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
                     origin_context: Stripe.Checkout.Session.OriginContext | null;
                     payment_intent: string | Stripe.PaymentIntent | null;
@@ -538,6 +541,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 amount_total: number | null;
                 automatic_tax: Stripe.Checkout.Session.AutomaticTax;
                 billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+                branding_settings?: Stripe.Checkout.Session.BrandingSettings;
                 cancel_url: string | null;
                 client_reference_id: string | null;
                 client_secret: string | null;
@@ -554,6 +558,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 customer_details: Stripe.Checkout.Session.CustomerDetails | null;
                 customer_email: string | null;
                 discounts: Array<Stripe.Checkout.Session.Discount> | null;
+                excluded_payment_method_types?: Array<string>;
                 expires_at: number;
                 invoice: string | Stripe.Invoice | null;
                 invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
@@ -562,6 +567,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 locale: Stripe.Checkout.Session.Locale | null;
                 metadata: Stripe.Metadata | null;
                 mode: Stripe.Checkout.Session.Mode;
+                name_collection?: Stripe.Checkout.Session.NameCollection;
                 optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
                 origin_context: Stripe.Checkout.Session.OriginContext | null;
                 payment_intent: string | Stripe.PaymentIntent | null;

package/dist/index.d.mts

@@ -460,6 +460,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     amount_total: number | null;
                     automatic_tax: Stripe.Checkout.Session.AutomaticTax;
                     billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+                    branding_settings?: Stripe.Checkout.Session.BrandingSettings;
                     cancel_url: string | null;
                     client_reference_id: string | null;
                     client_secret: string | null;
@@ -476,6 +477,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     customer_details: Stripe.Checkout.Session.CustomerDetails | null;
                     customer_email: string | null;
                     discounts: Array<Stripe.Checkout.Session.Discount> | null;
+                    excluded_payment_method_types?: Array<string>;
                     expires_at: number;
                     invoice: string | Stripe.Invoice | null;
                     invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
@@ -484,6 +486,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     locale: Stripe.Checkout.Session.Locale | null;
                     metadata: Stripe.Metadata | null;
                     mode: Stripe.Checkout.Session.Mode;
+                    name_collection?: Stripe.Checkout.Session.NameCollection;
                     optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
                     origin_context: Stripe.Checkout.Session.OriginContext | null;
                     payment_intent: string | Stripe.PaymentIntent | null;
@@ -538,6 +541,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 amount_total: number | null;
                 automatic_tax: Stripe.Checkout.Session.AutomaticTax;
                 billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+                branding_settings?: Stripe.Checkout.Session.BrandingSettings;
                 cancel_url: string | null;
                 client_reference_id: string | null;
                 client_secret: string | null;
@@ -554,6 +558,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 customer_details: Stripe.Checkout.Session.CustomerDetails | null;
                 customer_email: string | null;
                 discounts: Array<Stripe.Checkout.Session.Discount> | null;
+                excluded_payment_method_types?: Array<string>;
                 expires_at: number;
                 invoice: string | Stripe.Invoice | null;
                 invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
@@ -562,6 +567,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 locale: Stripe.Checkout.Session.Locale | null;
                 metadata: Stripe.Metadata | null;
                 mode: Stripe.Checkout.Session.Mode;
+                name_collection?: Stripe.Checkout.Session.NameCollection;
                 optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
                 origin_context: Stripe.Checkout.Session.OriginContext | null;
                 payment_intent: string | Stripe.PaymentIntent | null;

package/dist/index.d.ts

@@ -460,6 +460,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     amount_total: number | null;
                     automatic_tax: Stripe.Checkout.Session.AutomaticTax;
                     billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+                    branding_settings?: Stripe.Checkout.Session.BrandingSettings;
                     cancel_url: string | null;
                     client_reference_id: string | null;
                     client_secret: string | null;
@@ -476,6 +477,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     customer_details: Stripe.Checkout.Session.CustomerDetails | null;
                     customer_email: string | null;
                     discounts: Array<Stripe.Checkout.Session.Discount> | null;
+                    excluded_payment_method_types?: Array<string>;
                     expires_at: number;
                     invoice: string | Stripe.Invoice | null;
                     invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
@@ -484,6 +486,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                     locale: Stripe.Checkout.Session.Locale | null;
                     metadata: Stripe.Metadata | null;
                     mode: Stripe.Checkout.Session.Mode;
+                    name_collection?: Stripe.Checkout.Session.NameCollection;
                     optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
                     origin_context: Stripe.Checkout.Session.OriginContext | null;
                     payment_intent: string | Stripe.PaymentIntent | null;
@@ -538,6 +541,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 amount_total: number | null;
                 automatic_tax: Stripe.Checkout.Session.AutomaticTax;
                 billing_address_collection: Stripe.Checkout.Session.BillingAddressCollection | null;
+                branding_settings?: Stripe.Checkout.Session.BrandingSettings;
                 cancel_url: string | null;
                 client_reference_id: string | null;
                 client_secret: string | null;
@@ -554,6 +558,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 customer_details: Stripe.Checkout.Session.CustomerDetails | null;
                 customer_email: string | null;
                 discounts: Array<Stripe.Checkout.Session.Discount> | null;
+                excluded_payment_method_types?: Array<string>;
                 expires_at: number;
                 invoice: string | Stripe.Invoice | null;
                 invoice_creation: Stripe.Checkout.Session.InvoiceCreation | null;
@@ -562,6 +567,7 @@ declare const stripe: <O extends StripeOptions>(options: O) => {
                 locale: Stripe.Checkout.Session.Locale | null;
                 metadata: Stripe.Metadata | null;
                 mode: Stripe.Checkout.Session.Mode;
+                name_collection?: Stripe.Checkout.Session.NameCollection;
                 optional_items?: Array<Stripe.Checkout.Session.OptionalItem> | null;
                 origin_context: Stripe.Checkout.Session.OriginContext | null;
                 payment_intent: string | Stripe.PaymentIntent | null;

package/dist/index.mjs

@@ -1303,11 +1303,15 @@ const stripe = (options) => {
                 message: "Stripe webhook secret not found"
               });
             }
-            event = await client.webhooks.constructEventAsync(
-              buf,
-              sig,
-              webhookSecret
-            );
+            if (typeof client.webhooks.constructEventAsync === "function") {
+              event = await client.webhooks.constructEventAsync(
+                buf,
+                sig,
+                webhookSecret
+              );
+            } else {
+              event = client.webhooks.constructEvent(buf, sig, webhookSecret);
+            }
           } catch (err) {
             ctx.context.logger.error(`${err.message}`);
             throw new APIError("BAD_REQUEST", {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@better-auth/stripe",
   "author": "Bereket Engida",
-  "version": "1.3.28",
+  "version": "1.3.30",
   "main": "dist/index.cjs",
   "license": "MIT",
   "keywords": [
@@ -41,16 +41,16 @@
     "zod": "^4.1.5"
   },
   "peerDependencies": {
-    "stripe": "^18",
-    "@better-auth/core": "1.3.28",
-    "better-auth": "1.3.28"
+    "stripe": "^18 || ^19",
+    "@better-auth/core": "1.3.30",
+    "better-auth": "1.3.30"
   },
   "devDependencies": {
     "better-call": "1.0.19",
-    "stripe": "^18.5.0",
+    "stripe": "^19.1.0",
     "unbuild": "3.6.1",
-    "@better-auth/core": "1.3.28",
-    "better-auth": "1.3.28"
+    "@better-auth/core": "1.3.30",
+    "better-auth": "1.3.30"
   },
   "scripts": {
     "test": "vitest",

package/src/index.ts

@@ -1244,11 +1244,18 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 								message: "Stripe webhook secret not found",
 							});
 						}
-						event = await client.webhooks.constructEventAsync(
-							buf,
-							sig,
-							webhookSecret,
-						);
+						// Support both Stripe v18 (constructEvent) and v19+ (constructEventAsync)
+						if (typeof client.webhooks.constructEventAsync === "function") {
+							// Stripe v19+ - use async method
+							event = await client.webhooks.constructEventAsync(
+								buf,
+								sig,
+								webhookSecret,
+							);
+						} else {
+							// Stripe v18 - use sync method
+							event = client.webhooks.constructEvent(buf, sig, webhookSecret);
+						}
 					} catch (err: any) {
 						ctx.context.logger.error(`${err.message}`);
 						throw new APIError("BAD_REQUEST", {

package/src/stripe.test.ts

@@ -49,7 +49,7 @@ describe("stripe", async () => {
 			update: vi.fn(),
 		},
 		webhooks: {
-			constructEvent: vi.fn(),
+			constructEventAsync: vi.fn(),
 		},
 	};
 
@@ -1739,4 +1739,412 @@ describe("stripe", async () => {
 			});
 		});
 	});
+
+	describe("Webhook Error Handling (Stripe v19)", () => {
+		it("should handle invalid webhook signature with constructEventAsync", async () => {
+			const mockError = new Error("Invalid signature");
+			const stripeWithError = {
+				...stripeOptions.stripeClient,
+				webhooks: {
+					constructEventAsync: vi.fn().mockRejectedValue(mockError),
+				},
+			};
+
+			const testOptions = {
+				...stripeOptions,
+				stripeClient: stripeWithError as unknown as Stripe,
+				stripeWebhookSecret: "test_secret",
+			};
+
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(testOptions)],
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"stripe-signature": "invalid_signature",
+					},
+					body: JSON.stringify({ type: "test.event" }),
+				},
+			);
+
+			const response = await testAuth.handler(mockRequest);
+			expect(response.status).toBe(400);
+			const data = await response.json();
+			expect(data.message).toContain("Webhook Error");
+		});
+
+		it("should reject webhook request without stripe-signature header", async () => {
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(stripeOptions)],
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"content-type": "application/json",
+					},
+					body: JSON.stringify({ type: "test.event" }),
+				},
+			);
+
+			const response = await testAuth.handler(mockRequest);
+			expect(response.status).toBe(400);
+			const data = await response.json();
+			expect(data.message).toContain("Stripe webhook secret not found");
+		});
+
+		it("should handle constructEventAsync returning null/undefined", async () => {
+			const stripeWithNull = {
+				...stripeOptions.stripeClient,
+				webhooks: {
+					constructEventAsync: vi.fn().mockResolvedValue(null),
+				},
+			};
+
+			const testOptions = {
+				...stripeOptions,
+				stripeClient: stripeWithNull as unknown as Stripe,
+				stripeWebhookSecret: "test_secret",
+			};
+
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(testOptions)],
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"stripe-signature": "test_signature",
+					},
+					body: JSON.stringify({ type: "test.event" }),
+				},
+			);
+
+			const response = await testAuth.handler(mockRequest);
+			expect(response.status).toBe(400);
+			const data = await response.json();
+			expect(data.message).toContain("Failed to construct event");
+		});
+
+		it("should handle async errors in webhook event processing", async () => {
+			const errorThrowingHandler = vi
+				.fn()
+				.mockRejectedValue(new Error("Event processing failed"));
+
+			const mockEvent = {
+				type: "checkout.session.completed",
+				data: {
+					object: {
+						mode: "subscription",
+						subscription: "sub_123",
+						metadata: {
+							referenceId: "user_123",
+							subscriptionId: "sub_123",
+						},
+					},
+				},
+			};
+
+			const stripeForTest = {
+				...stripeOptions.stripeClient,
+				subscriptions: {
+					retrieve: vi.fn().mockRejectedValue(new Error("Stripe API error")),
+				},
+				webhooks: {
+					constructEventAsync: vi.fn().mockResolvedValue(mockEvent),
+				},
+			};
+
+			const testOptions = {
+				...stripeOptions,
+				stripeClient: stripeForTest as unknown as Stripe,
+				stripeWebhookSecret: "test_secret",
+				subscription: {
+					...stripeOptions.subscription,
+					onSubscriptionComplete: errorThrowingHandler,
+				},
+			};
+
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(testOptions as StripeOptions)],
+			});
+
+			await ctx.adapter.create({
+				model: "subscription",
+				data: {
+					referenceId: "user_123",
+					stripeCustomerId: "cus_123",
+					status: "incomplete",
+					plan: "starter",
+					id: "sub_123",
+				},
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"stripe-signature": "test_signature",
+					},
+					body: JSON.stringify(mockEvent),
+				},
+			);
+
+			const response = await testAuth.handler(mockRequest);
+			// Errors inside event handlers are caught and logged but don't fail the webhook
+			// This prevents Stripe from retrying and is the expected behavior
+			expect(response.status).toBe(200);
+			const data = await response.json();
+			expect(data).toEqual({ success: true });
+			// Verify the error was logged (via the stripeClient.subscriptions.retrieve rejection)
+			expect(stripeForTest.subscriptions.retrieve).toHaveBeenCalled();
+		});
+
+		it("should successfully process webhook with valid async signature verification", async () => {
+			const mockEvent = {
+				type: "customer.subscription.updated",
+				data: {
+					object: {
+						id: "sub_test_async",
+						customer: "cus_test_async",
+						status: "active",
+						items: {
+							data: [
+								{
+									price: { id: process.env.STRIPE_PRICE_ID_1 },
+									quantity: 1,
+									current_period_start: Math.floor(Date.now() / 1000),
+									current_period_end:
+										Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+								},
+							],
+						},
+						current_period_start: Math.floor(Date.now() / 1000),
+						current_period_end:
+							Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+					},
+				},
+			};
+
+			const stripeForTest = {
+				...stripeOptions.stripeClient,
+				webhooks: {
+					// Simulate async verification success
+					constructEventAsync: vi.fn().mockResolvedValue(mockEvent),
+				},
+			};
+
+			const testOptions = {
+				...stripeOptions,
+				stripeClient: stripeForTest as unknown as Stripe,
+				stripeWebhookSecret: "test_secret_async",
+			};
+
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(testOptions)],
+			});
+
+			const { id: subId } = await ctx.adapter.create({
+				model: "subscription",
+				data: {
+					referenceId: userId,
+					stripeCustomerId: "cus_test_async",
+					stripeSubscriptionId: "sub_test_async",
+					status: "incomplete",
+					plan: "starter",
+				},
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"stripe-signature": "valid_async_signature",
+					},
+					body: JSON.stringify(mockEvent),
+				},
+			);
+
+			const response = await testAuth.handler(mockRequest);
+			expect(response.status).toBe(200);
+			expect(stripeForTest.webhooks.constructEventAsync).toHaveBeenCalledWith(
+				expect.any(String),
+				"valid_async_signature",
+				"test_secret_async",
+			);
+
+			const data = await response.json();
+			expect(data).toEqual({ success: true });
+		});
+
+		it("should call constructEventAsync with exactly 3 required parameters", async () => {
+			const mockEvent = {
+				type: "customer.subscription.created",
+				data: {
+					object: {
+						id: "sub_test_params",
+						customer: "cus_test_params",
+						status: "active",
+					},
+				},
+			};
+
+			const stripeForTest = {
+				...stripeOptions.stripeClient,
+				webhooks: {
+					constructEventAsync: vi.fn().mockResolvedValue(mockEvent),
+				},
+			};
+
+			const testOptions = {
+				...stripeOptions,
+				stripeClient: stripeForTest as unknown as Stripe,
+				stripeWebhookSecret: "test_secret_params",
+			};
+
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(testOptions)],
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"stripe-signature": "test_signature_params",
+					},
+					body: JSON.stringify(mockEvent),
+				},
+			);
+
+			await testAuth.handler(mockRequest);
+
+			// Verify that constructEventAsync is called with exactly 3 required parameters
+			// (payload, signature, secret) and no optional parameters
+			expect(stripeForTest.webhooks.constructEventAsync).toHaveBeenCalledWith(
+				expect.any(String), // payload
+				"test_signature_params", // signature
+				"test_secret_params", // secret
+			);
+
+			// Verify it was called exactly once
+			expect(stripeForTest.webhooks.constructEventAsync).toHaveBeenCalledTimes(
+				1,
+			);
+		});
+
+		it("should support Stripe v18 with sync constructEvent method", async () => {
+			const mockEvent = {
+				type: "customer.subscription.updated",
+				data: {
+					object: {
+						id: "sub_test_v18",
+						customer: "cus_test_v18",
+						status: "active",
+						items: {
+							data: [
+								{
+									price: { id: process.env.STRIPE_PRICE_ID_1 },
+									quantity: 1,
+									current_period_start: Math.floor(Date.now() / 1000),
+									current_period_end:
+										Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+								},
+							],
+						},
+						current_period_start: Math.floor(Date.now() / 1000),
+						current_period_end:
+							Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+					},
+				},
+			};
+
+			// Simulate Stripe v18 - only has sync constructEvent, no constructEventAsync
+			const stripeV18 = {
+				...stripeOptions.stripeClient,
+				webhooks: {
+					constructEvent: vi.fn().mockReturnValue(mockEvent),
+					// v18 doesn't have constructEventAsync
+					constructEventAsync: undefined,
+				},
+			};
+
+			const testOptions = {
+				...stripeOptions,
+				stripeClient: stripeV18 as unknown as Stripe,
+				stripeWebhookSecret: "test_secret_v18",
+			};
+
+			const testAuth = betterAuth({
+				baseURL: "http://localhost:3000",
+				database: memory,
+				emailAndPassword: { enabled: true },
+				plugins: [stripe(testOptions)],
+			});
+
+			const { id: subId } = await ctx.adapter.create({
+				model: "subscription",
+				data: {
+					referenceId: userId,
+					stripeCustomerId: "cus_test_v18",
+					stripeSubscriptionId: "sub_test_v18",
+					status: "incomplete",
+					plan: "starter",
+				},
+			});
+
+			const mockRequest = new Request(
+				"http://localhost:3000/api/auth/stripe/webhook",
+				{
+					method: "POST",
+					headers: {
+						"stripe-signature": "test_signature_v18",
+					},
+					body: JSON.stringify(mockEvent),
+				},
+			);
+
+			const response = await testAuth.handler(mockRequest);
+			expect(response.status).toBe(200);
+
+			// Verify that constructEvent (sync) was called instead of constructEventAsync
+			expect(stripeV18.webhooks.constructEvent).toHaveBeenCalledWith(
+				expect.any(String),
+				"test_signature_v18",
+				"test_secret_v18",
+			);
+			expect(stripeV18.webhooks.constructEvent).toHaveBeenCalledTimes(1);
+
+			const data = await response.json();
+			expect(data).toEqual({ success: true });
+		});
+	});
 });