@better-auth/stripe 1.2.0-beta.18

package/dist/index.cjs

@@ -0,0 +1,779 @@
+'use strict';
+
+const plugins = require('better-auth/plugins');
+const zod = require('zod');
+const api = require('better-auth/api');
+const crypto = require('better-auth/crypto');
+
+async function getPlans(options) {
+  return typeof options?.subscription?.plans === "function" ? await options.subscription?.plans() : options.subscription?.plans;
+}
+async function getPlanByPriceId(options, priceId) {
+  return await getPlans(options).then(
+    (res) => res?.find((plan) => plan.priceId === priceId)
+  );
+}
+async function getPlanByName(options, name) {
+  return await getPlans(options).then(
+    (res) => res?.find((plan) => plan.name.toLowerCase() === name.toLowerCase())
+  );
+}
+
+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({
+          model: "subscription",
+          where: [
+            {
+              field: "id",
+              value: subscriptionId
+            }
+          ]
+        });
+      }
+      await options.subscription?.onSubscriptionComplete?.({
+        event,
+        subscription: dbSubscription,
+        stripeSubscription: subscription,
+        plan
+      });
+      return;
+    }
+  }
+}
+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) {
+      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
+    });
+  }
+}
+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({
+        model: "subscription",
+        where: [
+          {
+            field: "id",
+            value: subscription.id
+          }
+        ],
+        update: {
+          status: "canceled"
+        }
+      });
+      await options.subscription.onSubscriptionDeleted?.({
+        event,
+        stripeSubscription: subscriptionDeleted,
+        subscription
+      });
+    }
+  }
+}
+
+const getSchema = (options) => {
+  const subscriptions = {
+    subscription: {
+      fields: {
+        plan: {
+          type: "string",
+          required: true
+        },
+        referenceId: {
+          type: "string",
+          required: true
+        },
+        stripeCustomerId: {
+          type: "string",
+          required: false
+        },
+        stripeSubscriptionId: {
+          type: "string",
+          required: false
+        },
+        status: {
+          type: "string",
+          defaultValue: "incomplete"
+        },
+        periodStart: {
+          type: "date",
+          required: false
+        },
+        periodEnd: {
+          type: "date",
+          required: false
+        },
+        cancelAtPeriodEnd: {
+          type: "boolean",
+          required: false,
+          defaultValue: false
+        },
+        seats: {
+          type: "number",
+          required: false
+        }
+      }
+    }
+  };
+  const user = {
+    user: {
+      fields: {
+        stripeCustomerId: {
+          type: "string",
+          required: false
+        }
+      }
+    }
+  };
+  return {
+    ...options.subscription?.enabled ? subscriptions : {},
+    ...user
+  };
+};
+
+const STRIPE_ERROR_CODES = {
+  SUBSCRIPTION_NOT_FOUND: "Subscription not found",
+  SUBSCRIPTION_PLAN_NOT_FOUND: "Subscription plan not found",
+  ALREADY_SUBSCRIBED_PLAN: "You're already subscribed to this plan",
+  UNABLE_TO_CREATE_CUSTOMER: "Unable to create customer",
+  EMAIL_VERIFICATION_REQUIRED: "Email verification is required before you can subscribe to a plan"
+};
+const getUrl = (ctx, url) => {
+  if (url.startsWith("http")) {
+    return url;
+  }
+  return `${ctx.context.options.baseURL}${url.startsWith("/") ? url : `/${url}`}`;
+};
+const stripe = (options) => {
+  const client = options.stripeClient;
+  const referenceMiddleware = (action) => plugins.createAuthMiddleware(async (ctx) => {
+    const session = ctx.context.session;
+    if (!session) {
+      throw new api.APIError("UNAUTHORIZED");
+    }
+    const referenceId = ctx.body?.referenceId || ctx.query?.referenceId || session.user.id;
+    const isAuthorized = ctx.body?.referenceId ? await options.subscription?.authorizeReference?.({
+      user: session.user,
+      session: session.session,
+      referenceId,
+      action
+    }) : true;
+    if (!isAuthorized) {
+      throw new api.APIError("UNAUTHORIZED", {
+        message: "Unauthorized"
+      });
+    }
+  });
+  const subscriptionEndpoints = {
+    upgradeSubscription: plugins.createAuthEndpoint(
+      "/subscription/upgrade",
+      {
+        method: "POST",
+        body: zod.z.object({
+          plan: zod.z.string(),
+          referenceId: zod.z.string().optional(),
+          metadata: zod.z.record(zod.z.string(), zod.z.any()).optional(),
+          seats: zod.z.number({
+            description: "Number of seats to upgrade to (if applicable)"
+          }).optional(),
+          uiMode: zod.z.enum(["embedded", "hosted"]).default("hosted"),
+          successUrl: zod.z.string({
+            description: "callback url to redirect back after successful subscription"
+          }).default("/"),
+          cancelUrl: zod.z.string({
+            description: "callback url to redirect back after successful subscription"
+          }).default("/"),
+          returnUrl: zod.z.string().optional(),
+          withoutTrial: zod.z.boolean().optional(),
+          disableRedirect: zod.z.boolean().default(false)
+        }),
+        use: [
+          api.sessionMiddleware,
+          api.originCheck((c) => {
+            return [c.body.successURL, c.body.cancelURL];
+          }),
+          referenceMiddleware("upgrade-subscription")
+        ]
+      },
+      async (ctx) => {
+        const { user, session } = ctx.context.session;
+        if (!user.emailVerified && options.subscription?.requireEmailVerification) {
+          throw new api.APIError("BAD_REQUEST", {
+            message: STRIPE_ERROR_CODES.EMAIL_VERIFICATION_REQUIRED
+          });
+        }
+        const referenceId = ctx.body.referenceId || user.id;
+        const plan = await getPlanByName(options, ctx.body.plan);
+        if (!plan) {
+          throw new api.APIError("BAD_REQUEST", {
+            message: STRIPE_ERROR_CODES.SUBSCRIPTION_PLAN_NOT_FOUND
+          });
+        }
+        let customerId = user.stripeCustomerId;
+        if (!customerId) {
+          try {
+            const stripeCustomer = await client.customers.create(
+              {
+                email: user.email,
+                name: user.name,
+                metadata: {
+                  ...ctx.body.metadata,
+                  userId: user.id
+                }
+              },
+              {
+                idempotencyKey: crypto.generateRandomString(32, "a-z", "0-9")
+              }
+            );
+            await ctx.context.adapter.update({
+              model: "user",
+              update: {
+                stripeCustomerId: stripeCustomer.id
+              },
+              where: [
+                {
+                  field: "id",
+                  value: user.id
+                }
+              ]
+            });
+            customerId = stripeCustomer.id;
+          } catch (e) {
+            ctx.context.logger.error(e);
+            throw new api.APIError("BAD_REQUEST", {
+              message: STRIPE_ERROR_CODES.UNABLE_TO_CREATE_CUSTOMER
+            });
+          }
+        }
+        const activeSubscription = customerId ? await client.subscriptions.list({
+          customer: customerId,
+          status: "active"
+        }).then((res) => res.data[0]).catch((e) => null) : null;
+        const subscriptions = await ctx.context.adapter.findMany({
+          model: "subscription",
+          where: [
+            {
+              field: "referenceId",
+              value: ctx.body.referenceId || user.id
+            }
+          ]
+        });
+        const existingSubscription = subscriptions.find(
+          (sub) => sub.status === "active" || sub.status === "trialing"
+        );
+        if (activeSubscription && customerId) {
+          const { url } = await client.billingPortal.sessions.create({
+            customer: customerId,
+            return_url: getUrl(ctx, ctx.body.returnUrl || "/"),
+            flow_data: {
+              type: "subscription_update_confirm",
+              subscription_update_confirm: {
+                subscription: activeSubscription.id,
+                items: [
+                  {
+                    id: activeSubscription.items.data[0]?.id,
+                    quantity: 1,
+                    price: plan.priceId
+                  }
+                ]
+              }
+            }
+          }).catch(async (e) => {
+            if (e.message.includes("no changes")) {
+              const plan2 = await getPlanByPriceId(
+                options,
+                activeSubscription.items.data[0]?.plan.id
+              );
+              await ctx.context.adapter.update({
+                model: "subscription",
+                update: {
+                  status: activeSubscription.status,
+                  seats: activeSubscription.items.data[0]?.quantity,
+                  plan: plan2?.name.toLowerCase()
+                },
+                where: [
+                  {
+                    field: "referenceId",
+                    value: referenceId
+                  }
+                ]
+              });
+              throw new api.APIError("BAD_REQUEST", {
+                message: STRIPE_ERROR_CODES.ALREADY_SUBSCRIBED_PLAN
+              });
+            }
+            throw ctx.error("BAD_REQUEST", {
+              message: e.message,
+              code: e.code
+            });
+          });
+          return ctx.json({
+            url,
+            redirect: true
+          });
+        }
+        if (existingSubscription && existingSubscription.status === "active" && existingSubscription.plan === ctx.body.plan) {
+          throw new api.APIError("BAD_REQUEST", {
+            message: STRIPE_ERROR_CODES.ALREADY_SUBSCRIBED_PLAN
+          });
+        }
+        let subscription = existingSubscription;
+        if (!subscription) {
+          const newSubscription = await ctx.context.adapter.create({
+            model: "subscription",
+            data: {
+              plan: plan.name.toLowerCase(),
+              stripeCustomerId: customerId,
+              status: "incomplete",
+              referenceId,
+              seats: ctx.body.seats || 1
+            }
+          });
+          subscription = newSubscription;
+        }
+        if (!subscription) {
+          ctx.context.logger.error("Subscription ID not found");
+          throw new api.APIError("INTERNAL_SERVER_ERROR");
+        }
+        const params = await options.subscription?.getCheckoutSessionParams?.(
+          {
+            user,
+            session,
+            plan,
+            subscription
+          },
+          ctx.request
+        );
+        const checkoutSession = await client.checkout.sessions.create({
+          ...customerId ? {
+            customer: customerId,
+            customer_update: {
+              name: "auto",
+              address: "auto"
+            }
+          } : {
+            customer_email: session.user.email
+          },
+          success_url: getUrl(
+            ctx,
+            `${ctx.context.baseURL}/subscription/success?callbackURL=${encodeURIComponent(
+              ctx.body.successUrl
+            )}&reference=${encodeURIComponent(referenceId)}`
+          ),
+          cancel_url: getUrl(ctx, ctx.body.cancelUrl),
+          line_items: [
+            {
+              price: plan.priceId,
+              quantity: ctx.body.seats || 1
+            }
+          ],
+          mode: "subscription",
+          client_reference_id: referenceId,
+          ...params,
+          metadata: {
+            userId: user.id,
+            subscriptionId: subscription.id,
+            referenceId,
+            ...params?.params?.metadata
+          }
+        }).catch(async (e) => {
+          throw ctx.error("BAD_REQUEST", {
+            message: e.message,
+            code: e.code
+          });
+        });
+        return ctx.json({
+          ...checkoutSession,
+          redirect: !ctx.body.disableRedirect
+        });
+      }
+    ),
+    cancelSubscription: plugins.createAuthEndpoint(
+      "/subscription/cancel",
+      {
+        method: "POST",
+        body: zod.z.object({
+          referenceId: zod.z.string().optional(),
+          returnUrl: zod.z.string()
+        }),
+        use: [
+          api.sessionMiddleware,
+          api.originCheck((ctx) => ctx.body.returnUrl),
+          referenceMiddleware("cancel-subscription")
+        ]
+      },
+      async (ctx) => {
+        const referenceId = ctx.body?.referenceId || ctx.context.session.user.id;
+        const subscription = await ctx.context.adapter.findOne({
+          model: "subscription",
+          where: [
+            {
+              field: "referenceId",
+              value: referenceId
+            }
+          ]
+        });
+        if (!subscription || !subscription.stripeCustomerId) {
+          throw ctx.error("BAD_REQUEST", {
+            message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+          });
+        }
+        const activeSubscription = await client.subscriptions.list({
+          customer: subscription.stripeCustomerId,
+          status: "active"
+        }).then((res) => res.data[0]);
+        if (!activeSubscription) {
+          throw ctx.error("BAD_REQUEST", {
+            message: STRIPE_ERROR_CODES.SUBSCRIPTION_NOT_FOUND
+          });
+        }
+        const { url } = await client.billingPortal.sessions.create({
+          customer: subscription.stripeCustomerId,
+          return_url: getUrl(ctx, ctx.body?.returnUrl || "/"),
+          flow_data: {
+            type: "subscription_cancel",
+            subscription_cancel: {
+              subscription: activeSubscription.id
+            }
+          }
+        });
+        return {
+          url,
+          redirect: true
+        };
+      }
+    ),
+    listActiveSubscriptions: plugins.createAuthEndpoint(
+      "/subscription/list",
+      {
+        method: "GET",
+        query: zod.z.optional(
+          zod.z.object({
+            referenceId: zod.z.string().optional()
+          })
+        ),
+        use: [api.sessionMiddleware, referenceMiddleware("list-subscription")]
+      },
+      async (ctx) => {
+        const subscriptions = await ctx.context.adapter.findMany({
+          model: "subscription",
+          where: [
+            {
+              field: "referenceId",
+              value: ctx.query?.referenceId || ctx.context.session.user.id
+            }
+          ]
+        });
+        if (!subscriptions.length) {
+          return [];
+        }
+        const plans = await getPlans(options);
+        if (!plans) {
+          return [];
+        }
+        const subs = subscriptions.map((sub) => {
+          const plan = plans.find(
+            (p) => p.name.toLowerCase() === sub.plan.toLowerCase()
+          );
+          return {
+            ...sub,
+            limits: plan?.limits
+          };
+        }).filter((sub) => {
+          return sub.status === "active" || sub.status === "trialing";
+        });
+        return ctx.json(subs);
+      }
+    ),
+    subscriptionSuccess: plugins.createAuthEndpoint(
+      "/subscription/success",
+      {
+        method: "GET",
+        query: zod.z.record(zod.z.string(), zod.z.any()).optional()
+      },
+      async (ctx) => {
+        if (!ctx.query || !ctx.query.callbackURL || !ctx.query.reference) {
+          throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
+        }
+        const session = await api.getSessionFromCtx(
+          ctx
+        );
+        if (!session) {
+          throw ctx.redirect(getUrl(ctx, ctx.query?.callbackURL || "/"));
+        }
+        const { user } = session;
+        const { callbackURL, reference } = ctx.query;
+        const subscriptions = await ctx.context.adapter.findMany({
+          model: "subscription",
+          where: [
+            {
+              field: "referenceId",
+              value: reference
+            }
+          ]
+        });
+        const activeSubscription = subscriptions.find(
+          (sub) => sub.status === "active" || sub.status === "trialing"
+        );
+        if (activeSubscription) {
+          return ctx.redirect(getUrl(ctx, callbackURL));
+        }
+        if (user?.stripeCustomerId) {
+          try {
+            const subscription = await ctx.context.adapter.findOne({
+              model: "subscription",
+              where: [
+                {
+                  field: "referenceId",
+                  value: reference
+                }
+              ]
+            });
+            if (!subscription || subscription.status === "active") {
+              throw ctx.redirect(getUrl(ctx, callbackURL));
+            }
+            const stripeSubscription = await client.subscriptions.list({
+              customer: user.stripeCustomerId,
+              status: "active"
+            }).then((res) => res.data[0]);
+            if (stripeSubscription) {
+              const plan = await getPlanByPriceId(
+                options,
+                stripeSubscription.items.data[0]?.plan.id
+              );
+              if (plan && subscriptions.length > 0) {
+                await ctx.context.adapter.update({
+                  model: "subscription",
+                  update: {
+                    status: stripeSubscription.status,
+                    seats: stripeSubscription.items.data[0]?.quantity || 1,
+                    plan: plan.name.toLowerCase()
+                  },
+                  where: [
+                    {
+                      field: "referenceId",
+                      value: reference
+                    }
+                  ]
+                });
+              }
+            }
+          } catch (error) {
+            ctx.context.logger.error(
+              "Error fetching subscription from Stripe",
+              error
+            );
+          }
+        }
+        throw ctx.redirect(getUrl(ctx, callbackURL));
+      }
+    )
+  };
+  return {
+    id: "stripe",
+    endpoints: {
+      stripeWebhook: plugins.createAuthEndpoint(
+        "/stripe/webhook",
+        {
+          method: "POST",
+          metadata: {
+            isAction: false
+          },
+          cloneRequest: true
+        },
+        async (ctx) => {
+          if (!ctx.request?.body) {
+            throw new api.APIError("INTERNAL_SERVER_ERROR");
+          }
+          const buf = await ctx.request.text();
+          const sig = ctx.request.headers.get("stripe-signature");
+          const webhookSecret = options.stripeWebhookSecret;
+          let event;
+          try {
+            if (!sig || !webhookSecret) {
+              throw new api.APIError("BAD_REQUEST", {
+                message: "Stripe webhook secret not found"
+              });
+            }
+            event = client.webhooks.constructEvent(buf, sig, webhookSecret);
+          } catch (err) {
+            ctx.context.logger.error(`${err.message}`);
+            throw new api.APIError("BAD_REQUEST", {
+              message: `Webhook Error: ${err.message}`
+            });
+          }
+          try {
+            switch (event.type) {
+              case "checkout.session.completed":
+                await onCheckoutSessionCompleted(ctx, options, event);
+                await options.onEvent?.(event);
+                break;
+              case "customer.subscription.updated":
+                await onSubscriptionUpdated(ctx, options, event);
+                await options.onEvent?.(event);
+                break;
+              case "customer.subscription.deleted":
+                await onSubscriptionDeleted(ctx, options, event);
+                await options.onEvent?.(event);
+                break;
+              default:
+                await options.onEvent?.(event);
+                break;
+            }
+          } catch (e) {
+            ctx.context.logger.error(
+              `Stripe webhook failed. Error: ${e.message}`
+            );
+            throw new api.APIError("BAD_REQUEST", {
+              message: "Webhook error: See server logs for more information."
+            });
+          }
+          return ctx.json({ success: true });
+        }
+      ),
+      ...options.subscription?.enabled ? subscriptionEndpoints : {}
+    },
+    init(ctx) {
+      return {
+        options: {
+          databaseHooks: {
+            user: {
+              create: {
+                async after(user, ctx2) {
+                  if (ctx2 && options.createCustomerOnSignUp) {
+                    const stripeCustomer = await client.customers.create({
+                      email: user.email,
+                      name: user.name,
+                      metadata: {
+                        userId: user.id
+                      }
+                    });
+                    await ctx2.context.adapter.update({
+                      model: "user",
+                      update: {
+                        stripeCustomerId: stripeCustomer.id
+                      },
+                      where: [
+                        {
+                          field: "id",
+                          value: user.id
+                        }
+                      ]
+                    });
+                  }
+                }
+              }
+            }
+          }
+        }
+      };
+    },
+    schema: getSchema(options)
+  };
+};
+
+exports.stripe = stripe;