@better-auth/stripe 1.4.16 → 1.4.18

package/test/stripe.test.ts

@@ -16,6 +16,7 @@ import {
 import type { StripePlugin } from "../src";
 import { stripe } from "../src";
 import { stripeClient } from "../src/client";
+import { customerMetadata, subscriptionMetadata } from "../src/metadata";
 import type { StripeOptions, Subscription } from "../src/types";
 
 describe("stripe type", () => {
@@ -99,6 +100,50 @@ describe("stripe type", () => {
 	});
 });
 
+describe("stripe - metadata helpers", () => {
+	it("customerMetadata.set protects internal fields", () => {
+		const result = customerMetadata.set(
+			{ userId: "real", customerType: "user" },
+			{ userId: "fake", custom: "value" },
+		);
+		expect(result.userId).toBe("real");
+		expect(result.customerType).toBe("user");
+		expect(result.custom).toBe("value");
+	});
+
+	it("customerMetadata.get extracts typed fields", () => {
+		const result = customerMetadata.get({
+			userId: "u1",
+			customerType: "organization",
+			extra: "ignored",
+		});
+		expect(result.userId).toBe("u1");
+		expect(result.customerType).toBe("organization");
+		expect(result).not.toHaveProperty("extra");
+	});
+
+	it("subscriptionMetadata.set protects internal fields", () => {
+		const result = subscriptionMetadata.set(
+			{ userId: "u1", subscriptionId: "s1", referenceId: "r1" },
+			{ subscriptionId: "fake" },
+		);
+		expect(result.subscriptionId).toBe("s1");
+	});
+
+	it("subscriptionMetadata.get extracts typed fields", () => {
+		const result = subscriptionMetadata.get({
+			userId: "u1",
+			subscriptionId: "s1",
+			referenceId: "r1",
+			extra: "ignored",
+		});
+		expect(result.userId).toBe("u1");
+		expect(result.subscriptionId).toBe("s1");
+		expect(result.referenceId).toBe("r1");
+		expect(result).not.toHaveProperty("extra");
+	});
+});
+
 describe("stripe", () => {
 	const mockStripe = {
 		prices: {
@@ -1845,10 +1890,26 @@ describe("stripe", () => {
 	});
 
 	it("should prevent duplicate subscriptions with same plan and same seats", async () => {
+		const starterPriceId = "price_starter_duplicate_test";
+		const subscriptionId = "sub_duplicate_test_123";
+
+		const stripeOptionsWithPrice = {
+			...stripeOptions,
+			subscription: {
+				enabled: true,
+				plans: [
+					{
+						name: "starter",
+						priceId: starterPriceId,
+					},
+				],
+			},
+		} satisfies StripeOptions;
+
 		const { client, auth, sessionSetter } = await getTestInstance(
 			{
 				database: memory,
-				plugins: [stripe(stripeOptions)],
+				plugins: [stripe(stripeOptionsWithPrice)],
 			},
 			{
 				disableTestUser: true,
@@ -1894,6 +1955,7 @@ describe("stripe", () => {
 			update: {
 				status: "active",
 				seats: 3,
+				stripeSubscriptionId: subscriptionId,
 			},
 			where: [
 				{
@@ -1903,6 +1965,27 @@ describe("stripe", () => {
 			],
 		});
 
+		// Mock Stripe to return the existing subscription with the same price ID
+		mockStripe.subscriptions.list.mockResolvedValue({
+			data: [
+				{
+					id: subscriptionId,
+					status: "active",
+					items: {
+						data: [
+							{
+								id: "si_duplicate_item",
+								price: {
+									id: starterPriceId,
+								},
+								quantity: 3,
+							},
+						],
+					},
+				},
+			],
+		});
+
 		const upgradeRes = await client.subscription.upgrade({
 			plan: "starter",
 			seats: 3,
@@ -1915,6 +1998,224 @@ describe("stripe", () => {
 		expect(upgradeRes.error?.message).toContain("already subscribed");
 	});
 
+	it("should allow upgrade from monthly to annual billing for the same plan", async () => {
+		const monthlyPriceId = "price_monthly_starter_123";
+		const annualPriceId = "price_annual_starter_456";
+		const subscriptionId = "sub_monthly_to_annual_123";
+
+		const stripeOptionsWithAnnual = {
+			...stripeOptions,
+			subscription: {
+				enabled: true,
+				plans: [
+					{
+						name: "starter",
+						priceId: monthlyPriceId,
+						annualDiscountPriceId: annualPriceId,
+					},
+				],
+			},
+		} satisfies StripeOptions;
+
+		const { client, auth, sessionSetter } = await getTestInstance(
+			{
+				database: memory,
+				plugins: [stripe(stripeOptionsWithAnnual)],
+			},
+			{
+				disableTestUser: true,
+				clientOptions: {
+					plugins: [stripeClient({ subscription: true })],
+				},
+			},
+		);
+		const ctx = await auth.$context;
+
+		const userRes = await client.signUp.email(testUser, { throw: true });
+
+		const headers = new Headers();
+		await client.signIn.email(testUser, {
+			throw: true,
+			onSuccess: sessionSetter(headers),
+		});
+
+		await client.subscription.upgrade({
+			plan: "starter",
+			seats: 1,
+			fetchOptions: { headers },
+		});
+
+		await ctx.adapter.update({
+			model: "subscription",
+			update: {
+				status: "active",
+				seats: 1,
+				stripeSubscriptionId: subscriptionId,
+			},
+			where: [{ field: "referenceId", value: userRes.user.id }],
+		});
+
+		mockStripe.subscriptions.list.mockResolvedValue({
+			data: [
+				{
+					id: subscriptionId,
+					status: "active",
+					items: {
+						data: [
+							{
+								id: "si_monthly_item",
+								price: { id: monthlyPriceId },
+								quantity: 1,
+							},
+						],
+					},
+				},
+			],
+		});
+
+		// Clear mocks before the upgrade call
+		mockStripe.checkout.sessions.create.mockClear();
+		mockStripe.billingPortal.sessions.create.mockClear();
+
+		const upgradeRes = await client.subscription.upgrade({
+			plan: "starter",
+			seats: 1,
+			annual: true,
+			subscriptionId,
+			fetchOptions: { headers },
+		});
+
+		// Should succeed and return a billing portal URL
+		expect(upgradeRes.error).toBeNull();
+		expect(upgradeRes.data?.url).toBeDefined();
+
+		// Verify billing portal was called with the annual price ID
+		expect(mockStripe.billingPortal.sessions.create).toHaveBeenCalledWith(
+			expect.objectContaining({
+				flow_data: expect.objectContaining({
+					type: "subscription_update_confirm",
+					subscription_update_confirm: expect.objectContaining({
+						items: expect.arrayContaining([
+							expect.objectContaining({ price: annualPriceId }),
+						]),
+					}),
+				}),
+			}),
+		);
+
+		// Should use billing portal, not checkout (since user has existing subscription)
+		expect(mockStripe.checkout.sessions.create).not.toHaveBeenCalled();
+		expect(mockStripe.billingPortal.sessions.create).toHaveBeenCalled();
+	});
+
+	it.each([
+		{
+			name: "past",
+			periodEnd: new Date(Date.now() - 24 * 60 * 60 * 1000),
+			shouldAllow: true,
+		},
+		{
+			name: "future",
+			periodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
+			shouldAllow: false,
+		},
+	])("should handle re-subscribing when periodEnd is in the $name", async ({
+		periodEnd,
+		shouldAllow,
+	}) => {
+		const starterPriceId = "price_starter_periodend_test";
+		const subscriptionId = "sub_periodend_test_123";
+
+		const stripeOptionsWithPrice = {
+			...stripeOptions,
+			subscription: {
+				enabled: true,
+				plans: [
+					{
+						name: "starter",
+						priceId: starterPriceId,
+					},
+				],
+			},
+		} satisfies StripeOptions;
+
+		const { client, auth, sessionSetter } = await getTestInstance(
+			{
+				database: memory,
+				plugins: [stripe(stripeOptionsWithPrice)],
+			},
+			{
+				disableTestUser: true,
+				clientOptions: {
+					plugins: [stripeClient({ subscription: true })],
+				},
+			},
+		);
+		const ctx = await auth.$context;
+
+		const userRes = await client.signUp.email(
+			{ ...testUser, email: `periodend-${periodEnd.getTime()}@email.com` },
+			{ throw: true },
+		);
+
+		const headers = new Headers();
+		await client.signIn.email(
+			{ ...testUser, email: `periodend-${periodEnd.getTime()}@email.com` },
+			{ throw: true, onSuccess: sessionSetter(headers) },
+		);
+
+		await client.subscription.upgrade({
+			plan: "starter",
+			seats: 1,
+			fetchOptions: { headers },
+		});
+
+		await ctx.adapter.update({
+			model: "subscription",
+			update: {
+				status: "active",
+				seats: 1,
+				periodEnd,
+				stripeSubscriptionId: subscriptionId,
+			},
+			where: [{ field: "referenceId", value: userRes.user.id }],
+		});
+
+		// Mock Stripe to return the existing subscription with the same price ID
+		mockStripe.subscriptions.list.mockResolvedValue({
+			data: [
+				{
+					id: subscriptionId,
+					status: "active",
+					items: {
+						data: [
+							{
+								id: "si_periodend_item",
+								price: {
+									id: starterPriceId,
+								},
+								quantity: 1,
+							},
+						],
+					},
+				},
+			],
+		});
+
+		const upgradeRes = await client.subscription.upgrade({
+			plan: "starter",
+			seats: 1,
+			fetchOptions: { headers },
+		});
+
+		if (shouldAllow) {
+			expect(upgradeRes.error).toBeNull();
+			expect(upgradeRes.data?.url).toBeDefined();
+		} else {
+			expect(upgradeRes.error?.message).toContain("already subscribed");
+		}
+	});
+
 	it("should only call Stripe customers.create once for signup and upgrade", async () => {
 		const { client, sessionSetter } = await getTestInstance(
 			{
@@ -4804,4 +5105,100 @@ describe("stripe", () => {
 			});
 		});
 	});
+
+	it("should upgrade existing active subscription even when canceled subscription exists for same referenceId", async () => {
+		const { client, auth, sessionSetter } = await getTestInstance(
+			{
+				database: memory,
+				plugins: [stripe(stripeOptions)],
+			},
+			{
+				disableTestUser: true,
+				clientOptions: {
+					plugins: [stripeClient({ subscription: true })],
+				},
+			},
+		);
+		const ctx = await auth.$context;
+
+		// Create a user
+		const userRes = await client.signUp.email({ ...testUser }, { throw: true });
+
+		const headers = new Headers();
+		await client.signIn.email(
+			{ ...testUser },
+			{
+				throw: true,
+				onSuccess: sessionSetter(headers),
+			},
+		);
+
+		// Update the user with the Stripe customer ID
+		await ctx.adapter.update({
+			model: "user",
+			update: {
+				stripeCustomerId: "cus_findone_test",
+			},
+			where: [
+				{
+					field: "id",
+					value: userRes.user.id,
+				},
+			],
+		});
+
+		// Create a CANCELED subscription first (simulating old subscription)
+		await ctx.adapter.create({
+			model: "subscription",
+			data: {
+				plan: "starter",
+				referenceId: userRes.user.id,
+				stripeCustomerId: "cus_findone_test",
+				stripeSubscriptionId: "sub_stripe_canceled",
+				status: "canceled",
+			},
+		});
+
+		// Create an ACTIVE subscription (simulating current subscription)
+		await ctx.adapter.create({
+			model: "subscription",
+			data: {
+				plan: "starter",
+				referenceId: userRes.user.id,
+				stripeCustomerId: "cus_findone_test",
+				stripeSubscriptionId: "sub_stripe_active",
+				status: "active",
+				periodEnd: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000),
+			},
+		});
+
+		// Mock Stripe subscriptions.list to return the active subscription
+		mockStripe.subscriptions.list.mockResolvedValueOnce({
+			data: [
+				{
+					id: "sub_stripe_active",
+					status: "active",
+					items: {
+						data: [
+							{
+								id: "si_test_item",
+								price: { id: process.env.STRIPE_PRICE_ID_1 },
+								quantity: 1,
+							},
+						],
+					},
+				},
+			],
+		});
+
+		// Try to upgrade to premium (without providing subscriptionId)
+		await client.subscription.upgrade({
+			plan: "premium",
+			fetchOptions: { headers },
+		});
+
+		// Should use billing portal to upgrade existing subscription (not create new checkout)
+		expect(mockStripe.billingPortal.sessions.create).toHaveBeenCalled();
+		expect(mockStripe.checkout.sessions.create).not.toHaveBeenCalled();
+	});
 });

package/tsdown.config.ts

@@ -5,4 +5,5 @@ export default defineConfig({
 	format: ["esm"],
 	entry: ["./src/index.ts", "./src/client.ts"],
 	external: ["better-auth", "better-call", "@better-fetch/fetch", "stripe"],
+	sourcemap: true,
 });

package/CHANGELOG.md

@@ -1,22 +0,0 @@
-# @better-auth/stripe
-
-## 1.3.4
-
-### Patch Changes
-
-- ac6baba: chore: fix typo on `freeTrial`
-- c2fb1aa: Fix duplicate trials when switching plans
-- 2bd2fa9: Added support for listing organization members with pagination, sorting, and filtering, and improved client inference for additional organization fields. Also fixed date handling in rate limits and tokens, improved Notion OAuth user extraction, and ensured session is always set in context.
-
-  Organization
-
-  - Added listMembers API with pagination, sorting, and filtering.
-  - Added membersLimit param to getFullOrganization.
-  - Improved client inference for additional fields in organization schemas.
-  - Bug Fixes
-  - Fixed date handling by casting DB values to Date objects before using date methods.
-  - Fixed Notion OAuth to extract user info correctly.
-  - Ensured session is set in context when reading from cookie cache
-
-- Updated dependencies [2bd2fa9]
-  - better-auth@1.3.4