better_auth-stripe 0.2.1 → 0.6.2

data/lib/better_auth/plugins/stripe.rb

@@ -1,76 +1,5 @@
 # frozen_string_literal: true
 
-require "securerandom"
-require "stripe"
-
-module BetterAuth
-  module Stripe
-    class ClientAdapter
-      attr_reader :customers, :checkout, :billing_portal, :subscriptions, :prices, :subscription_schedules, :webhooks
-
-      def initialize(api_key)
-        client = ::Stripe::StripeClient.new(api_key)
-        @customers = ResourceAdapter.new(client.v1.customers)
-        @checkout = NamespaceAdapter.new(sessions: ResourceAdapter.new(client.v1.checkout.sessions))
-        @billing_portal = NamespaceAdapter.new(sessions: ResourceAdapter.new(client.v1.billing_portal.sessions))
-        @subscriptions = ResourceAdapter.new(client.v1.subscriptions)
-        @prices = ResourceAdapter.new(client.v1.prices)
-        @subscription_schedules = ResourceAdapter.new(client.v1.subscription_schedules)
-        @webhooks = WebhooksAdapter.new
-      end
-    end
-
-    class NamespaceAdapter
-      def initialize(resources)
-        resources.each do |name, resource|
-          instance_variable_set(:"@#{name}", resource)
-          self.class.attr_reader(name) unless respond_to?(name)
-        end
-      end
-    end
-
-    class ResourceAdapter
-      def initialize(resource)
-        @resource = resource
-      end
-
-      def create(params = {}, options = nil)
-        options ? @resource.create(params || {}, options) : @resource.create(params || {})
-      end
-
-      def list(params = {})
-        @resource.list(params || {})
-      end
-
-      def search(params = {})
-        @resource.search(params || {})
-      end
-
-      def retrieve(id)
-        @resource.retrieve(id)
-      end
-
-      def update(id, params = {})
-        @resource.update(id, params || {})
-      end
-
-      def release(id)
-        @resource.release(id)
-      end
-    end
-
-    class WebhooksAdapter
-      def construct_event(payload, signature, secret)
-        ::Stripe::Webhook.construct_event(payload, signature, secret)
-      end
-
-      def construct_event_async(payload, signature, secret)
-        construct_event(payload, signature, secret)
-      end
-    end
-  end
-end
-
 module BetterAuth
   module Plugins
     singleton_class.remove_method(:stripe) if singleton_class.method_defined?(:stripe)
@@ -79,656 +8,79 @@ module BetterAuth
 
     module_function
 
-    STRIPE_ERROR_CODES = {
-      "UNAUTHORIZED" => "Unauthorized access",
-      "EMAIL_VERIFICATION_REQUIRED" => "Email verification required",
-      "SUBSCRIPTION_NOT_FOUND" => "Subscription not found",
-      "SUBSCRIPTION_PLAN_NOT_FOUND" => "Subscription plan not found",
-      "ALREADY_SUBSCRIBED_PLAN" => "You're already subscribed to this plan",
-      "REFERENCE_ID_NOT_ALLOWED" => "Reference id is not allowed",
-      "CUSTOMER_NOT_FOUND" => "Stripe customer not found for this user",
-      "UNABLE_TO_CREATE_CUSTOMER" => "Unable to create customer",
-      "UNABLE_TO_CREATE_BILLING_PORTAL" => "Unable to create billing portal session",
-      "ORGANIZATION_NOT_FOUND" => "Organization not found",
-      "ORGANIZATION_SUBSCRIPTION_NOT_ENABLED" => "Organization subscription is not enabled",
-      "AUTHORIZE_REFERENCE_REQUIRED" => "Organization subscriptions require authorizeReference callback to be configured",
-      "ORGANIZATION_HAS_ACTIVE_SUBSCRIPTION" => "Cannot delete organization with active subscription",
-      "ORGANIZATION_REFERENCE_ID_REQUIRED" => "Reference ID is required. Provide referenceId or set activeOrganizationId in session",
-      "SUBSCRIPTION_NOT_ACTIVE" => "Subscription is not active",
-      "SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION" => "Subscription is not scheduled for cancellation",
-      "STRIPE_SIGNATURE_NOT_FOUND" => "Stripe signature not found",
-      "STRIPE_WEBHOOK_SECRET_NOT_FOUND" => "Stripe webhook secret not found",
-      "FAILED_TO_CONSTRUCT_STRIPE_EVENT" => "Failed to construct Stripe event",
-      "STRIPE_WEBHOOK_ERROR" => "Stripe webhook error",
-      "INVALID_CUSTOMER_TYPE" => "Customer type must be either user or organization",
-      "INVALID_REQUEST_BODY" => "Invalid request body"
-    }.freeze
-    STRIPE_UNSAFE_METADATA_KEYS = %w[__proto__ constructor prototype].freeze
+    STRIPE_ERROR_CODES = BetterAuth::Stripe::ERROR_CODES
+    STRIPE_UNSAFE_METADATA_KEYS = BetterAuth::Stripe::Metadata::UNSAFE_KEYS
 
     def stripe(options = {})
-      config = normalize_hash(options)
-      Plugin.new(
-        id: "stripe",
-        init: ->(ctx) { {context: {schema: Schema.auth_tables(ctx.options)}} },
-        schema: stripe_schema(config),
-        endpoints: stripe_endpoints(config),
-        error_codes: STRIPE_ERROR_CODES,
-        options: config.merge(database_hooks: stripe_database_hooks(config), organization_hooks: stripe_organization_hooks(config))
-      )
+      BetterAuth::Stripe::PluginFactory.build(options)
     end
 
     def stripe_schema(config)
-      schema = {
-        user: {
-          fields: {
-            stripeCustomerId: {type: "string", required: false}
-          }
-        }
-      }
-      if config.dig(:subscription, :enabled)
-        schema[: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", required: false, default_value: "incomplete"},
-            periodStart: {type: "date", required: false},
-            periodEnd: {type: "date", required: false},
-            trialStart: {type: "date", required: false},
-            trialEnd: {type: "date", required: false},
-            cancelAtPeriodEnd: {type: "boolean", required: false, default_value: false},
-            cancelAt: {type: "date", required: false},
-            canceledAt: {type: "date", required: false},
-            endedAt: {type: "date", required: false},
-            seats: {type: "number", required: false},
-            billingInterval: {type: "string", required: false},
-            stripeScheduleId: {type: "string", required: false},
-            limits: {type: "json", required: false}
-          }
-        }
-      end
-      if config.dig(:organization, :enabled)
-        schema[:organization] = {fields: {stripeCustomerId: {type: "string", required: false}}}
-      end
-      schema
+      BetterAuth::Stripe::Schema.schema(config)
     end
 
     def stripe_endpoints(config)
-      endpoints = {stripe_webhook: stripe_webhook_endpoint(config)}
-      return endpoints unless config.dig(:subscription, :enabled)
-
-      endpoints.merge(
-        upgrade_subscription: stripe_upgrade_subscription_endpoint(config),
-        cancel_subscription_callback: stripe_cancel_callback_endpoint(config),
-        cancel_subscription: stripe_cancel_subscription_endpoint(config),
-        restore_subscription: stripe_restore_subscription_endpoint(config),
-        list_active_subscriptions: stripe_list_subscriptions_endpoint(config),
-        subscription_success: stripe_success_endpoint(config),
-        create_billing_portal: stripe_billing_portal_endpoint(config)
-      )
+      BetterAuth::Stripe::Routes.endpoints(config)
     end
 
     def stripe_database_hooks(config)
