@better-auth/stripe 1.2.1-beta.2 → 1.2.1-beta.4

package/.turbo/turbo-build.log

@@ -1,17 +1,17 @@
 
-> @better-auth/stripe@1.2.1-beta.2 build /home/runner/work/better-auth/better-auth/packages/stripe
+> @better-auth/stripe@1.2.1-beta.4 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: 24.7 kB, chunk size: 24.7 kB, exports: stripe)
+[log]   dist/index.cjs (total size: 26 kB, chunk size: 26 kB, exports: stripe)
 
 [log]   dist/client.cjs (total size: 160 B, chunk size: 160 B, exports: stripeClient)
 
-[log]   dist/index.mjs (total size: 24.5 kB, chunk size: 24.5 kB, exports: stripe)
+[log]   dist/index.mjs (total size: 25.8 kB, chunk size: 25.8 kB, exports: stripe)
 
 [log]   dist/client.mjs (total size: 133 B, chunk size: 133 B, exports: stripeClient)
 
-Σ Total dist size (byte size): 156 kB
+Σ Total dist size (byte size): 159 kB
 [log]

package/dist/index.cjs

@@ -4,6 +4,7 @@ const plugins = require('better-auth/plugins');
 const zod = require('zod');
 const api = require('better-auth/api');
 const crypto = require('better-auth/crypto');
