@better-auth/stripe 1.3.10-beta.1 → 1.3.10-beta.2

package/.turbo/turbo-build.log

@@ -1,15 +1,15 @@
 
-> @better-auth/stripe@1.3.10-beta.1 build /home/runner/work/better-auth/better-auth/packages/stripe
+> @better-auth/stripe@1.3.10-beta.2 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: 45.5 kB, chunk size: 45.5 kB, exports: stripe)
+[log]   dist/index.cjs (total size: 45.4 kB, chunk size: 45.4 kB, exports: stripe)
 
 [log]   dist/client.cjs (total size: 224 B, chunk size: 224 B, exports: stripeClient)
 
-[log]   dist/index.mjs (total size: 44.6 kB, chunk size: 44.6 kB, exports: stripe)
+[log]   dist/index.mjs (total size: 44.5 kB, chunk size: 44.5 kB, exports: stripe)
 
 [log]   dist/client.mjs (total size: 197 B, chunk size: 197 B, exports: stripeClient)
 

package/dist/index.cjs

@@ -660,9 +660,8 @@ const stripe = (options) => {
           ctx
         );
         const hasEverTrialed = subscriptions.some((s) => {
-          const samePlan = s.plan?.toLowerCase() === plan.name.toLowerCase();
           const hadTrial = !!(s.trialStart || s.trialEnd) || s.status === "trialing";
-          return samePlan && hadTrial;
+          return hadTrial;
         });
         const freeTrial = !hasEverTrialed && plan.freeTrial ? { trial_period_days: plan.freeTrial.days } : void 0;
         let priceIdToUse = void 0;

package/dist/index.mjs

@@ -644,9 +644,8 @@ const stripe = (options) => {
           ctx
         );
         const hasEverTrialed = subscriptions.some((s) => {
-          const samePlan = s.plan?.toLowerCase() === plan.name.toLowerCase();
           const hadTrial = !!(s.trialStart || s.trialEnd) || s.status === "trialing";
-          return samePlan && hadTrial;
+          return hadTrial;
         });
         const freeTrial = !hasEverTrialed && plan.freeTrial ? { trial_period_days: plan.freeTrial.days } : void 0;
         let priceIdToUse = void 0;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@better-auth/stripe",
   "author": "Bereket Engida",