-      return {} unless config[:create_customer_on_sign_up]
-
-      {
-        user: {
-          create: {
-            before: lambda do |data, hook_ctx|
-              next unless data["email"] && !data["stripeCustomerId"]
-
-              data["id"] ||= SecureRandom.hex(16)
-              customer = stripe_find_or_create_user_customer(config, data, nil, hook_ctx)
-              {data: {id: data["id"], stripeCustomerId: stripe_id(customer)}}
-            rescue
-              nil
-            end
-          },
-          update: {
-            after: lambda do |user, _ctx|
-              next unless user && user["stripeCustomerId"]
-
-              customer = stripe_client(config).customers.retrieve(user["stripeCustomerId"])
-              next if stripe_fetch(customer, "deleted")
-              next if stripe_fetch(customer, "email") == user["email"]
-
-              stripe_client(config).customers.update(user["stripeCustomerId"], email: user["email"])
-            rescue
-              nil
-            end
-          }
-        }
-      }
+      BetterAuth::Stripe::PluginFactory.database_hooks(config)
     end
 
     def stripe_organization_hooks(config)
-      return {} unless config.dig(:organization, :enabled)
-
-      {
-        after_update_organization: lambda do |data, _ctx|
-          organization = data[:organization] || data["organization"]
-          next unless organization && organization["stripeCustomerId"]
-
-          customer = stripe_client(config).customers.retrieve(organization["stripeCustomerId"])
-          next if stripe_fetch(customer, "deleted")
-          next if stripe_fetch(customer, "name") == organization["name"]
-
-          stripe_client(config).customers.update(organization["stripeCustomerId"], name: organization["name"])
-        rescue
-          nil
-        end,
-        before_delete_organization: lambda do |data, _ctx|
-          organization = data[:organization] || data["organization"]
-          next unless organization && organization["stripeCustomerId"]
-
-          subscriptions = stripe_client(config).subscriptions.list(customer: organization["stripeCustomerId"], status: "all", limit: 100)
-          active = Array(stripe_fetch(subscriptions, "data")).any? do |subscription|
-            !%w[canceled incomplete incomplete_expired].include?(stripe_fetch(subscription, "status").to_s)
-          end
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("ORGANIZATION_HAS_ACTIVE_SUBSCRIPTION")) if active
-        end,
-        after_add_member: ->(data, ctx) { stripe_sync_organization_seats(config, data, ctx) },
-        after_remove_member: ->(data, ctx) { stripe_sync_organization_seats(config, data, ctx) },
-        after_accept_invitation: ->(data, ctx) { stripe_sync_organization_seats(config, data, ctx) }
-      }
+      BetterAuth::Stripe::OrganizationHooks.hooks(config)
     end
 
     def stripe_upgrade_subscription_endpoint(config)