+const betterAuth = require('better-auth');
 
 async function getPlans(options) {
   return typeof options?.subscription?.plans === "function" ? await options.subscription?.plans() : options.subscription?.plans;
@@ -20,46 +21,37 @@ async function getPlanByName(options, name) {
 }
 
 async function onCheckoutSessionCompleted(ctx, options, event) {
-  const client = options.stripeClient;
-  const checkoutSession = event.data.object;
-  if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
-    return;
-  }
-  const subscription = await client.subscriptions.retrieve(
-    checkoutSession.subscription
-  );
-  const priceId = subscription.items.data[0]?.price.id;
-  const plan = await getPlanByPriceId(options, priceId);
-  if (plan) {
-    const referenceId = checkoutSession?.metadata?.referenceId;
-    const subscriptionId = checkoutSession?.metadata?.subscriptionId;
-    const seats = subscription.items.data[0].quantity;
-    if (referenceId && subscriptionId) {
-      const trial = subscription.trial_start && subscription.trial_end ? {
-        trialStart: new Date(subscription.trial_start * 1e3),
-        trialEnd: new Date(subscription.trial_end * 1e3)
-      } : {};
-      let dbSubscription = await ctx.context.adapter.update({
-        model: "subscription",
-        update: {
-          plan: plan.name.toLowerCase(),
-          status: subscription.status,
-          updatedAt: /* @__PURE__ */ new Date(),
-          periodStart: new Date(subscription.current_period_start * 1e3),
-          periodEnd: new Date(subscription.current_period_end * 1e3),
-          seats,
-          ...trial
-        },
-        where: [
-          {
-            field: "id",
-            value: subscriptionId
-          }
-        ]
-      });
-      if (!dbSubscription) {
-        dbSubscription = await ctx.context.adapter.findOne({
+  try {
+    const client = options.stripeClient;
+    const checkoutSession = event.data.object;
+    if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
+      return;
+    }
+    const subscription = await client.subscriptions.retrieve(
+      checkoutSession.subscription
+    );
+    const priceId = subscription.items.data[0]?.price.id;
+    const plan = await getPlanByPriceId(options, priceId);
+    if (plan) {
+      const referenceId = checkoutSession?.metadata?.referenceId;
+      const subscriptionId = checkoutSession?.metadata?.subscriptionId;
+      const seats = subscription.items.data[0].quantity;
+      if (referenceId && subscriptionId) {
+        const trial = subscription.trial_start && subscription.trial_end ? {
+          trialStart: new Date(subscription.trial_start * 1e3),
+          trialEnd: new Date(subscription.trial_end * 1e3)
+        } : {};
+        let dbSubscription = await ctx.context.adapter.update({
           model: "subscription",
+          update: {
+            plan: plan.name.toLowerCase(),
+            status: subscription.status,
+            updatedAt: /* @__PURE__ */ new Date(),
+            periodStart: new Date(subscription.current_period_start * 1e3),
+            periodEnd: new Date(subscription.current_period_end * 1e3),
+            seats,
+            ...trial
+          },
           where: [
             {
               field: "id",
@@ -67,111 +59,146 @@ async function onCheckoutSessionCompleted(ctx, options, event) {
             }
           ]
         });
+        if (trial.trialStart && plan.freeTrial?.onTrialStart) {
+          await plan.freeTrial.onTrialStart(dbSubscription);
+        }
+        if (!dbSubscription) {
+          dbSubscription = await ctx.context.adapter.findOne({
+            model: "subscription",
+            where: [
+              {
+                field: "id",
+                value: subscriptionId
+              }
+            ]
+          });
+        }
+        await options.subscription?.onSubscriptionComplete?.({
+          event,
+          subscription: dbSubscription,
+          stripeSubscription: subscription,
+          plan
+        });
+        return;
       }
-      await options.subscription?.onSubscriptionComplete?.({
-        event,
-        subscription: dbSubscription,
-        stripeSubscription: subscription,
-        plan
-      });
-      return;
     }
+  } catch (e) {
+    betterAuth.logger.error(`Stripe webhook failed. Error: ${e.message}`);
   }
 }
 async function onSubscriptionUpdated(ctx, options, event) {
-  if (!options.subscription?.enabled) {
-    return;
-  }
-  const subscriptionUpdated = event.data.object;
-  const priceId = subscriptionUpdated.items.data[0].price.id;
-  const plan = await getPlanByPriceId(options, priceId);
-  if (plan) {
-    const stripeId = subscriptionUpdated.customer.toString();
-    const subscription = await ctx.context.adapter.findOne({
-      model: "subscription",
-      where: [
-        {
-          field: "stripeSubscriptionId",
-          value: stripeId
-        }
-      ]
-    });
-    if (!subscription) {
+  try {
+    if (!options.subscription?.enabled) {
       return;
     }
-    const seats = subscriptionUpdated.items.data[0].quantity;
-    await ctx.context.adapter.update({
-      model: "subscription",
-      update: {
-        plan: plan.name.toLowerCase(),
-        limits: plan.limits,
-        updatedAt: /* @__PURE__ */ new Date(),
-        status: subscriptionUpdated.status,
-        periodStart: new Date(subscriptionUpdated.current_period_start * 1e3),
-        periodEnd: new Date(subscriptionUpdated.current_period_end * 1e3),
-        cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
-        seats
-      },
-      where: [
-        {
-          field: "stripeSubscriptionId",
-          value: subscriptionUpdated.id
-        }
-      ]
-    });
-    const subscriptionCanceled = subscriptionUpdated.status === "active" && subscriptionUpdated.cancel_at_period_end;
-    if (subscriptionCanceled) {
-      await options.subscription.onSubscriptionCancel?.({
-        subscription,
-        cancellationDetails: subscriptionUpdated.cancellation_details || void 0,
-        stripeSubscription: subscriptionUpdated,
-        event
+    const subscriptionUpdated = event.data.object;
+    const priceId = subscriptionUpdated.items.data[0].price.id;
+    const plan = await getPlanByPriceId(options, priceId);
+    if (plan) {
+      const stripeId = subscriptionUpdated.id;
+      const subscription = await ctx.context.adapter.findOne({
+        model: "subscription",
+        where: [
+          {
+            field: "stripeSubscriptionId",
+            value: stripeId
+          }
+        ]
       });
+      if (!subscription) {
+        return;
+      }
+      const seats = subscriptionUpdated.items.data[0].quantity;
+      await ctx.context.adapter.update({
+        model: "subscription",
+        update: {
+          plan: plan.name.toLowerCase(),
+          limits: plan.limits,
+          updatedAt: /* @__PURE__ */ new Date(),
+          status: subscriptionUpdated.status,
+          periodStart: new Date(
+            subscriptionUpdated.current_period_start * 1e3
+          ),
+          periodEnd: new Date(subscriptionUpdated.current_period_end * 1e3),
+          cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
+          seats
+        },
+        where: [
+          {
+            field: "stripeSubscriptionId",
+            value: subscriptionUpdated.id
+          }
+        ]
+      });
+      const subscriptionCanceled = subscriptionUpdated.status === "active" && subscriptionUpdated.cancel_at_period_end;
+      if (subscriptionCanceled) {
+        await options.subscription.onSubscriptionCancel?.({
+          subscription,
+          cancellationDetails: subscriptionUpdated.cancellation_details || void 0,
+          stripeSubscription: subscriptionUpdated,
+          event
+        });
+      }
+      await options.subscription.onSubscriptionUpdate?.({
+        event,
+        subscription
+      });
+      if (subscriptionUpdated.status === "active" && subscription.status === "trialing" && plan.freeTrial?.onTrialEnd) {
+        const user = await ctx.context.adapter.findOne({
+          model: "user",
+          where: [{ field: "id", value: subscription.referenceId }]
+        });
+        if (user) {
+          await plan.freeTrial.onTrialEnd({ subscription, user }, ctx.request);
+        }
+      }
+      if (subscriptionUpdated.status === "incomplete_expired" && subscription.status === "trialing" && plan.freeTrial?.onTrialExpired) {
+        await plan.freeTrial.onTrialExpired(subscription, ctx.request);
+      }
     }
-    await options.subscription.onSubscriptionUpdate?.({
-      event,
-      subscription
-    });
+  } catch (error) {
+    betterAuth.logger.error(`Stripe webhook failed. Error: ${error.message}`);
   }
 }
 async function onSubscriptionDeleted(ctx, options, event) {
   if (!options.subscription?.enabled) {
     return;
   }
-  const subscriptionDeleted = event.data.object;
-  const subscriptionId = subscriptionDeleted.metadata?.subscriptionId;
-  const stripeSubscription = await options.stripeClient.subscriptions.retrieve(
-    subscriptionId
-  );
-  if (stripeSubscription.status === "canceled") {
-    const subscription = await ctx.context.adapter.findOne({
-      model: "subscription",
-      where: [
-        {
-          field: "id",
-          value: subscriptionId
-        }
-      ]
-    });
-    if (subscription) {
-      await ctx.context.adapter.update({
+  try {
+    const subscriptionDeleted = event.data.object;
+    const subscriptionId = subscriptionDeleted.metadata?.subscriptionId;
+    if (subscriptionDeleted.status === "canceled") {
+      const subscription = await ctx.context.adapter.findOne({
         model: "subscription",
         where: [
           {
             field: "id",
-            value: subscription.id
+            value: subscriptionId
           }
-        ],
-        update: {
-          status: "canceled"
-        }
-      });
-      await options.subscription.onSubscriptionDeleted?.({
-        event,
-        stripeSubscription: subscriptionDeleted,
-        subscription
+        ]
       });
+      if (subscription) {
+        await ctx.context.adapter.update({
+          model: "subscription",
+          where: [
+            {
+              field: "id",
+              value: subscription.id
+            }
+          ],
+          update: {
+            status: "canceled"
+          }
+        });
+        await options.subscription.onSubscriptionDeleted?.({
+          event,
+          stripeSubscription: subscriptionDeleted,
+          subscription
+        });
+      }
     }
+  } catch (error) {
+    betterAuth.logger.error(`Stripe webhook failed. Error: ${error.message}`);
   }
 }
 

package/dist/index.d.cts

@@ -78,7 +78,7 @@ type Plan = {
          * @param subscription - Subscription
          * @returns
          */
-        onTrialExpired?: (subscription: Subscription) => Promise<void>;
+        onTrialExpired?: (subscription: Subscription, request?: Request) => Promise<void>;
     };
 };
 interface Subscription {

package/dist/index.d.mts

@@ -78,7 +78,7 @@ type Plan = {
          * @param subscription - Subscription
          * @returns
          */
-        onTrialExpired?: (subscription: Subscription) => Promise<void>;
+        onTrialExpired?: (subscription: Subscription, request?: Request) => Promise<void>;
     };
 };
 interface Subscription {

package/dist/index.d.ts

@@ -78,7 +78,7 @@ type Plan = {
          * @param subscription - Subscription
          * @returns
          */
-        onTrialExpired?: (subscription: Subscription) => Promise<void>;
+        onTrialExpired?: (subscription: Subscription, request?: Request) => Promise<void>;
     };
 };
 interface Subscription {

package/dist/index.mjs

@@ -2,6 +2,7 @@ import { createAuthEndpoint, createAuthMiddleware } from 'better-auth/plugins';
 import { z } from 'zod';
 import { getSessionFromCtx, sessionMiddleware, originCheck, APIError } from 'better-auth/api';
 import { generateRandomString } from 'better-auth/crypto';
+import { logger } from 'better-auth';
 
 async function getPlans(options) {
   return typeof options?.subscription?.plans === "function" ? await options.subscription?.plans() : options.subscription?.plans;
@@ -18,46 +19,37 @@ async function getPlanByName(options, name) {
 }
 
 async function onCheckoutSessionCompleted(ctx, options, event) {
-  const client = options.stripeClient;
-  const checkoutSession = event.data.object;
-  if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
-    return;
-  }
-  const subscription = await client.subscriptions.retrieve(
-    checkoutSession.subscription
-  );
-  const priceId = subscription.items.data[0]?.price.id;
-  const plan = await getPlanByPriceId(options, priceId);
-  if (plan) {
-    const referenceId = checkoutSession?.metadata?.referenceId;
-    const subscriptionId = checkoutSession?.metadata?.subscriptionId;
-    const seats = subscription.items.data[0].quantity;
-    if (referenceId && subscriptionId) {
-      const trial = subscription.trial_start && subscription.trial_end ? {
-        trialStart: new Date(subscription.trial_start * 1e3),
-        trialEnd: new Date(subscription.trial_end * 1e3)
-      } : {};
-      let dbSubscription = await ctx.context.adapter.update({
-        model: "subscription",
-        update: {
-          plan: plan.name.toLowerCase(),
-          status: subscription.status,
-          updatedAt: /* @__PURE__ */ new Date(),
-          periodStart: new Date(subscription.current_period_start * 1e3),
-          periodEnd: new Date(subscription.current_period_end * 1e3),
-          seats,
-          ...trial
-        },
-        where: [
-          {
-            field: "id",
-            value: subscriptionId
-          }
-        ]
-      });
-      if (!dbSubscription) {
-        dbSubscription = await ctx.context.adapter.findOne({
+  try {
+    const client = options.stripeClient;
+    const checkoutSession = event.data.object;
+    if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
+      return;
+    }
+    const subscription = await client.subscriptions.retrieve(
+      checkoutSession.subscription
+    );
+    const priceId = subscription.items.data[0]?.price.id;
+    const plan = await getPlanByPriceId(options, priceId);
+    if (plan) {
+      const referenceId = checkoutSession?.metadata?.referenceId;
+      const subscriptionId = checkoutSession?.metadata?.subscriptionId;
+      const seats = subscription.items.data[0].quantity;
+      if (referenceId && subscriptionId) {
+        const trial = subscription.trial_start && subscription.trial_end ? {
+          trialStart: new Date(subscription.trial_start * 1e3),
+          trialEnd: new Date(subscription.trial_end * 1e3)
+        } : {};
+        let dbSubscription = await ctx.context.adapter.update({
           model: "subscription",
+          update: {
+            plan: plan.name.toLowerCase(),
+            status: subscription.status,
+            updatedAt: /* @__PURE__ */ new Date(),
+            periodStart: new Date(subscription.current_period_start * 1e3),
+            periodEnd: new Date(subscription.current_period_end * 1e3),
+            seats,
+            ...trial
+          },
           where: [
             {
               field: "id",
@@ -65,111 +57,146 @@ async function onCheckoutSessionCompleted(ctx, options, event) {
             }
           ]
         });
+        if (trial.trialStart && plan.freeTrial?.onTrialStart) {
+          await plan.freeTrial.onTrialStart(dbSubscription);
+        }
+        if (!dbSubscription) {
+          dbSubscription = await ctx.context.adapter.findOne({
+            model: "subscription",
+            where: [
+              {
+                field: "id",
+                value: subscriptionId
+              }
+            ]
+          });
+        }
+        await options.subscription?.onSubscriptionComplete?.({
+          event,
+          subscription: dbSubscription,
+          stripeSubscription: subscription,
+          plan
+        });
+        return;
       }
-      await options.subscription?.onSubscriptionComplete?.({
-        event,
-        subscription: dbSubscription,
-        stripeSubscription: subscription,
-        plan
-      });
-      return;
     }
+  } catch (e) {
+    logger.error(`Stripe webhook failed. Error: ${e.message}`);
   }
 }
 async function onSubscriptionUpdated(ctx, options, event) {
-  if (!options.subscription?.enabled) {
-    return;
-  }
-  const subscriptionUpdated = event.data.object;
-  const priceId = subscriptionUpdated.items.data[0].price.id;
-  const plan = await getPlanByPriceId(options, priceId);
-  if (plan) {
-    const stripeId = subscriptionUpdated.customer.toString();
-    const subscription = await ctx.context.adapter.findOne({
-      model: "subscription",
-      where: [
-        {
-          field: "stripeSubscriptionId",
-          value: stripeId
-        }
-      ]
-    });
-    if (!subscription) {
+  try {
+    if (!options.subscription?.enabled) {
       return;
     }
-    const seats = subscriptionUpdated.items.data[0].quantity;
-    await ctx.context.adapter.update({
-      model: "subscription",
-      update: {
-        plan: plan.name.toLowerCase(),
-        limits: plan.limits,
-        updatedAt: /* @__PURE__ */ new Date(),
-        status: subscriptionUpdated.status,
-        periodStart: new Date(subscriptionUpdated.current_period_start * 1e3),
-        periodEnd: new Date(subscriptionUpdated.current_period_end * 1e3),
-        cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
-        seats
-      },
-      where: [
-        {
-          field: "stripeSubscriptionId",
-          value: subscriptionUpdated.id
-        }
-      ]
-    });
-    const subscriptionCanceled = subscriptionUpdated.status === "active" && subscriptionUpdated.cancel_at_period_end;
-    if (subscriptionCanceled) {
-      await options.subscription.onSubscriptionCancel?.({
-        subscription,
-        cancellationDetails: subscriptionUpdated.cancellation_details || void 0,
-        stripeSubscription: subscriptionUpdated,
-        event
+    const subscriptionUpdated = event.data.object;
+    const priceId = subscriptionUpdated.items.data[0].price.id;
+    const plan = await getPlanByPriceId(options, priceId);
+    if (plan) {
+      const stripeId = subscriptionUpdated.id;
+      const subscription = await ctx.context.adapter.findOne({
+        model: "subscription",
+        where: [
+          {
+            field: "stripeSubscriptionId",
+            value: stripeId
+          }
+        ]
       });
+      if (!subscription) {
+        return;
+      }
+      const seats = subscriptionUpdated.items.data[0].quantity;
+      await ctx.context.adapter.update({
+        model: "subscription",
+        update: {
+          plan: plan.name.toLowerCase(),
+          limits: plan.limits,
+          updatedAt: /* @__PURE__ */ new Date(),
+          status: subscriptionUpdated.status,
+          periodStart: new Date(
+            subscriptionUpdated.current_period_start * 1e3
+          ),
+          periodEnd: new Date(subscriptionUpdated.current_period_end * 1e3),
+          cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
+          seats
+        },
+        where: [
+          {
+            field: "stripeSubscriptionId",
+            value: subscriptionUpdated.id
+          }
+        ]
+      });
+      const subscriptionCanceled = subscriptionUpdated.status === "active" && subscriptionUpdated.cancel_at_period_end;
+      if (subscriptionCanceled) {
+        await options.subscription.onSubscriptionCancel?.({
+          subscription,
+          cancellationDetails: subscriptionUpdated.cancellation_details || void 0,
+          stripeSubscription: subscriptionUpdated,
+          event
+        });
+      }
+      await options.subscription.onSubscriptionUpdate?.({
+        event,
+        subscription
+      });
+      if (subscriptionUpdated.status === "active" && subscription.status === "trialing" && plan.freeTrial?.onTrialEnd) {
+        const user = await ctx.context.adapter.findOne({
+          model: "user",
+          where: [{ field: "id", value: subscription.referenceId }]
+        });
+        if (user) {
+          await plan.freeTrial.onTrialEnd({ subscription, user }, ctx.request);
+        }
+      }
+      if (subscriptionUpdated.status === "incomplete_expired" && subscription.status === "trialing" && plan.freeTrial?.onTrialExpired) {
+        await plan.freeTrial.onTrialExpired(subscription, ctx.request);
+      }
     }
-    await options.subscription.onSubscriptionUpdate?.({
-      event,
-      subscription
-    });
+  } catch (error) {
+    logger.error(`Stripe webhook failed. Error: ${error.message}`);
   }
 }
 async function onSubscriptionDeleted(ctx, options, event) {
   if (!options.subscription?.enabled) {
     return;
   }
-  const subscriptionDeleted = event.data.object;
-  const subscriptionId = subscriptionDeleted.metadata?.subscriptionId;
-  const stripeSubscription = await options.stripeClient.subscriptions.retrieve(
-    subscriptionId
-  );
-  if (stripeSubscription.status === "canceled") {
-    const subscription = await ctx.context.adapter.findOne({
-      model: "subscription",
-      where: [
-        {
-          field: "id",
-          value: subscriptionId
-        }
-      ]
-    });
-    if (subscription) {
-      await ctx.context.adapter.update({
+  try {
+    const subscriptionDeleted = event.data.object;
+    const subscriptionId = subscriptionDeleted.metadata?.subscriptionId;
+    if (subscriptionDeleted.status === "canceled") {
+      const subscription = await ctx.context.adapter.findOne({
         model: "subscription",
         where: [
           {
             field: "id",
-            value: subscription.id
+            value: subscriptionId
           }
-        ],
-        update: {
-          status: "canceled"
-        }
-      });
-      await options.subscription.onSubscriptionDeleted?.({
-        event,
-        stripeSubscription: subscriptionDeleted,
-        subscription
+        ]
       });
+      if (subscription) {
+        await ctx.context.adapter.update({
+          model: "subscription",
+          where: [
+            {
+              field: "id",
+              value: subscription.id
+            }
+          ],
+          update: {
+            status: "canceled"
+          }
+        });
+        await options.subscription.onSubscriptionDeleted?.({
+          event,
+          stripeSubscription: subscriptionDeleted,
+          subscription
+        });
+      }
     }
+  } catch (error) {
+    logger.error(`Stripe webhook failed. Error: ${error.message}`);
   }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@better-auth/stripe",
   "author": "Bereket Engida",
-  "version": "1.2.1-beta.2",
+  "version": "1.2.1-beta.4",
   "main": "dist/index.cjs",
   "license": "MIT",
   "keywords": [
@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "zod": "^3.24.1",
-    "better-auth": "^1.2.1-beta.2"
+    "better-auth": "^1.2.1-beta.4"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.12",

package/src/hooks.ts

@@ -1,4 +1,4 @@
-import type { GenericEndpointContext } from "better-auth";
+import { logger, type GenericEndpointContext, type User } from "better-auth";
 import type Stripe from "stripe";
 import type { InputSubscription, StripeOptions, Subscription } from "./types";
 import { getPlanByPriceId } from "./utils";
@@ -8,65 +8,76 @@ export async function onCheckoutSessionCompleted(
 	options: StripeOptions,
 	event: Stripe.Event,
 ) {
-	const client = options.stripeClient;
-	const checkoutSession = event.data.object as Stripe.Checkout.Session;
-	if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
-		return;
-	}
-	const subscription = await client.subscriptions.retrieve(
-		checkoutSession.subscription as string,
-	);
-	const priceId = subscription.items.data[0]?.price.id;
-	const plan = await getPlanByPriceId(options, priceId as string);
-	if (plan) {
-		const referenceId = checkoutSession?.metadata?.referenceId;
-		const subscriptionId = checkoutSession?.metadata?.subscriptionId;
-		const seats = subscription.items.data[0].quantity;
-		if (referenceId && subscriptionId) {
-			const trial =
-				subscription.trial_start && subscription.trial_end
-					? {
-							trialStart: new Date(subscription.trial_start * 1000),
-							trialEnd: new Date(subscription.trial_end * 1000),
-						}
-					: {};
-			let dbSubscription = await ctx.context.adapter.update<InputSubscription>({
-				model: "subscription",
-				update: {
-					plan: plan.name.toLowerCase(),
-					status: subscription.status,
-					updatedAt: new Date(),
-					periodStart: new Date(subscription.current_period_start * 1000),
-					periodEnd: new Date(subscription.current_period_end * 1000),
-					seats,
-					...trial,
-				},
-				where: [
-					{
-						field: "id",
-						value: subscriptionId,
-					},
-				],
-			});
-			if (!dbSubscription) {
-				dbSubscription = await ctx.context.adapter.findOne<Subscription>({
-					model: "subscription",
-					where: [
-						{
-							field: "id",
-							value: subscriptionId,
+	try {
+		const client = options.stripeClient;
+		const checkoutSession = event.data.object as Stripe.Checkout.Session;
+		if (checkoutSession.mode === "setup" || !options.subscription?.enabled) {
+			return;
+		}
+		const subscription = await client.subscriptions.retrieve(
+			checkoutSession.subscription as string,
+		);
+		const priceId = subscription.items.data[0]?.price.id;
+		const plan = await getPlanByPriceId(options, priceId as string);
+		if (plan) {
+			const referenceId = checkoutSession?.metadata?.referenceId;
+			const subscriptionId = checkoutSession?.metadata?.subscriptionId;
+			const seats = subscription.items.data[0].quantity;
+			if (referenceId && subscriptionId) {
+				const trial =
+					subscription.trial_start && subscription.trial_end
+						? {
+								trialStart: new Date(subscription.trial_start * 1000),
+								trialEnd: new Date(subscription.trial_end * 1000),
+							}
+						: {};
+
+				let dbSubscription =
+					await ctx.context.adapter.update<InputSubscription>({
+						model: "subscription",
+						update: {
+							plan: plan.name.toLowerCase(),
+							status: subscription.status,
+							updatedAt: new Date(),
+							periodStart: new Date(subscription.current_period_start * 1000),
+							periodEnd: new Date(subscription.current_period_end * 1000),
+							seats,
+							...trial,
 						},
-					],
+						where: [
+							{
+								field: "id",
+								value: subscriptionId,
+							},
+						],
+					});
+
+				if (trial.trialStart && plan.freeTrial?.onTrialStart) {
+					await plan.freeTrial.onTrialStart(dbSubscription as Subscription);
+				}
+
+				if (!dbSubscription) {
+					dbSubscription = await ctx.context.adapter.findOne<Subscription>({
+						model: "subscription",
+						where: [
+							{
+								field: "id",
+								value: subscriptionId,
+							},
+						],
+					});
+				}
+				await options.subscription?.onSubscriptionComplete?.({
+					event,
+					subscription: dbSubscription as Subscription,
+					stripeSubscription: subscription,
+					plan,
 				});
+				return;
 			}
-			await options.subscription?.onSubscriptionComplete?.({
-				event,
-				subscription: dbSubscription as Subscription,
-				stripeSubscription: subscription,
-				plan,
-			});
-			return;
 		}
+	} catch (e: any) {
+		logger.error(`Stripe webhook failed. Error: ${e.message}`);
 	}
 }
 
@@ -75,62 +86,89 @@ export async function onSubscriptionUpdated(
 	options: StripeOptions,
 	event: Stripe.Event,
 ) {
-	if (!options.subscription?.enabled) {
-		return;
-	}
-	const subscriptionUpdated = event.data.object as Stripe.Subscription;
-	const priceId = subscriptionUpdated.items.data[0].price.id;
-	const plan = await getPlanByPriceId(options, priceId);
-	if (plan) {
-		const stripeId = subscriptionUpdated.customer.toString();
-		const subscription = await ctx.context.adapter.findOne<Subscription>({
-			model: "subscription",
-			where: [
-				{
-					field: "stripeSubscriptionId",
-					value: stripeId,
-				},
-			],
-		});
-		if (!subscription) {
+	try {
+		if (!options.subscription?.enabled) {
 			return;
 		}
-		const seats = subscriptionUpdated.items.data[0].quantity;
-		await ctx.context.adapter.update({
-			model: "subscription",
-			update: {
-				plan: plan.name.toLowerCase(),
-				limits: plan.limits,
-				updatedAt: new Date(),
-				status: subscriptionUpdated.status,
-				periodStart: new Date(subscriptionUpdated.current_period_start * 1000),
-				periodEnd: new Date(subscriptionUpdated.current_period_end * 1000),
-				cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
-				seats,
-			},
-			where: [
-				{
-					field: "stripeSubscriptionId",
-					value: subscriptionUpdated.id,
+		const subscriptionUpdated = event.data.object as Stripe.Subscription;
+		const priceId = subscriptionUpdated.items.data[0].price.id;
+		const plan = await getPlanByPriceId(options, priceId);
+		if (plan) {
+			const stripeId = subscriptionUpdated.id;
+			const subscription = await ctx.context.adapter.findOne<Subscription>({
+				model: "subscription",
+				where: [
+					{
+						field: "stripeSubscriptionId",
+						value: stripeId,
+					},
+				],
+			});
+			if (!subscription) {
+				return;
+			}
+			const seats = subscriptionUpdated.items.data[0].quantity;
+			await ctx.context.adapter.update({
+				model: "subscription",
+				update: {
+					plan: plan.name.toLowerCase(),
+					limits: plan.limits,
+					updatedAt: new Date(),
+					status: subscriptionUpdated.status,
+					periodStart: new Date(
+						subscriptionUpdated.current_period_start * 1000,
+					),
+					periodEnd: new Date(subscriptionUpdated.current_period_end * 1000),
+					cancelAtPeriodEnd: subscriptionUpdated.cancel_at_period_end,
+					seats,
 				},
-			],
-		});
-		const subscriptionCanceled =
-			subscriptionUpdated.status === "active" &&
-			subscriptionUpdated.cancel_at_period_end;
-		if (subscriptionCanceled) {
-			await options.subscription.onSubscriptionCancel?.({
-				subscription,
-				cancellationDetails:
-					subscriptionUpdated.cancellation_details || undefined,
-				stripeSubscription: subscriptionUpdated,
+				where: [
+					{
+						field: "stripeSubscriptionId",
+						value: subscriptionUpdated.id,
+					},
+				],
+			});
+			const subscriptionCanceled =
+				subscriptionUpdated.status === "active" &&
+				subscriptionUpdated.cancel_at_period_end;
+			if (subscriptionCanceled) {
+				await options.subscription.onSubscriptionCancel?.({
+					subscription,
+					cancellationDetails:
+						subscriptionUpdated.cancellation_details || undefined,
+					stripeSubscription: subscriptionUpdated,
+					event,
+				});
+			}
+			await options.subscription.onSubscriptionUpdate?.({
 				event,
+				subscription,
 			});
+
+			if (
+				subscriptionUpdated.status === "active" &&
+				subscription.status === "trialing" &&
+				plan.freeTrial?.onTrialEnd
+			) {
+				const user = await ctx.context.adapter.findOne<User>({
+					model: "user",
+					where: [{ field: "id", value: subscription.referenceId }],
+				});
+				if (user) {
+					await plan.freeTrial.onTrialEnd({ subscription, user }, ctx.request);
+				}
+			}
+			if (
+				subscriptionUpdated.status === "incomplete_expired" &&
+				subscription.status === "trialing" &&
+				plan.freeTrial?.onTrialExpired
+			) {
+				await plan.freeTrial.onTrialExpired(subscription, ctx.request);
+			}
 		}
-		await options.subscription.onSubscriptionUpdate?.({
-			event,
-			subscription,
-		});
+	} catch (error: any) {
+		logger.error(`Stripe webhook failed. Error: ${error.message}`);
 	}
 }
 
@@ -142,39 +180,40 @@ export async function onSubscriptionDeleted(
 	if (!options.subscription?.enabled) {
 		return;
 	}
-	const subscriptionDeleted = event.data.object as Stripe.Subscription;
-	const subscriptionId = subscriptionDeleted.metadata?.subscriptionId;
-	const stripeSubscription = await options.stripeClient.subscriptions.retrieve(
-		subscriptionId as string,
-	);
-	if (stripeSubscription.status === "canceled") {
-		const subscription = await ctx.context.adapter.findOne<Subscription>({
-			model: "subscription",
-			where: [
-				{
-					field: "id",
-					value: subscriptionId,
-				},
-			],
-		});
-		if (subscription) {
-			await ctx.context.adapter.update({
+	try {
+		const subscriptionDeleted = event.data.object as Stripe.Subscription;
+		const subscriptionId = subscriptionDeleted.metadata?.subscriptionId;
+		if (subscriptionDeleted.status === "canceled") {
+			const subscription = await ctx.context.adapter.findOne<Subscription>({
 				model: "subscription",
 				where: [
 					{
 						field: "id",
-						value: subscription.id,
+						value: subscriptionId,
 					},
 				],
-				update: {
-					status: "canceled",
-				},
-			});
-			await options.subscription.onSubscriptionDeleted?.({
-				event,
-				stripeSubscription: subscriptionDeleted,
-				subscription,
 			});
+			if (subscription) {
+				await ctx.context.adapter.update({
+					model: "subscription",
+					where: [
+						{
+							field: "id",
+							value: subscription.id,
+						},
+					],
+					update: {
+						status: "canceled",
+					},
+				});
+				await options.subscription.onSubscriptionDeleted?.({
+					event,
+					stripeSubscription: subscriptionDeleted,
+					subscription,
+				});
+			}
 		}
+	} catch (error: any) {
+		logger.error(`Stripe webhook failed. Error: ${error.message}`);
 	}
 }

package/src/stripe.test.ts

@@ -453,4 +453,232 @@ describe("stripe", async () => {
 			expect(updatedSubscription?.status).toBe("canceled");
 		}
 	});
+
+	it("should execute subscription event handlers", async () => {
+		const onSubscriptionComplete = vi.fn();
+		const onSubscriptionUpdate = vi.fn();
+		const onSubscriptionCancel = vi.fn();
+		const onSubscriptionDeleted = vi.fn();
+
+		const testOptions = {
+			...stripeOptions,
+			subscription: {
+				...stripeOptions.subscription,
+				onSubscriptionComplete,
+				onSubscriptionUpdate,
+				onSubscriptionCancel,
+				onSubscriptionDeleted,
+			},
+			stripeWebhookSecret: "test_secret",
+		};
+
+		const testAuth = betterAuth({
+			baseURL: "http://localhost:3000",
+			database: memory,
+			emailAndPassword: {
+				enabled: true,
+			},
+			plugins: [stripe(testOptions)],
+		});
+
+		// Test subscription complete handler
+		const completeEvent = {
+			type: "checkout.session.completed",
+			data: {
+				object: {
+					mode: "subscription",
+					subscription: "sub_123",
+					metadata: {
+						referenceId: "user_123",
+						subscriptionId: "sub_123",
+					},
+				},
+			},
+		};
+
+		const mockSubscription = {
+			id: "sub_123",
+			status: "active",
+			items: {
+				data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
+			},
+			current_period_start: Math.floor(Date.now() / 1000),
+			current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+		};
+
+		const mockStripeForEvents = {
+			...testOptions.stripeClient,
+			subscriptions: {
+				retrieve: vi.fn().mockResolvedValue(mockSubscription),
+			},
+			webhooks: {
+				constructEvent: vi.fn().mockReturnValue(completeEvent),
+			},
+		};
+
+		const eventTestOptions = {
+			...testOptions,
+			stripeClient: mockStripeForEvents as unknown as Stripe,
+		};
+
+		const eventTestAuth = betterAuth({
+			baseURL: "http://localhost:3000",
+			database: memory,
+			emailAndPassword: { enabled: true },
+			plugins: [stripe(eventTestOptions)],
+		});
+
+		await ctx.adapter.create({
+			model: "subscription",
+			data: {
+				id: "sub_123",
+				referenceId: "user_123",
+				stripeCustomerId: "cus_123",
+				stripeSubscriptionId: "sub_123",
+				status: "incomplete",
+				plan: "starter",
+			},
+		});
+
+		const webhookRequest = new Request(
+			"http://localhost:3000/api/auth/stripe/webhook",
+			{
+				method: "POST",
+				headers: {
+					"stripe-signature": "test_signature",
+				},
+				body: JSON.stringify(completeEvent),
+			},
+		);
+
+		await eventTestAuth.handler(webhookRequest);
+
+		expect(onSubscriptionComplete).toHaveBeenCalledWith(
+			expect.objectContaining({
+				event: expect.any(Object),
+				subscription: expect.any(Object),
+				stripeSubscription: expect.any(Object),
+				plan: expect.any(Object),
+			}),
+		);
+
+		const updateEvent = {
+			type: "customer.subscription.updated",
+			data: {
+				object: {
+					id: "sub_123",
+					customer: "cus_123",
+					status: "active",
+					items: {
+						data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
+					},
+					current_period_start: Math.floor(Date.now() / 1000),
+					current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+				},
+			},
+		};
+
+		const updateRequest = new Request(
+			"http://localhost:3000/api/auth/stripe/webhook",
+			{
+				method: "POST",
+				headers: {
+					"stripe-signature": "test_signature",
+				},
+				body: JSON.stringify(updateEvent),
+			},
+		);
+
+		mockStripeForEvents.webhooks.constructEvent.mockReturnValue(updateEvent);
+		await eventTestAuth.handler(updateRequest);
+
+		expect(onSubscriptionUpdate).toHaveBeenCalledWith(
+			expect.objectContaining({
+				event: expect.any(Object),
+				subscription: expect.any(Object),
+			}),
+		);
+
+		const cancelEvent = {
+			type: "customer.subscription.updated",
+			data: {
+				object: {
+					id: "sub_123",
+					customer: "cus_123",
+					status: "active",
+					cancel_at_period_end: true,
+					items: {
+						data: [{ price: { id: process.env.STRIPE_PRICE_ID_1 } }],
+					},
+					current_period_start: Math.floor(Date.now() / 1000),
+					current_period_end: Math.floor(Date.now() / 1000) + 30 * 24 * 60 * 60,
+				},
+			},
+		};
+
+		const cancelRequest = new Request(
+			"http://localhost:3000/api/auth/stripe/webhook",
+			{
+				method: "POST",
+				headers: {
+					"stripe-signature": "test_signature",
+				},
+				body: JSON.stringify(cancelEvent),
+			},
+		);
+
+		mockStripeForEvents.webhooks.constructEvent.mockReturnValue(cancelEvent);
+		await eventTestAuth.handler(cancelRequest);
+
+		expect(onSubscriptionCancel).toHaveBeenCalledWith({
+			event: cancelEvent,
+			subscription: expect.objectContaining({
+				id: "sub_123",
+			}),
+			stripeSubscription: expect.objectContaining({
+				id: "sub_123",
+				cancel_at_period_end: true,
+			}),
+		});
+
+		const deleteEvent = {
+			type: "customer.subscription.deleted",
+			data: {
+				object: {
+					id: "sub_123",
+					customer: "cus_123",
+					status: "canceled",
+					metadata: {
+						referenceId: "user_123",
+						subscriptionId: "sub_123",
+					},
+				},
+			},
+		};
+
+		const deleteRequest = new Request(
+			"http://localhost:3000/api/auth/stripe/webhook",
+			{
+				method: "POST",
+				headers: {
+					"stripe-signature": "test_signature",
+				},
+				body: JSON.stringify(deleteEvent),
+			},
+		);
+
+		mockStripeForEvents.webhooks.constructEvent.mockReturnValue(deleteEvent);
+		await eventTestAuth.handler(deleteRequest);
+
+		expect(onSubscriptionDeleted).toHaveBeenCalledWith({
+			event: deleteEvent,
+			subscription: expect.objectContaining({
+				id: "sub_123",
+			}),
+			stripeSubscription: expect.objectContaining({
+				id: "sub_123",
+				status: "canceled",
+			}),
+		});
+	});
 });

package/src/types.ts

@@ -77,7 +77,10 @@ export type Plan = {
 		 * @param subscription - Subscription
 		 * @returns
 		 */
-		onTrialExpired?: (subscription: Subscription) => Promise<void>;
+		onTrialExpired?: (
+			subscription: Subscription,
+			request?: Request,
+		) => Promise<void>;
 	};
 };