-  "version": "1.3.10-beta.1",
+  "version": "1.3.10-beta.2",
   "main": "dist/index.cjs",
   "license": "MIT",
   "keywords": [
@@ -41,13 +41,13 @@
   },
   "peerDependencies": {
     "stripe": "^18",
-    "better-auth": "1.3.10-beta.1"
+    "better-auth": "1.3.10-beta.2"
   },
   "devDependencies": {
     "better-call": "1.0.18",
     "stripe": "^18.5.0",
     "unbuild": "3.6.1",
-    "better-auth": "1.3.10-beta.1"
+    "better-auth": "1.3.10-beta.2"
   },
   "scripts": {
     "test": "vitest",

package/src/index.ts

@@ -468,10 +468,11 @@ export const stripe = <O extends StripeOptions>(options: O) => {
 				);
 
 				const hasEverTrialed = subscriptions.some((s) => {
-					const samePlan = s.plan?.toLowerCase() === plan.name.toLowerCase();
+					// Check if user has ever had a trial for any plan (not just the same plan)
+					// This prevents users from getting multiple trials by switching plans
 					const hadTrial =
 						!!(s.trialStart || s.trialEnd) || s.status === "trialing";
-					return samePlan && hadTrial;
+					return hadTrial;
 				});
 
 				const freeTrial =

package/src/stripe.test.ts

@@ -1103,68 +1103,181 @@ describe("stripe", async () => {
 		expect(personalAfter?.status).toBe("active");
 	});
 
-	it("should reuse incomplete subscription when upgrading again", async () => {
+	it("should prevent multiple free trials for the same user", async () => {
 		// Create a user
 		const userRes = await authClient.signUp.email(
-			{
-				email: "incomplete@example.com",
-				password: "password",
-				name: "Incomplete Test",
-			},
+			{ ...testUser, email: "trial-prevention@email.com" },
+			{ throw: true },
+		);
+
+		const headers = new Headers();
+		await authClient.signIn.email(
+			{ ...testUser, email: "trial-prevention@email.com" },
 			{
 				throw: true,
+				onSuccess: setCookieToHeader(headers),
 			},
 		);
 
+		// First subscription with trial
+		const firstUpgradeRes = await authClient.subscription.upgrade({
+			plan: "starter",
+			fetchOptions: { headers },
+		});
+
+		expect(firstUpgradeRes.data?.url).toBeDefined();
+
+		// Simulate the subscription being created with trial data
+		await ctx.adapter.update({
+			model: "subscription",
+			update: {
+				status: "trialing",
+				trialStart: new Date(),
+				trialEnd: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days from now
+			},
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
+		});
+
+		// Cancel the subscription
+		await ctx.adapter.update({
+			model: "subscription",
+			update: {
+				status: "canceled",
+			},
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
+		});
+
+		// Try to subscribe again - should NOT get a trial
+		const secondUpgradeRes = await authClient.subscription.upgrade({
+			plan: "starter",
+			fetchOptions: { headers },
+		});
+
+		expect(secondUpgradeRes.data?.url).toBeDefined();
+
+		// Verify that the checkout session was created without trial_period_days
+		// We can't directly test the Stripe session, but we can verify the logic
+		// by checking that the user has trial history
+		const subscriptions = (await ctx.adapter.findMany({
+			model: "subscription",
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
+		})) as Subscription[];
+
+		// Should have 2 subscriptions (first canceled, second new)
+		expect(subscriptions).toHaveLength(2);
+
+		// At least one should have trial data
+		const hasTrialData = subscriptions.some(
+			(s: Subscription) => s.trialStart || s.trialEnd,
+		);
+		expect(hasTrialData).toBe(true);
+	});
+
+	it("should prevent multiple free trials across different plans", async () => {
+		// Create a user
+		const userRes = await authClient.signUp.email(
+			{ ...testUser, email: "cross-plan-trial@email.com" },
+			{ throw: true },
+		);
+
 		const headers = new Headers();
 		await authClient.signIn.email(
-			{
-				email: "incomplete@example.com",
-				password: "password",
-			},
+			{ ...testUser, email: "cross-plan-trial@email.com" },
 			{
 				throw: true,
 				onSuccess: setCookieToHeader(headers),
 			},
 		);
 
-		// First upgrade attempt - creates incomplete subscription
-		const firstUpgrade = await authClient.subscription.upgrade({
+		// First subscription with trial on starter plan
+		const firstUpgradeRes = await authClient.subscription.upgrade({
 			plan: "starter",
-			fetchOptions: {
-				headers,
+			fetchOptions: { headers },
+		});
+
+		expect(firstUpgradeRes.data?.url).toBeDefined();
+
+		// Simulate the subscription being created with trial data
+		await ctx.adapter.update({
+			model: "subscription",
+			update: {
+				status: "trialing",
+				trialStart: new Date(),
+				trialEnd: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000),
 			},
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
 		});
-		expect(firstUpgrade.data?.url).toBe("https://checkout.stripe.com/mock");
 
-		// Check that an incomplete subscription was created
-		const subscriptions = await ctx.adapter.findMany<Subscription>({
+		// Cancel the subscription
+		await ctx.adapter.update({
 			model: "subscription",
-			where: [{ field: "referenceId", value: userRes.user.id }],
+			update: {
+				status: "canceled",
+			},
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
 		});
-		expect(subscriptions).toHaveLength(1);
-		expect(subscriptions[0].status).toBe("incomplete");
-		const firstSubId = subscriptions[0].id;
 
-		// Second upgrade attempt - should reuse the same subscription
-		const secondUpgrade = await authClient.subscription.upgrade({
+		// Try to subscribe to a different plan - should NOT get a trial
+		const secondUpgradeRes = await authClient.subscription.upgrade({
 			plan: "premium",
-			seats: 2,
-			fetchOptions: {
-				headers,
-			},
+			fetchOptions: { headers },
 		});
-		expect(secondUpgrade.data?.url).toBe("https://checkout.stripe.com/mock");
 
-		// Check that the same subscription was updated, not a new one created
-		const subscriptionsAfter = await ctx.adapter.findMany<Subscription>({
+		expect(secondUpgradeRes.data?.url).toBeDefined();
+
+		// Verify that the user has trial history from the first plan
+		const subscriptions = (await ctx.adapter.findMany({
 			model: "subscription",
-			where: [{ field: "referenceId", value: userRes.user.id }],
+			where: [
+				{
+					field: "referenceId",
+					value: userRes.user.id,
+				},
+			],
+		})) as Subscription[];
+
+		// Should have at least 1 subscription (the starter with trial data)
+		expect(subscriptions.length).toBeGreaterThanOrEqual(1);
+
+		// The starter subscription should have trial data
+		const starterSub = subscriptions.find(
+			(s: Subscription) => s.plan === "starter",
+		) as Subscription | undefined;
+		expect(starterSub?.trialStart).toBeDefined();
+		expect(starterSub?.trialEnd).toBeDefined();
+
+		// Verify that the trial eligibility logic is working by checking
+		// that the user has ever had a trial (which should prevent future trials)
+		const hasEverTrialed = subscriptions.some((s: Subscription) => {
+			const hadTrial =
+				!!(s.trialStart || s.trialEnd) || s.status === "trialing";
+			return hadTrial;
 		});
-		expect(subscriptionsAfter).toHaveLength(1);
-		expect(subscriptionsAfter[0].id).toBe(firstSubId);
-		expect(subscriptionsAfter[0].status).toBe("incomplete");
-		expect(subscriptionsAfter[0].plan).toBe("premium");
-		expect(subscriptionsAfter[0].seats).toBe(2);
+		expect(hasEverTrialed).toBe(true);
 	});
 });