-      Endpoint.new(path: "/subscription/upgrade", method: "POST") do |ctx|
-        session = Routes.current_session(ctx)
-        body = normalize_hash(ctx.body)
-        subscription_options = stripe_subscription_options(config)
-        customer_type = stripe_customer_type!(body)
-        reference_id = stripe_reference_id!(ctx, session, customer_type, body[:reference_id], config)
-        stripe_authorize_reference!(ctx, session, reference_id, "upgrade-subscription", customer_type, subscription_options, explicit: body.key?(:reference_id))
-
-        user = session.fetch(:user)
-        if subscription_options[:require_email_verification] && !user["emailVerified"]
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("EMAIL_VERIFICATION_REQUIRED"))
-        end
-
-        plan = stripe_plan_by_name(config, body[:plan])
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_PLAN_NOT_FOUND")) unless plan
-
-        subscription_to_update = nil
-        if body[:subscription_id]
-          subscription_to_update = ctx.context.adapter.find_one(model: "subscription", where: [{field: "stripeSubscriptionId", value: body[:subscription_id]}])
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless subscription_to_update && subscription_to_update["referenceId"] == reference_id
-        end
-
-        subscriptions = subscription_to_update ? [subscription_to_update] : ctx.context.adapter.find_many(model: "subscription", where: [{field: "referenceId", value: reference_id}])
-        reference_customer_id = subscriptions.find { |entry| entry["stripeCustomerId"] }&.fetch("stripeCustomerId", nil)
-        customer_id = if customer_type == "organization"
-          subscription_to_update&.fetch("stripeCustomerId", nil) || reference_customer_id || stripe_organization_customer(config, ctx, reference_id, body[:metadata])
-        else
-          subscription_to_update&.fetch("stripeCustomerId", nil) || reference_customer_id || user["stripeCustomerId"] || stripe_create_customer(config, ctx, user, body[:metadata])
-        end
-
-        active_or_trialing = subscriptions.find { |entry| stripe_active_or_trialing?(entry) }
-        active_stripe_subscriptions = stripe_active_subscriptions(config, customer_id)
-        active_stripe = active_stripe_subscriptions.find do |entry|
-          if subscription_to_update&.fetch("stripeSubscriptionId", nil) || body[:subscription_id]
-            stripe_fetch(entry, "id") == subscription_to_update&.fetch("stripeSubscriptionId", nil) || stripe_fetch(entry, "id") == body[:subscription_id]
-          elsif active_or_trialing && active_or_trialing["stripeSubscriptionId"]
-            stripe_fetch(entry, "id") == active_or_trialing["stripeSubscriptionId"]
-          else
-            false
-          end
-        end
-
-        price_id = stripe_price_id(config, plan, body[:annual])
-        raise APIError.new("BAD_REQUEST", message: "Price ID not found for the selected plan") if price_id.to_s.empty?
-        auto_managed_seats = !!(plan[:seat_price_id] && customer_type == "organization")
-        member_count = auto_managed_seats ? ctx.context.adapter.count(model: "member", where: [{field: "organizationId", value: reference_id}]) : 0
-        requested_seats = auto_managed_seats ? member_count : (body[:seats] || 1)
-        seat_only_plan = auto_managed_seats && plan[:seat_price_id] == price_id
-
-        active_resolved = active_stripe && stripe_resolve_plan_item(config, active_stripe)
-        active_stripe_item = active_resolved&.fetch(:item, nil) || stripe_subscription_item(active_stripe || {})
-        stripe_price_id_value = stripe_fetch(stripe_fetch(active_stripe_item || {}, "price") || {}, "id")
-        same_plan = active_or_trialing && active_or_trialing["plan"].to_s.downcase == body[:plan].to_s.downcase
-        same_seats = auto_managed_seats || (active_or_trialing && active_or_trialing["seats"].to_i == requested_seats.to_i)
-        same_price = !active_stripe || stripe_price_id_value == price_id
-        valid_period = !active_or_trialing || !active_or_trialing["periodEnd"] || active_or_trialing["periodEnd"] > Time.now
-        if active_or_trialing&.fetch("status", nil) == "active" && same_plan && same_seats && same_price && valid_period
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("ALREADY_SUBSCRIBED_PLAN"))
-        end
-
-        if active_stripe
-          stripe_release_plugin_schedule(ctx, config, customer_id, active_stripe, active_or_trialing || subscription_to_update)
-
-          if body[:schedule_at_period_end]
-            url = stripe_schedule_plan_change(ctx, config, active_stripe, active_or_trialing, plan, price_id, requested_seats, seat_only_plan, body)
-            next ctx.json({url: url, redirect: stripe_redirect?(body)})
-          end
-
-          old_plan = active_or_trialing && stripe_plan_by_name(config, active_or_trialing["plan"])
-          if stripe_direct_subscription_update?(old_plan, plan, auto_managed_seats)
-            url = stripe_update_active_subscription_items(ctx, config, active_stripe, active_or_trialing, old_plan, plan, price_id, requested_seats, seat_only_plan, body)
-            next ctx.json({url: url, redirect: stripe_redirect?(body)})
-          end
-
-          portal = stripe_client(config).billing_portal.sessions.create(
-            customer: customer_id,
-            return_url: stripe_url(ctx, body[:return_url] || "/"),
-            flow_data: {
-              type: "subscription_update_confirm",
-              after_completion: {type: "redirect", redirect: {return_url: stripe_url(ctx, body[:return_url] || "/")}},
-              subscription_update_confirm: {
-                subscription: stripe_fetch(active_stripe, "id"),
-                items: [stripe_line_item(config, price_id, requested_seats).merge(id: stripe_fetch(active_stripe_item || {}, "id"))]
-              }
-            }
-          )
-          next ctx.json(stripe_stringify_keys(portal).merge(redirect: stripe_redirect?(body)))
-        end
-
-        incomplete = subscriptions.find { |entry| entry["status"] == "incomplete" }
-        subscription = active_or_trialing || incomplete
-        if subscription
-          update = {plan: plan[:name].to_s.downcase, seats: requested_seats}
-          subscription = ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: update) || subscription.merge(update.transform_keys { |key| Schema.storage_key(key) })
-        else
-          subscription = ctx.context.adapter.create(
-            model: "subscription",
-            data: {plan: plan[:name].to_s.downcase, referenceId: reference_id, stripeCustomerId: customer_id, status: "incomplete", seats: requested_seats, limits: plan[:limits]}
-          )
-        end
-
-        has_ever_trialed = ctx.context.adapter.find_many(model: "subscription", where: [{field: "referenceId", value: reference_id}]).any? do |entry|
-          entry["trialStart"] || entry["trialEnd"] || entry["status"] == "trialing"
-        end
-        free_trial = (!has_ever_trialed && plan[:free_trial]) ? {trial_period_days: plan.dig(:free_trial, :days)} : {}
-        checkout_customization = subscription_options[:get_checkout_session_params]&.call(
-          {user: user, session: session.fetch(:session), plan: plan, subscription: subscription},
-          ctx.request,
-          ctx
-        ) || {}
-        custom_params = stripe_fetch(checkout_customization, "params") || {}
-        custom_options = normalize_hash(stripe_fetch(checkout_customization, "options") || {})
-        custom_subscription_data = stripe_fetch(custom_params, "subscription_data") || stripe_fetch(custom_params, "subscriptionData") || {}
-        internal_metadata = {userId: user.fetch("id"), subscriptionId: subscription.fetch("id"), referenceId: reference_id}
-        metadata = stripe_subscription_metadata_set(internal_metadata, body[:metadata], stripe_fetch(custom_params, "metadata"))
-        subscription_metadata = stripe_subscription_metadata_set(internal_metadata, body[:metadata], stripe_fetch(custom_subscription_data, "metadata"))
-        checkout_params = stripe_deep_merge(
-          custom_params,
-          customer: customer_id,
-          customer_update: (customer_type == "user") ? {name: "auto", address: "auto"} : {address: "auto"},
-          locale: body[:locale],
-          success_url: stripe_url(ctx, "#{ctx.context.base_url}/subscription/success?callbackURL=#{Rack::Utils.escape(body[:success_url] || "/")}&checkoutSessionId={CHECKOUT_SESSION_ID}"),
-          cancel_url: stripe_url(ctx, body[:cancel_url] || "/"),
-          line_items: stripe_checkout_line_items(config, plan, price_id, requested_seats, auto_managed_seats, seat_only_plan),
-          subscription_data: free_trial.merge(metadata: subscription_metadata),
-          mode: "subscription",
-          client_reference_id: reference_id,
-          metadata: metadata
-        )
-        checkout_params[:metadata] = metadata
-        checkout_params[:subscription_data] ||= {}
-        checkout_params[:subscription_data][:metadata] = subscription_metadata
-        checkout = stripe_client(config).checkout.sessions.create(checkout_params, custom_options.empty? ? nil : custom_options)
-        ctx.json(stripe_stringify_keys(checkout).merge(redirect: stripe_redirect?(body)))
-      end
+      BetterAuth::Stripe::Routes::UpgradeSubscription.endpoint(config)
     end
 
     def stripe_cancel_subscription_endpoint(config)
-      Endpoint.new(path: "/subscription/cancel", method: "POST") do |ctx|
-        session = Routes.current_session(ctx)
-        body = normalize_hash(ctx.body)
-        customer_type = stripe_customer_type!(body)
-        reference_id = stripe_reference_id!(ctx, session, customer_type, body[:reference_id], config)
-        stripe_authorize_reference!(ctx, session, reference_id, "cancel-subscription", customer_type, stripe_subscription_options(config), explicit: body.key?(:reference_id))
-        subscription = stripe_find_subscription_for_action(ctx, reference_id, body[:subscription_id], active_only: true)
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless subscription && subscription["stripeCustomerId"]
-
-        active = stripe_active_subscriptions(config, subscription["stripeCustomerId"])
-        if active.empty?
-          ctx.context.adapter.delete_many(model: "subscription", where: [{field: "referenceId", value: reference_id}])
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND"))
-        end
-        stripe_subscription = active.find { |entry| stripe_fetch(entry, "id") == subscription["stripeSubscriptionId"] }
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless stripe_subscription
-
-        portal = stripe_client(config).billing_portal.sessions.create(
-          customer: subscription["stripeCustomerId"],
-          return_url: stripe_url(ctx, "#{ctx.context.base_url}/subscription/cancel/callback?callbackURL=#{Rack::Utils.escape(body[:return_url] || "/")}&subscriptionId=#{Rack::Utils.escape(subscription.fetch("id"))}"),
-          flow_data: {type: "subscription_cancel", subscription_cancel: {subscription: stripe_fetch(stripe_subscription, "id")}}
-        )
-        ctx.json(stripe_stringify_keys(portal).merge(redirect: stripe_redirect?(body)))
-      rescue APIError
-        raise
-      rescue => error
-        if error.message.include?("already set to be canceled") && subscription && !stripe_pending_cancel?(subscription)
-          stripe_sub = stripe_client(config).subscriptions.retrieve(subscription["stripeSubscriptionId"])
-          ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: stripe_subscription_state(stripe_sub, include_status: false))
-        end
-        raise APIError.new("BAD_REQUEST", message: error.message)
-      end
+      BetterAuth::Stripe::Routes::CancelSubscription.endpoint(config)
     end
 
     def stripe_restore_subscription_endpoint(config)
-      Endpoint.new(path: "/subscription/restore", method: "POST") do |ctx|
-        session = Routes.current_session(ctx)
-        body = normalize_hash(ctx.body)
-        customer_type = stripe_customer_type!(body)
-        reference_id = stripe_reference_id!(ctx, session, customer_type, body[:reference_id], config)
-        stripe_authorize_reference!(ctx, session, reference_id, "restore-subscription", customer_type, stripe_subscription_options(config), explicit: body.key?(:reference_id))
-        subscription = stripe_find_subscription_for_action(ctx, reference_id, body[:subscription_id], active_only: false)
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless subscription && subscription["stripeCustomerId"]
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_ACTIVE")) unless stripe_active_or_trialing?(subscription)
-
-        if subscription["stripeScheduleId"]
-          schedule = stripe_client(config).subscription_schedules.retrieve(subscription["stripeScheduleId"])
-          if stripe_fetch(schedule, "status") == "active"
-            schedule = stripe_client(config).subscription_schedules.release(subscription["stripeScheduleId"])
-          end
-          ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: {stripeScheduleId: nil})
-          next ctx.json(stripe_stringify_keys(schedule))
-        end
-
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION")) unless stripe_pending_cancel?(subscription)
-
-        active = stripe_active_subscriptions(config, subscription["stripeCustomerId"]).first
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless active
-
-        update_params = if stripe_fetch(active, "cancel_at")
-          {cancel_at: ""}
-        elsif stripe_fetch(active, "cancel_at_period_end")
-          {cancel_at_period_end: false}
-        else
-          {}
-        end
-        restored = stripe_client(config).subscriptions.update(stripe_fetch(active, "id"), update_params)
-        ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: {cancelAtPeriodEnd: false, cancelAt: nil, canceledAt: nil})
-        ctx.json(stripe_stringify_keys(restored))
-      end
+      BetterAuth::Stripe::Routes::RestoreSubscription.endpoint(config)
     end
 
     def stripe_list_subscriptions_endpoint(config)
-      Endpoint.new(path: "/subscription/list", method: "GET") do |ctx|
-        session = Routes.current_session(ctx)
-        query = normalize_hash(ctx.query)
-        customer_type = stripe_customer_type!(query)
-        reference_id = stripe_reference_id!(ctx, session, customer_type, query[:reference_id], config)
-        stripe_authorize_reference!(ctx, session, reference_id, "list-subscription", customer_type, stripe_subscription_options(config), explicit: query.key?(:reference_id))
-        plans = stripe_plans(config)
-        subscriptions = ctx.context.adapter.find_many(model: "subscription", where: [{field: "referenceId", value: reference_id}]).select { |entry| stripe_active_or_trialing?(entry) }
-        ctx.json(subscriptions.map do |entry|
-          plan = plans.find { |item| item[:name].to_s.downcase == entry["plan"].to_s.downcase }
-          price_id = if entry["billingInterval"] == "year"
-            plan&.fetch(:annual_discount_price_id, nil) || plan&.fetch(:price_id, nil)
-          else
-            plan&.fetch(:price_id, nil)
-          end
-          entry.merge("limits" => plan&.fetch(:limits, nil), "priceId" => price_id)
-        end)
-      end
+      BetterAuth::Stripe::Routes::ListActiveSubscriptions.endpoint(config)
     end
 
     def stripe_billing_portal_endpoint(config)
-      Endpoint.new(path: "/subscription/billing-portal", method: "POST") do |ctx|
-        session = Routes.current_session(ctx)
-        body = normalize_hash(ctx.body)
-        customer_type = stripe_customer_type!(body)
-        reference_id = stripe_reference_id!(ctx, session, customer_type, body[:reference_id], config)
-        stripe_authorize_reference!(ctx, session, reference_id, "billing-portal", customer_type, stripe_subscription_options(config), explicit: body.key?(:reference_id))
-        customer_id = if customer_type == "organization"
-          org = ctx.context.adapter.find_one(model: "organization", where: [{field: "id", value: reference_id}])
-          org&.fetch("stripeCustomerId", nil) || stripe_active_subscription(ctx, reference_id)&.fetch("stripeCustomerId", nil)
-        else
-          session.fetch(:user)["stripeCustomerId"] || stripe_active_subscription(ctx, reference_id)&.fetch("stripeCustomerId", nil)
-        end
-        raise APIError.new("NOT_FOUND", message: STRIPE_ERROR_CODES.fetch("CUSTOMER_NOT_FOUND")) unless customer_id
-
-        portal = stripe_client(config).billing_portal.sessions.create(customer: customer_id, return_url: stripe_url(ctx, body[:return_url] || "/"), locale: body[:locale])
-        ctx.json(stripe_stringify_keys(portal).merge(redirect: stripe_redirect?(body)))
-      rescue APIError
-        raise
-      rescue
-        raise APIError.new("INTERNAL_SERVER_ERROR", message: STRIPE_ERROR_CODES.fetch("UNABLE_TO_CREATE_BILLING_PORTAL"))
-      end
+      BetterAuth::Stripe::Routes::CreateBillingPortal.endpoint(config)
     end
 
-    def stripe_cancel_callback_endpoint(config = nil)
-      Endpoint.new(path: "/subscription/cancel/callback", method: "GET") do |ctx|
-        query = normalize_hash(ctx.query)
-        callback = query[:callback_url] || "/"
-        unless query[:subscription_id]
-          raise ctx.redirect(stripe_url(ctx, callback))
-        end
-        session = Routes.current_session(ctx, allow_nil: true)
-        raise ctx.redirect(stripe_url(ctx, callback)) unless session
-
-        subscription = ctx.context.adapter.find_one(model: "subscription", where: [{field: "id", value: query[:subscription_id]}])
-        if subscription && !stripe_pending_cancel?(subscription) && subscription["stripeCustomerId"]
-          current = stripe_active_subscriptions(config || {}, subscription["stripeCustomerId"]).find { |entry| stripe_fetch(entry, "id") == subscription["stripeSubscriptionId"] }
-          if current && stripe_stripe_pending_cancel?(current)
-            ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: stripe_subscription_state(current, include_status: true))
-            stripe_subscription_options(config || {})[:on_subscription_cancel]&.call({subscription: subscription, stripeSubscription: current, stripe_subscription: current, cancellationDetails: stripe_fetch(current, "cancellation_details"), cancellation_details: stripe_fetch(current, "cancellation_details"), event: nil})
-          end
-        end
-        raise ctx.redirect(stripe_url(ctx, callback))
-      end
+    def stripe_cancel_callback_endpoint(config)
+      BetterAuth::Stripe::Routes::CancelSubscriptionCallback.endpoint(config)
     end
 
-    def stripe_success_endpoint(config = nil)
-      Endpoint.new(path: "/subscription/success", method: "GET") do |ctx|
-        query = normalize_hash(ctx.query)
-        callback = query[:callback_url] || "/"
-        checkout_session_id = query[:checkout_session_id]
-        subscription_id = query[:subscription_id]
-        if checkout_session_id
-          callback = callback.to_s.gsub("{CHECKOUT_SESSION_ID}", checkout_session_id.to_s)
-          checkout_session = begin
-            stripe_client(config || {}).checkout.sessions.retrieve(checkout_session_id)
-          rescue
-            nil
-          end
-          raise ctx.redirect(stripe_url(ctx, callback)) unless checkout_session
-
-          metadata = normalize_hash(stripe_fetch(checkout_session || {}, "metadata") || {})
-          subscription_id = metadata[:subscription_id]
-        end
-
-        unless subscription_id
-          raise ctx.redirect(stripe_url(ctx, callback))
-        end
-        session = Routes.current_session(ctx, allow_nil: true)
-        raise ctx.redirect(stripe_url(ctx, callback)) unless session
-
-        subscription = ctx.context.adapter.find_one(model: "subscription", where: [{field: "id", value: subscription_id}])
-        raise ctx.redirect(stripe_url(ctx, callback)) unless subscription
-        raise ctx.redirect(stripe_url(ctx, callback)) if stripe_active_or_trialing?(subscription)
-
-        customer_id = subscription["stripeCustomerId"] || session.fetch(:user)["stripeCustomerId"]
-        raise ctx.redirect(stripe_url(ctx, callback)) unless customer_id
-
-        stripe_subscription = stripe_active_subscriptions(config || {}, customer_id).first
-        if stripe_subscription
-          resolved = stripe_resolve_plan_item(config || {}, stripe_subscription)
-          item = resolved&.fetch(:item, nil)
-          plan = resolved&.fetch(:plan, nil)
-          if item && plan
-            ctx.context.adapter.update(
-              model: "subscription",
-              where: [{field: "id", value: subscription.fetch("id")}],
-              update: stripe_subscription_state(stripe_subscription, include_status: true, compact: false).merge(
-                plan: plan[:name].to_s.downcase,
-                seats: stripe_resolve_quantity(stripe_subscription, item, plan),
-                stripeSubscriptionId: stripe_fetch(stripe_subscription, "id")
-              )
-            )
-          end
-        end
-        raise ctx.redirect(stripe_url(ctx, callback))
-      end
+    def stripe_success_endpoint(config)
+      BetterAuth::Stripe::Routes::SubscriptionSuccess.endpoint(config)
     end
 
     def stripe_webhook_endpoint(config)
-      Endpoint.new(path: "/stripe/webhook", method: "POST") do |ctx|
-        signature = ctx.headers["stripe-signature"]
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("STRIPE_SIGNATURE_NOT_FOUND")) if signature.to_s.empty?
-
-        raise APIError.new("INTERNAL_SERVER_ERROR", message: STRIPE_ERROR_CODES.fetch("STRIPE_WEBHOOK_SECRET_NOT_FOUND")) if config[:stripe_webhook_secret].to_s.empty?
-
-        event = begin
-          if stripe_client(config).respond_to?(:webhooks)
-            webhooks = stripe_client(config).webhooks
-            if webhooks.respond_to?(:construct_event_async)
-              webhooks.construct_event_async(ctx.body, signature, config[:stripe_webhook_secret])
-            else
-              webhooks.construct_event(ctx.body, signature, config[:stripe_webhook_secret])
-            end
-          else
-            ctx.body
-          end
-        rescue
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("FAILED_TO_CONSTRUCT_STRIPE_EVENT"))
-        end
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("FAILED_TO_CONSTRUCT_STRIPE_EVENT")) unless event
-        begin
-          stripe_handle_event(ctx, event)
-        rescue
-          raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("STRIPE_WEBHOOK_ERROR"))
-        end
-        ctx.json({success: true})
-      end
+      BetterAuth::Stripe::Routes::StripeWebhook.endpoint(config)
     end
 
     def stripe_handle_event(ctx, event)
-      event = normalize_hash(event)
-      type = event[:type].to_s
-      case type
-      when "checkout.session.completed"
-        stripe_on_checkout_completed(ctx, event)
-      when "customer.subscription.created"
-        stripe_on_subscription_created(ctx, event)
-      when "customer.subscription.updated"
-        stripe_on_subscription_updated(ctx, event)
-      when "customer.subscription.deleted"
-        stripe_on_subscription_deleted(ctx, event)
-      end
-      config = ctx.context.options.plugins.find { |plugin| plugin.id == "stripe" }&.options || {}
-      config[:on_event]&.call(event)
+      BetterAuth::Stripe::Hooks.handle_event(ctx, event)
     end
 
     def stripe_on_checkout_completed(ctx, event)
-      config = ctx.context.options.plugins.find { |plugin| plugin.id == "stripe" }&.options || {}
-      object = normalize_hash(event.dig(:data, :object) || {})
-      return if object[:mode] == "setup" || !config.dig(:subscription, :enabled)
-
-      stripe_subscription = stripe_client(config).subscriptions.retrieve(object[:subscription])
-      resolved = stripe_resolve_plan_item(config, stripe_subscription)
-      return unless resolved
-
-      item = resolved.fetch(:item)
-      plan = resolved.fetch(:plan)
-      metadata = normalize_hash(object[:metadata] || {})
-      reference_id = object[:client_reference_id] || metadata[:reference_id]
-      subscription_id = metadata[:subscription_id]
-      return unless plan && reference_id && subscription_id
-
-      update = stripe_subscription_state(stripe_subscription, include_status: true).merge(
-        plan: plan[:name].to_s.downcase,
-        stripeSubscriptionId: object[:subscription],
-        seats: stripe_resolve_quantity(stripe_subscription, item, plan),
-        trialStart: stripe_time(stripe_fetch(stripe_subscription, "trial_start")),
-        trialEnd: stripe_time(stripe_fetch(stripe_subscription, "trial_end"))
-      ).compact
-      db_subscription = ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription_id}], update: update)
-      plan.dig(:free_trial, :on_trial_start)&.call(db_subscription) if db_subscription && update[:trialStart]
-      callback = config.dig(:subscription, :on_subscription_complete)
-      callback&.call({event: event, subscription: db_subscription, stripeSubscription: stripe_subscription, stripe_subscription: stripe_subscription, plan: plan}, ctx)
+      BetterAuth::Stripe::Hooks.on_checkout_completed(ctx, event)
     end
 
     def stripe_on_subscription_created(ctx, event)
-      config = ctx.context.options.plugins.find { |plugin| plugin.id == "stripe" }&.options || {}
-      object = normalize_hash(event.dig(:data, :object) || {})
-      customer_id = object[:customer].to_s
-      return if customer_id.empty?
-      metadata = normalize_hash(object[:metadata] || {})
-      existing = if metadata[:subscription_id]
-        ctx.context.adapter.find_one(model: "subscription", where: [{field: "id", value: metadata[:subscription_id]}])
-      else
-        ctx.context.adapter.find_one(model: "subscription", where: [{field: "stripeSubscriptionId", value: object[:id]}])
-      end
-      return if existing
-
-      reference = stripe_reference_by_customer(ctx, config, customer_id) || ((metadata[:reference_id] && metadata[:plan]) ? {reference_id: metadata[:reference_id], customer_type: metadata[:customer_type] || "user"} : nil)
-      return unless reference
-      resolved = stripe_resolve_plan_item(config, object)
-      return unless resolved
-      item = resolved.fetch(:item)
-      plan = resolved[:plan] || (metadata[:plan] && stripe_plan_by_name(config, metadata[:plan]))
-      return unless plan
-
-      created = ctx.context.adapter.create(
-        model: "subscription",
-        data: stripe_subscription_state(object, include_status: true).merge(
-          referenceId: reference.fetch(:reference_id),
-          stripeCustomerId: customer_id,
-          stripeSubscriptionId: object[:id],
-          plan: plan[:name].to_s.downcase,
-          seats: stripe_resolve_quantity(object, item, plan),
-          limits: plan[:limits]
-        ).compact
-      )
-      config.dig(:subscription, :on_subscription_created)&.call({event: event, subscription: created, stripeSubscription: object, stripe_subscription: object, plan: plan})
+      BetterAuth::Stripe::Hooks.on_subscription_created(ctx, event)
     end
 
     def stripe_on_subscription_updated(ctx, event)
-      config = ctx.context.options.plugins.find { |plugin| plugin.id == "stripe" }&.options || {}
-      object = normalize_hash(event.dig(:data, :object) || {})
-      resolved = stripe_resolve_plan_item(config, object)
-      return unless resolved
-      item = resolved.fetch(:item)
-
-      metadata = normalize_hash(object[:metadata] || {})
-      subscription = if metadata[:subscription_id]
-        ctx.context.adapter.find_one(model: "subscription", where: [{field: "id", value: metadata[:subscription_id]}])
-      else
-        ctx.context.adapter.find_one(model: "subscription", where: [{field: "stripeSubscriptionId", value: object[:id]}])
-      end
-      unless subscription
-        candidates = ctx.context.adapter.find_many(model: "subscription", where: [{field: "stripeCustomerId", value: object[:customer]}])
-        subscription = if candidates.length > 1
-          candidates.find { |entry| stripe_active_or_trialing?(entry) }
-        else
-          candidates.first
-        end
-      end
-      return unless subscription
-
-      plan = resolved[:plan]
-      was_pending = stripe_pending_cancel?(subscription)
-      update = stripe_subscription_state(object, include_status: true, compact: false).merge(
-        stripeSubscriptionId: object[:id],
-        seats: stripe_resolve_quantity(object, item, plan)
-      )
-      update[:plan] = plan[:name].to_s.downcase if plan
-      update[:limits] = plan[:limits] if plan&.key?(:limits)
-      updated = ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: update)
-      if object[:status] == "active" && stripe_stripe_pending_cancel?(object) && !was_pending
-        config.dig(:subscription, :on_subscription_cancel)&.call({event: event, subscription: subscription, stripeSubscription: object, stripe_subscription: object, cancellationDetails: object[:cancellation_details], cancellation_details: object[:cancellation_details]})
-      end
-      config.dig(:subscription, :on_subscription_update)&.call({event: event, subscription: updated || subscription})
-      if plan && subscription["status"] == "trialing" && object[:status] == "active"
-        plan.dig(:free_trial, :on_trial_end)&.call({subscription: subscription}, ctx)
-      end
-      if plan && subscription["status"] == "trialing" && object[:status] == "incomplete_expired"
-        plan.dig(:free_trial, :on_trial_expired)&.call(subscription, ctx)
-      end
+      BetterAuth::Stripe::Hooks.on_subscription_updated(ctx, event)
     end
 
     def stripe_on_subscription_deleted(ctx, event)
-      config = ctx.context.options.plugins.find { |plugin| plugin.id == "stripe" }&.options || {}
-      object = normalize_hash(event.dig(:data, :object) || {})
-      subscription = ctx.context.adapter.find_one(model: "subscription", where: [{field: "stripeSubscriptionId", value: object[:id]}])
-      return unless subscription
-
-      ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: stripe_subscription_state(object, include_status: false, compact: false).merge(status: "canceled", stripeScheduleId: nil))
-      config.dig(:subscription, :on_subscription_deleted)&.call({event: event, subscription: subscription, stripeSubscription: object, stripe_subscription: object})
+      BetterAuth::Stripe::Hooks.on_subscription_deleted(ctx, event)
     end
 
     def stripe_create_customer(config, ctx, user, metadata = nil)
@@ -801,86 +153,51 @@ module BetterAuth
     end
 
     def stripe_id(object)
-      stripe_fetch(object, "id")
+      BetterAuth::Stripe::Utils.id(object)
     end
 
     def stripe_fetch(object, key)
-      return nil unless object.respond_to?(:[])
-
-      object[key] || object[key.to_sym]
+      BetterAuth::Stripe::Utils.fetch(object, key)
     end
 
     def stripe_time(value)
-      return nil unless value
-
-      Time.at(value.to_i)
+      BetterAuth::Stripe::Utils.time(value)
     end
 
     def stripe_subscription_options(config)
-      normalize_hash(config[:subscription] || {})
+      BetterAuth::Stripe::Utils.subscription_options(config)
     end
 
     def stripe_plans(config)
-      plans = stripe_subscription_options(config)[:plans] || []
-      plans = plans.call if plans.respond_to?(:call)
-      Array(plans).map do |plan|
-        normalized = normalize_hash(plan)
-        limits = stripe_fetch(plan, "limits")
-        normalized[:limits] = limits if limits
-        normalized
-      end
+      BetterAuth::Stripe::Utils.plans(config)
     end
 
     def stripe_plan_by_name(config, name)
-      stripe_plans(config).find { |plan| plan[:name].to_s.downcase == name.to_s.downcase }
+      BetterAuth::Stripe::Utils.plan_by_name(config, name)
     end
 
     def stripe_plan_by_price_info(config, price_id, lookup_key = nil)
-      stripe_plans(config).find do |plan|
-        plan[:price_id] == price_id || plan[:annual_discount_price_id] == price_id || (lookup_key && (plan[:lookup_key] == lookup_key || plan[:annual_discount_lookup_key] == lookup_key))
-      end
+      BetterAuth::Stripe::Utils.plan_by_price_info(config, price_id, lookup_key)
     end
 
     def stripe_price_id(config, plan, annual = false)
-      annual ? (plan[:annual_discount_price_id] || stripe_resolve_lookup(config, plan[:annual_discount_lookup_key])) : (plan[:price_id] || stripe_resolve_lookup(config, plan[:lookup_key]))
+      BetterAuth::Stripe::Utils.price_id(config, plan, annual)
     end
 
     def stripe_resolve_lookup(config, lookup_key)
-      return nil if lookup_key.to_s.empty?
-      return nil unless stripe_client(config).respond_to?(:prices)
-
-      prices = stripe_client(config).prices.list(lookup_keys: [lookup_key], active: true, limit: 1)
-      stripe_fetch(Array(stripe_fetch(prices, "data")).first || {}, "id")
+      BetterAuth::Stripe::Utils.resolve_lookup(config, lookup_key)
     end
 
     def stripe_reference_id!(ctx, session, customer_type, explicit_reference_id, config)
-      return explicit_reference_id || session.fetch(:user).fetch("id") unless customer_type == "organization"
-      raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("ORGANIZATION_SUBSCRIPTION_NOT_ENABLED")) unless config.dig(:organization, :enabled)
-
-      reference_id = explicit_reference_id || session.fetch(:session)["activeOrganizationId"]
-      raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("ORGANIZATION_REFERENCE_ID_REQUIRED")) if reference_id.to_s.empty?
-      reference_id
+      BetterAuth::Stripe::Middleware.reference_id!(ctx, session, customer_type, explicit_reference_id, config)
     end
 
     def stripe_authorize_reference!(ctx, session, reference_id, action, customer_type, subscription_options, explicit: false)
-      callback = subscription_options[:authorize_reference]
-      if customer_type == "organization"
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("AUTHORIZE_REFERENCE_REQUIRED")) unless callback
-      elsif !explicit || reference_id == session.fetch(:user).fetch("id")
-        return
-      elsif !callback
-        raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("REFERENCE_ID_NOT_ALLOWED"))
-      end
-
-      allowed = callback.call({user: session.fetch(:user), session: session.fetch(:session), referenceId: reference_id, reference_id: reference_id, action: action}, ctx)
-      raise APIError.new("UNAUTHORIZED", message: STRIPE_ERROR_CODES.fetch("UNAUTHORIZED")) unless allowed
+      BetterAuth::Stripe::Middleware.authorize_reference!(ctx, session, reference_id, action, customer_type, subscription_options, explicit: explicit)
     end
 
     def stripe_customer_type!(source)
-      customer_type = (source[:customer_type] || "user").to_s
-      raise APIError.new("BAD_REQUEST", message: STRIPE_ERROR_CODES.fetch("INVALID_CUSTOMER_TYPE")) unless %w[user organization].include?(customer_type)
-
-      customer_type
+      BetterAuth::Stripe::Middleware.customer_type!(source)
     end
 
     def stripe_find_user_customer(config, email)
@@ -932,59 +249,39 @@ module BetterAuth
     end
 
     def stripe_active_or_trialing?(subscription)
-      %w[active trialing].include?(stripe_fetch(subscription, "status").to_s)
+      BetterAuth::Stripe::Utils.active_or_trialing?(subscription)
     end
 
     def stripe_pending_cancel?(subscription)
-      !!(stripe_fetch(subscription, "cancelAtPeriodEnd") || stripe_fetch(subscription, "cancelAt"))
+      BetterAuth::Stripe::Utils.pending_cancel?(subscription)
     end
 
     def stripe_stripe_pending_cancel?(subscription)
-      !!(stripe_fetch(subscription, "cancel_at_period_end") || stripe_fetch(subscription, "cancel_at"))
+      BetterAuth::Stripe::Utils.stripe_pending_cancel?(subscription)
     end
 
     def stripe_subscription_item(subscription)
-      Array(stripe_fetch(stripe_fetch(subscription, "items") || {}, "data")).first
+      BetterAuth::Stripe::Utils.subscription_item(subscription)
     end
 
     def stripe_resolve_plan_item(config, subscription)
-      items = Array(stripe_fetch(stripe_fetch(subscription, "items") || {}, "data"))
-      first = items.first
-      return nil unless first
-
-      items.each do |item|
-        price = stripe_fetch(item, "price") || {}
-        plan = stripe_plan_by_price_info(config, stripe_fetch(price, "id"), stripe_fetch(price, "lookup_key"))
-        return {item: item, plan: plan} if plan
-      end
-      {item: first, plan: nil} if items.length == 1
+      BetterAuth::Stripe::Utils.resolve_plan_item(config, subscription)
     end
 
     def stripe_resolve_quantity(subscription, plan_item, plan = nil)
-      items = Array(stripe_fetch(stripe_fetch(subscription, "items") || {}, "data"))
-      seat_price_id = plan && plan[:seat_price_id]
-      seat_item = seat_price_id && items.find { |item| stripe_fetch(stripe_fetch(item, "price") || {}, "id") == seat_price_id }
-      stripe_fetch(seat_item || plan_item, "quantity") || 1
+      BetterAuth::Stripe::Utils.resolve_quantity(subscription, plan_item, plan)
     end
 
     def stripe_line_item(config, price_id, quantity)
-      item = {price: price_id}
-      item[:quantity] = quantity unless stripe_metered_price?(config, price_id)
-      item
+      BetterAuth::Stripe::Utils.line_item(config, price_id, quantity)
     end
 
     def stripe_checkout_line_items(config, plan, price_id, quantity, auto_managed_seats, seat_only_plan)
-      items = []
-      items << stripe_line_item(config, price_id, auto_managed_seats ? 1 : quantity) unless seat_only_plan
-      items << {price: plan[:seat_price_id], quantity: quantity} if auto_managed_seats && plan[:seat_price_id]
-      items.concat(stripe_plan_line_items(plan))
-      items
+      BetterAuth::Stripe::Utils.checkout_line_items(config, plan, price_id, quantity, auto_managed_seats, seat_only_plan)
     end
 
     def stripe_plan_line_items(plan)
-      Array(plan[:line_items]).map do |item|
-        item.is_a?(Hash) ? normalize_hash(item) : item
-      end
+      BetterAuth::Stripe::Utils.plan_line_items(plan)
     end
 
     def stripe_schedule_plan_change(ctx, config, active_stripe, db_subscription, plan, price_id, quantity, seat_only_plan, body)
@@ -1060,9 +357,7 @@ module BetterAuth
     end
 
     def stripe_direct_subscription_update?(old_plan, plan, auto_managed_seats)
-      return true if auto_managed_seats && old_plan && old_plan[:seat_price_id] != plan[:seat_price_id]
-
-      stripe_plan_line_items(old_plan || {}).map { |item| item[:price] } != stripe_plan_line_items(plan).map { |item| item[:price] }
+      BetterAuth::Stripe::Utils.direct_subscription_update?(old_plan, plan, auto_managed_seats)
     end
 
     def stripe_update_active_subscription_items(ctx, config, active_stripe, db_subscription, old_plan, plan, price_id, quantity, seat_only_plan, body)
@@ -1100,131 +395,47 @@ module BetterAuth
     end
 
     def stripe_sync_organization_seats(config, data, ctx)
-      organization = data[:organization] || data["organization"]
-      return unless config.dig(:subscription, :enabled) && organization && organization["stripeCustomerId"]
-
-      member_count = ctx.context.adapter.count(model: "member", where: [{field: "organizationId", value: organization.fetch("id")}])
-      seat_plans = stripe_plans(config).select { |plan| plan[:seat_price_id] }
-      return if seat_plans.empty?
-
-      subscription = ctx.context.adapter.find_many(model: "subscription", where: [{field: "referenceId", value: organization.fetch("id")}]).find { |entry| stripe_active_or_trialing?(entry) }
-      return unless subscription && subscription["stripeSubscriptionId"]
-
-      plan = seat_plans.find { |entry| entry[:name].to_s.downcase == subscription["plan"].to_s.downcase }
-      return unless plan
-
-      stripe_subscription = stripe_client(config).subscriptions.retrieve(subscription["stripeSubscriptionId"])
-      return unless stripe_active_or_trialing?(stripe_subscription)
-
-      items = Array(stripe_fetch(stripe_fetch(stripe_subscription, "items") || {}, "data"))
-      seat_item = items.find { |item| stripe_fetch(stripe_fetch(item, "price") || {}, "id") == plan[:seat_price_id] }
-      return if seat_item && stripe_fetch(seat_item, "quantity").to_i == member_count.to_i
-
-      update_items = if seat_item
-        [{id: stripe_fetch(seat_item, "id"), quantity: member_count}]
-      else
-        [{price: plan[:seat_price_id], quantity: member_count}]
-      end
-      stripe_client(config).subscriptions.update(subscription["stripeSubscriptionId"], items: update_items, proration_behavior: plan[:proration_behavior] || "create_prorations")
-      ctx.context.adapter.update(model: "subscription", where: [{field: "id", value: subscription.fetch("id")}], update: {seats: member_count})
-    rescue
-      nil
+      BetterAuth::Stripe::OrganizationHooks.sync_seats(config, data, ctx)
     end
 
     def stripe_metered_price?(config, price_id, lookup_key = nil)
-      price = stripe_resolve_stripe_price(config, price_id, lookup_key)
-      recurring = stripe_fetch(price || {}, "recurring") || {}
-      stripe_fetch(recurring, "usage_type") == "metered"
+      BetterAuth::Stripe::Utils.metered_price?(config, price_id, lookup_key)
     end
 
     def stripe_resolve_stripe_price(config, price_id, lookup_key = nil)
-      return nil unless stripe_client(config).respond_to?(:prices)
-
-      prices = stripe_client(config).prices
-      if lookup_key
-        result = prices.list(lookup_keys: [lookup_key], active: true, limit: 1)
-        Array(stripe_fetch(result, "data")).first
-      elsif price_id && prices.respond_to?(:retrieve)
-        prices.retrieve(price_id)
-      end
-    rescue
-      nil
+      BetterAuth::Stripe::Utils.resolve_stripe_price(config, price_id, lookup_key)
     end
 
     def stripe_subscription_state(subscription, include_status: true, compact: true)
-      item = stripe_subscription_item(subscription)
-      price = stripe_fetch(item || {}, "price") || {}
-      recurring = stripe_fetch(price, "recurring") || {}
-      state = {
-        periodStart: stripe_time(stripe_fetch(item || subscription, "current_period_start")),
-        periodEnd: stripe_time(stripe_fetch(item || subscription, "current_period_end")),
-        cancelAtPeriodEnd: stripe_fetch(subscription, "cancel_at_period_end"),
-        cancelAt: stripe_time(stripe_fetch(subscription, "cancel_at")),
-        canceledAt: stripe_time(stripe_fetch(subscription, "canceled_at")),
-        endedAt: stripe_time(stripe_fetch(subscription, "ended_at")),
-        trialStart: stripe_time(stripe_fetch(subscription, "trial_start")),
-        trialEnd: stripe_time(stripe_fetch(subscription, "trial_end")),
-        billingInterval: stripe_fetch(recurring, "interval"),
-        stripeScheduleId: stripe_schedule_id(subscription)
-      }
-      state[:status] = stripe_fetch(subscription, "status") if include_status
-      compact ? state.compact : state
+      BetterAuth::Stripe::Utils.subscription_state(subscription, include_status: include_status, compact: compact)
     end
 
     def stripe_schedule_id(subscription)
-      schedule = stripe_fetch(subscription, "schedule")
-      return nil if schedule.nil?
-      return schedule if schedule.is_a?(String)
-
-      stripe_id(schedule) || schedule.to_s
+      BetterAuth::Stripe::Utils.schedule_id(subscription)
     end
 
     def stripe_reference_by_customer(ctx, config, customer_id)
-      if config.dig(:organization, :enabled)
-        org = ctx.context.adapter.find_one(model: "organization", where: [{field: "stripeCustomerId", value: customer_id}])
-        return {customer_type: "organization", reference_id: org.fetch("id")} if org
-      end
-      user = ctx.context.adapter.find_one(model: "user", where: [{field: "stripeCustomerId", value: customer_id}])
-      return {customer_type: "user", reference_id: user.fetch("id")} if user
-
-      nil
+      BetterAuth::Stripe::Middleware.reference_by_customer(ctx, config, customer_id)
     end
 
     def stripe_metadata(internal, *user_metadata)
-      user_metadata.compact
-        .reduce({}) do |acc, entry|
-          next acc unless entry.respond_to?(:each)
-
-          acc.merge(entry.each_with_object({}) do |(key, value), result|
-            metadata_key = stripe_metadata_key(key)
-            result[metadata_key] = value unless STRIPE_UNSAFE_METADATA_KEYS.include?(metadata_key)
-          end)
-        end
-        .merge(internal.transform_keys { |key| stripe_metadata_key(key) })
+      BetterAuth::Stripe::Metadata.merge(internal, *user_metadata)
     end
 
     def stripe_customer_metadata_set(internal_fields, *user_metadata)
-      stripe_metadata(internal_fields, *user_metadata)
+      BetterAuth::Stripe::Metadata.customer_set(internal_fields, *user_metadata)
     end
 
     def stripe_customer_metadata_get(metadata)
-      {
-        userId: stripe_metadata_fetch(metadata, "userId"),
-        organizationId: stripe_metadata_fetch(metadata, "organizationId"),
-        customerType: stripe_metadata_fetch(metadata, "customerType")
-      }
+      BetterAuth::Stripe::Metadata.customer_get(metadata)
     end
 
     def stripe_subscription_metadata_set(internal_fields, *user_metadata)
-      stripe_metadata(internal_fields, *user_metadata)
+      BetterAuth::Stripe::Metadata.subscription_set(internal_fields, *user_metadata)
     end
 
     def stripe_subscription_metadata_get(metadata)
-      {
-        userId: stripe_metadata_fetch(metadata, "userId"),
-        subscriptionId: stripe_metadata_fetch(metadata, "subscriptionId"),
-        referenceId: stripe_metadata_fetch(metadata, "referenceId")
-      }
+      BetterAuth::Stripe::Metadata.subscription_get(metadata)
     end
 
     def stripe_notify_customer_created(config, customer, user, ctx)
@@ -1239,54 +450,31 @@ module BetterAuth
     end
 
     def stripe_metadata_key(key)
-      case normalize_key(key)
-      when :user_id then "userId"
-      when :organization_id then "organizationId"
-      when :customer_type then "customerType"
-      when :subscription_id then "subscriptionId"
-      when :reference_id then "referenceId"
-      else
-        key.to_s
-      end
+      BetterAuth::Stripe::Metadata.metadata_key(key)
     end
 
     def stripe_metadata_fetch(metadata, key)
-      return nil unless metadata.respond_to?(:[])
-
-      metadata[key] || metadata[key.to_sym] || metadata[normalize_key(key)] || metadata[normalize_key(key).to_s]
+      BetterAuth::Stripe::Metadata.metadata_fetch(metadata, key)
     end
 
     def stripe_deep_merge(base, override)
-      normalize_hash(base).merge(normalize_hash(override)) do |_key, old, new|
-        if old.is_a?(Hash) && new.is_a?(Hash)
-          stripe_deep_merge(old, new)
-        else
-          new
-        end
-      end
+      BetterAuth::Stripe::Metadata.deep_merge(base, override)
     end
 
     def stripe_redirect?(body)
-      body[:disable_redirect] != true
+      BetterAuth::Stripe::Utils.redirect?(body)
     end
 
     def stripe_stringify_keys(value)
-      return value unless value.is_a?(Hash)
-
-      value.each_with_object({}) do |(key, object), result|
-        result[key.to_s] = object
-        result[key.to_sym] = object
-      end
+      BetterAuth::Stripe::Metadata.stringify_keys(value)
     end
 
     def stripe_url(ctx, url)
-      return url if url.to_s.match?(/\A[a-zA-Z][a-zA-Z0-9+\-.]*:/)
-
-      "#{ctx.context.base_url}#{url.to_s.start_with?("/") ? url : "/#{url}"}"
+      BetterAuth::Stripe::Utils.url(ctx, url)
     end
 
     def stripe_escape_search(value)
-      value.to_s.gsub("\"", "\\\"")
+      BetterAuth::Stripe::Utils.escape_search(value)
     end
   end
 end