better_auth-stripe 0.2.1 → 0.6.2

data/lib/better_auth/stripe/routes/index.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Routes
+      module_function
+
+      def endpoints(config)
+        endpoints = {stripe_webhook: BetterAuth::Stripe::Routes::StripeWebhook.endpoint(config)}
+        return endpoints unless config.dig(:subscription, :enabled)
+
+        endpoints.merge(
+          upgrade_subscription: BetterAuth::Stripe::Routes::UpgradeSubscription.endpoint(config),
+          cancel_subscription_callback: BetterAuth::Stripe::Routes::CancelSubscriptionCallback.endpoint(config),
+          cancel_subscription: BetterAuth::Stripe::Routes::CancelSubscription.endpoint(config),
+          restore_subscription: BetterAuth::Stripe::Routes::RestoreSubscription.endpoint(config),
+          list_active_subscriptions: BetterAuth::Stripe::Routes::ListActiveSubscriptions.endpoint(config),
+          subscription_success: BetterAuth::Stripe::Routes::SubscriptionSuccess.endpoint(config),
+          create_billing_portal: BetterAuth::Stripe::Routes::CreateBillingPortal.endpoint(config)
+        )
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/routes/list_active_subscriptions.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Routes
+      module ListActiveSubscriptions
+        module_function
+
+        def endpoint(config)
+          BetterAuth::Endpoint.new(path: "/subscription/list", method: "GET") do |ctx|
+            session = BetterAuth::Routes.current_session(ctx)
+            query = BetterAuth::Plugins.normalize_hash(ctx.query)
+            customer_type = BetterAuth::Plugins.stripe_customer_type!(query)
+            reference_id = BetterAuth::Plugins.stripe_reference_id!(ctx, session, customer_type, query[:reference_id], config)
+            BetterAuth::Plugins.stripe_authorize_reference!(ctx, session, reference_id, "list-subscription", customer_type, BetterAuth::Plugins.stripe_subscription_options(config), explicit: query.key?(:reference_id))
+            plans = BetterAuth::Plugins.stripe_plans(config)
+            subscriptions = ctx.context.adapter.find_many(model: "subscription", where: [{field: "referenceId", value: reference_id}]).select { |entry| BetterAuth::Plugins.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
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/routes/restore_subscription.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Routes
+      module RestoreSubscription
+        module_function
+
+        def endpoint(config)
+          BetterAuth::Endpoint.new(path: "/subscription/restore", method: "POST") do |ctx|
+            session = BetterAuth::Routes.current_session(ctx)
+            body = BetterAuth::Plugins.normalize_hash(ctx.body)
+            customer_type = BetterAuth::Plugins.stripe_customer_type!(body)
+            reference_id = BetterAuth::Plugins.stripe_reference_id!(ctx, session, customer_type, body[:reference_id], config)
+            BetterAuth::Plugins.stripe_authorize_reference!(ctx, session, reference_id, "restore-subscription", customer_type, BetterAuth::Plugins.stripe_subscription_options(config), explicit: body.key?(:reference_id))
+            subscription = BetterAuth::Plugins.stripe_find_subscription_for_action(ctx, reference_id, body[:subscription_id], active_only: false)
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless subscription && subscription["stripeCustomerId"]
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("SUBSCRIPTION_NOT_ACTIVE")) unless BetterAuth::Plugins.stripe_active_or_trialing?(subscription)
+
+            if subscription["stripeScheduleId"]
+              schedule = BetterAuth::Plugins.stripe_client(config).subscription_schedules.retrieve(subscription["stripeScheduleId"])
+              if BetterAuth::Plugins.stripe_fetch(schedule, "status") == "active"
+                schedule = BetterAuth::Plugins.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(BetterAuth::Plugins.stripe_stringify_keys(schedule))
+            end
+
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("SUBSCRIPTION_NOT_SCHEDULED_FOR_CANCELLATION")) unless BetterAuth::Plugins.stripe_pending_cancel?(subscription)
+
+            active = BetterAuth::Plugins.stripe_active_subscriptions(config, subscription["stripeCustomerId"]).first
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("SUBSCRIPTION_NOT_FOUND")) unless active
+
+            update_params = if BetterAuth::Plugins.stripe_fetch(active, "cancel_at")
+              {cancel_at: ""}
+            elsif BetterAuth::Plugins.stripe_fetch(active, "cancel_at_period_end")
+              {cancel_at_period_end: false}
+            else
+              {}
+            end
+            restored = BetterAuth::Plugins.stripe_client(config).subscriptions.update(BetterAuth::Plugins.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(BetterAuth::Plugins.stripe_stringify_keys(restored))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/routes/stripe_webhook.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Routes
+      module StripeWebhook
+        module_function
+
+        def endpoint(config)
+          BetterAuth::Endpoint.new(path: "/stripe/webhook", method: "POST") do |ctx|
+            signature = ctx.headers["stripe-signature"]
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("STRIPE_SIGNATURE_NOT_FOUND")) if signature.to_s.empty?
+
+            raise BetterAuth::APIError.new("INTERNAL_SERVER_ERROR", message: BetterAuth::Stripe::ERROR_CODES.fetch("STRIPE_WEBHOOK_SECRET_NOT_FOUND")) if config[:stripe_webhook_secret].to_s.empty?
+
+            event = begin
+              if BetterAuth::Plugins.stripe_client(config).respond_to?(:webhooks)
+                webhooks = BetterAuth::Plugins.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 BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("FAILED_TO_CONSTRUCT_STRIPE_EVENT"))
+            end
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("FAILED_TO_CONSTRUCT_STRIPE_EVENT")) unless event
+            begin
+              BetterAuth::Plugins.stripe_handle_event(ctx, event)
+            rescue
+              raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("STRIPE_WEBHOOK_ERROR"))
+            end
+            ctx.json({success: true})
+          end
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/routes/subscription_success.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Routes
+      module SubscriptionSuccess
+        module_function
+
+        def endpoint(config)
+          BetterAuth::Endpoint.new(path: "/subscription/success", method: "GET") do |ctx|
+            query = BetterAuth::Plugins.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
+                BetterAuth::Plugins.stripe_client(config || {}).checkout.sessions.retrieve(checkout_session_id)
+              rescue
+                nil
+              end
+              raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback)) unless checkout_session
+
+              metadata = BetterAuth::Plugins.normalize_hash(BetterAuth::Plugins.stripe_fetch(checkout_session || {}, "metadata") || {})
+              subscription_id = metadata[:subscription_id]
+            end
+
+            unless subscription_id
+              raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback))
+            end
+            session = BetterAuth::Routes.current_session(ctx, allow_nil: true)
+            raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback)) unless session
+
+            subscription = ctx.context.adapter.find_one(model: "subscription", where: [{field: "id", value: subscription_id}])
+            raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback)) unless subscription
+            raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback)) if BetterAuth::Plugins.stripe_active_or_trialing?(subscription)
+
+            customer_id = subscription["stripeCustomerId"] || session.fetch(:user)["stripeCustomerId"]
+            raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback)) unless customer_id
+
+            stripe_subscription = BetterAuth::Plugins.stripe_active_subscriptions(config || {}, customer_id).first
+            if stripe_subscription
+              resolved = BetterAuth::Plugins.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: BetterAuth::Plugins.stripe_subscription_state(stripe_subscription, include_status: true, compact: false).merge(
+                    plan: plan[:name].to_s.downcase,
+                    seats: BetterAuth::Plugins.stripe_resolve_quantity(stripe_subscription, item, plan),
+                    stripeSubscriptionId: BetterAuth::Plugins.stripe_fetch(stripe_subscription, "id")
+                  )
+                )
+              end
+            end
+            raise ctx.redirect(BetterAuth::Plugins.stripe_url(ctx, callback))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/routes/upgrade_subscription.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Routes
+      module UpgradeSubscription
+        module_function
+
+        def endpoint(config)
+          BetterAuth::Endpoint.new(path: "/subscription/upgrade", method: "POST") do |ctx|
+            session = BetterAuth::Routes.current_session(ctx)
+            body = BetterAuth::Plugins.normalize_hash(ctx.body)
+            subscription_options = BetterAuth::Plugins.stripe_subscription_options(config)
+            customer_type = BetterAuth::Plugins.stripe_customer_type!(body)
+            reference_id = BetterAuth::Plugins.stripe_reference_id!(ctx, session, customer_type, body[:reference_id], config)
+            BetterAuth::Plugins.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 BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("EMAIL_VERIFICATION_REQUIRED"))
+            end
+
+            plan = BetterAuth::Plugins.stripe_plan_by_name(config, body[:plan])
+            raise BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::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 BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::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 || BetterAuth::Plugins.stripe_organization_customer(config, ctx, reference_id, body[:metadata])
+            else
+              subscription_to_update&.fetch("stripeCustomerId", nil) || reference_customer_id || user["stripeCustomerId"] || BetterAuth::Plugins.stripe_create_customer(config, ctx, user, body[:metadata])
+            end
+
+            active_or_trialing = subscriptions.find { |entry| BetterAuth::Plugins.stripe_active_or_trialing?(entry) }
+            active_stripe_subscriptions = BetterAuth::Plugins.stripe_active_subscriptions(config, customer_id)
+            active_stripe = active_stripe_subscriptions.find do |entry|
+              if subscription_to_update&.fetch("stripeSubscriptionId", nil) || body[:subscription_id]
+                BetterAuth::Plugins.stripe_fetch(entry, "id") == subscription_to_update&.fetch("stripeSubscriptionId", nil) || BetterAuth::Plugins.stripe_fetch(entry, "id") == body[:subscription_id]
+              elsif active_or_trialing && active_or_trialing["stripeSubscriptionId"]
+                BetterAuth::Plugins.stripe_fetch(entry, "id") == active_or_trialing["stripeSubscriptionId"]
+              else
+                false
+              end
+            end
+
+            price_id = BetterAuth::Plugins.stripe_price_id(config, plan, body[:annual])
+            raise BetterAuth::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 && BetterAuth::Plugins.stripe_resolve_plan_item(config, active_stripe)
+            active_stripe_item = active_resolved&.fetch(:item, nil) || BetterAuth::Plugins.stripe_subscription_item(active_stripe || {})
+            stripe_price_id_value = BetterAuth::Plugins.stripe_fetch(BetterAuth::Plugins.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 BetterAuth::APIError.new("BAD_REQUEST", message: BetterAuth::Stripe::ERROR_CODES.fetch("ALREADY_SUBSCRIBED_PLAN"))
+            end
+
+            if active_stripe
+              BetterAuth::Plugins.stripe_release_plugin_schedule(ctx, config, customer_id, active_stripe, active_or_trialing || subscription_to_update)
+
+              if body[:schedule_at_period_end]
+                url = BetterAuth::Plugins.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: BetterAuth::Plugins.stripe_redirect?(body)})
+              end
+
+              old_plan = active_or_trialing && BetterAuth::Plugins.stripe_plan_by_name(config, active_or_trialing["plan"])
+              if BetterAuth::Plugins.stripe_direct_subscription_update?(old_plan, plan, auto_managed_seats)
+                url = BetterAuth::Plugins.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: BetterAuth::Plugins.stripe_redirect?(body)})
+              end
+
+              portal = BetterAuth::Plugins.stripe_client(config).billing_portal.sessions.create(
+                customer: customer_id,
+                return_url: BetterAuth::Plugins.stripe_url(ctx, body[:return_url] || "/"),
+                flow_data: {
+                  type: "subscription_update_confirm",
+                  after_completion: {type: "redirect", redirect: {return_url: BetterAuth::Plugins.stripe_url(ctx, body[:return_url] || "/")}},
+                  subscription_update_confirm: {
+                    subscription: BetterAuth::Plugins.stripe_fetch(active_stripe, "id"),
+                    items: [BetterAuth::Plugins.stripe_line_item(config, price_id, requested_seats).merge(id: BetterAuth::Plugins.stripe_fetch(active_stripe_item || {}, "id"))]
+                  }
+                }
+              )
+              next ctx.json(BetterAuth::Plugins.stripe_stringify_keys(portal).merge(redirect: BetterAuth::Plugins.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| BetterAuth::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 = BetterAuth::Plugins.stripe_fetch(checkout_customization, "params") || {}
+            custom_options = BetterAuth::Plugins.normalize_hash(BetterAuth::Plugins.stripe_fetch(checkout_customization, "options") || {})
+            custom_subscription_data = BetterAuth::Plugins.stripe_fetch(custom_params, "subscription_data") || BetterAuth::Plugins.stripe_fetch(custom_params, "subscriptionData") || {}
+            internal_metadata = {userId: user.fetch("id"), subscriptionId: subscription.fetch("id"), referenceId: reference_id}
+            metadata = BetterAuth::Plugins.stripe_subscription_metadata_set(internal_metadata, body[:metadata], BetterAuth::Plugins.stripe_fetch(custom_params, "metadata"))
+            subscription_metadata = BetterAuth::Plugins.stripe_subscription_metadata_set(internal_metadata, body[:metadata], BetterAuth::Plugins.stripe_fetch(custom_subscription_data, "metadata"))
+            checkout_params = BetterAuth::Plugins.stripe_deep_merge(
+              custom_params,
+              customer: customer_id,
+              customer_update: (customer_type == "user") ? {name: "auto", address: "auto"} : {address: "auto"},
+              locale: body[:locale],
+              success_url: BetterAuth::Plugins.stripe_url(ctx, "#{ctx.context.base_url}/subscription/success?callbackURL=#{Rack::Utils.escape(body[:success_url] || "/")}&checkoutSessionId={CHECKOUT_SESSION_ID}"),
+              cancel_url: BetterAuth::Plugins.stripe_url(ctx, body[:cancel_url] || "/"),
+              line_items: BetterAuth::Plugins.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 = BetterAuth::Plugins.stripe_client(config).checkout.sessions.create(checkout_params, custom_options.empty? ? nil : custom_options)
+            ctx.json(BetterAuth::Plugins.stripe_stringify_keys(checkout).merge(redirect: BetterAuth::Plugins.stripe_redirect?(body)))
+          end
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/schema.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Schema
+      module_function
+
+      def schema(config)
+        custom_schema = custom_schema(config)
+        config = BetterAuth::Plugins.normalize_hash((config || {}).reject { |key, _| key.to_s == "schema" })
+        base_schema = {
+          user: {
+            fields: {
+              stripeCustomerId: {type: "string", required: false}
+            }
+          }
+        }
+
+        if config.dig(:subscription, :enabled)
+          base_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)
+          base_schema[:organization] = {fields: {stripeCustomerId: {type: "string", required: false}}}
+        end
+
+        custom_schema = custom_schema.except(:subscription) unless config.dig(:subscription, :enabled)
+        deep_merge_schema(base_schema, custom_schema)
+      end
+
+      def custom_schema(config)
+        raw = config && (config[:schema] || config["schema"])
+        normalize_custom_schema(raw || {})
+      end
+
+      def normalize_custom_schema(value)
+        return {} unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(model_name, model_schema), result|
+          normalized_model = BetterAuth::Plugins.normalize_key(model_name)
+          result[normalized_model] = normalize_custom_model_schema(model_schema)
+        end
+      end
+
+      def normalize_custom_model_schema(value)
+        return value unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, object), result|
+          normalized_key = BetterAuth::Plugins.normalize_key(key)
+          result[normalized_key] = if normalized_key == :fields && object.is_a?(Hash)
+            object.each_with_object({}) do |(field_name, field_schema), fields|
+              fields[field_name] = field_schema
+            end
+          elsif object.is_a?(Hash)
+            BetterAuth::Plugins.normalize_hash(object)
+          else
+            object
+          end
+        end
+      end
+
+      def deep_merge_schema(base, override)
+        base.merge(override) do |_key, old_value, new_value|
+          if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+            deep_merge_schema(old_value, new_value)
+          else
+            new_value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/better_auth/stripe/types.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Types
+      CUSTOMER_TYPES = %w[user organization].freeze
+      AUTHORIZE_REFERENCE_ACTIONS = %w[
+        upgrade-subscription
+        cancel-subscription
+        restore-subscription
+        billing-portal
+        list-subscriptions
+      ].freeze
+
+      module_function
+    end
+  end
+end

data/lib/better_auth/stripe/utils.rb

@@ -0,0 +1,190 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Stripe
+    module Utils
+      module_function
+
+      def client(config)
+        BetterAuth::Plugins.stripe_client(config)
+      end
+
+      def id(object)
+        fetch(object, "id")
+      end
+
+      def fetch(object, key)
+        return nil unless object.respond_to?(:[])
+
+        object[key] || object[key.to_sym]
+      end
+
+      def time(value)
+        return nil unless value
+
+        Time.at(value.to_i)
+      end
+
+      def subscription_options(config)
+        BetterAuth::Plugins.normalize_hash(config[:subscription] || {})
+      end
+
+      def plans(config)
+        plans = subscription_options(config)[:plans] || []
+        plans = plans.call if plans.respond_to?(:call)
+        Array(plans).map do |plan|
+          normalized = BetterAuth::Plugins.normalize_hash(plan)
+          limits = fetch(plan, "limits")
+          normalized[:limits] = limits if limits
+          normalized
+        end
+      end
+
+      def plan_by_name(config, name)
+        plans(config).find { |plan| plan[:name].to_s.downcase == name.to_s.downcase }
+      end
+
+      def plan_by_price_info(config, price_id, lookup_key = nil)
+        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
+      end
+
+      def price_id(config, plan, annual = false)
+        annual ? (plan[:annual_discount_price_id] || resolve_lookup(config, plan[:annual_discount_lookup_key])) : (plan[:price_id] || resolve_lookup(config, plan[:lookup_key]))
+      end
+
+      def resolve_lookup(config, lookup_key)
+        return nil if lookup_key.to_s.empty?
+        return nil unless client(config).respond_to?(:prices)
+
+        prices = client(config).prices.list(lookup_keys: [lookup_key], active: true, limit: 1)
+        fetch(Array(fetch(prices, "data")).first || {}, "id")
+      end
+
+      def active_or_trialing?(subscription)
+        %w[active trialing].include?(fetch(subscription, "status").to_s)
+      end
+
+      def pending_cancel?(subscription)
+        !!(fetch(subscription, "cancelAtPeriodEnd") || fetch(subscription, "cancelAt"))
+      end
+
+      def stripe_pending_cancel?(subscription)
+        !!(fetch(subscription, "cancel_at_period_end") || fetch(subscription, "cancel_at"))
+      end
+
+      def subscription_item(subscription)
+        Array(fetch(fetch(subscription, "items") || {}, "data")).first
+      end
+
+      def resolve_plan_item(config, subscription)
+        items = Array(fetch(fetch(subscription, "items") || {}, "data"))
+        first = items.first
+        return nil unless first
+
+        items.each do |item|
+          price = fetch(item, "price") || {}
+          plan = plan_by_price_info(config, fetch(price, "id"), fetch(price, "lookup_key"))
+          return {item: item, plan: plan} if plan
+        end
+        {item: first, plan: nil} if items.length == 1
+      end
+
+      def resolve_quantity(subscription, plan_item, plan = nil)
+        items = Array(fetch(fetch(subscription, "items") || {}, "data"))
+        seat_price_id = plan && plan[:seat_price_id]
+        seat_item = seat_price_id && items.find { |item| fetch(fetch(item, "price") || {}, "id") == seat_price_id }
+        fetch(seat_item || plan_item, "quantity") || 1
+      end
+
+      def line_item(config, price_id, quantity)
+        item = {price: price_id}
+        item[:quantity] = quantity unless metered_price?(config, price_id)
+        item
+      end
+
+      def checkout_line_items(config, plan, price_id, quantity, auto_managed_seats, seat_only_plan)
+        items = []
+        items << 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(plan_line_items(plan))
+        items
+      end
+
+      def plan_line_items(plan)
+        Array(plan[:line_items]).map do |item|
+          item.is_a?(Hash) ? BetterAuth::Plugins.normalize_hash(item) : item
+        end
+      end
+
+      def 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]
+
+        plan_line_items(old_plan || {}).map { |item| item[:price] } != plan_line_items(plan).map { |item| item[:price] }
+      end
+
+      def metered_price?(config, price_id, lookup_key = nil)
+        price = resolve_stripe_price(config, price_id, lookup_key)
+        recurring = fetch(price || {}, "recurring") || {}
+        fetch(recurring, "usage_type") == "metered"
+      end
+
+      def resolve_stripe_price(config, price_id, lookup_key = nil)
+        return nil unless client(config).respond_to?(:prices)
+
+        prices = client(config).prices
+        if lookup_key
+          result = prices.list(lookup_keys: [lookup_key], active: true, limit: 1)
+          Array(fetch(result, "data")).first
+        elsif price_id && prices.respond_to?(:retrieve)
+          prices.retrieve(price_id)
+        end
+      rescue
+        nil
+      end
+
+      def subscription_state(subscription, include_status: true, compact: true)
+        item = subscription_item(subscription)
+        price = fetch(item || {}, "price") || {}
+        recurring = fetch(price, "recurring") || {}
+        state = {
+          periodStart: time(fetch(item || subscription, "current_period_start")),
+          periodEnd: time(fetch(item || subscription, "current_period_end")),
+          cancelAtPeriodEnd: fetch(subscription, "cancel_at_period_end"),
+          cancelAt: time(fetch(subscription, "cancel_at")),
+          canceledAt: time(fetch(subscription, "canceled_at")),
+          endedAt: time(fetch(subscription, "ended_at")),
+          trialStart: time(fetch(subscription, "trial_start")),
+          trialEnd: time(fetch(subscription, "trial_end")),
+          billingInterval: fetch(recurring, "interval"),
+          stripeScheduleId: schedule_id(subscription)
+        }
+        state[:status] = fetch(subscription, "status") if include_status
+        compact ? state.compact : state
+      end
+
+      def schedule_id(subscription)
+        schedule = fetch(subscription, "schedule")
+        return nil if schedule.nil?
+        return schedule if schedule.is_a?(String)
+
+        id(schedule) || schedule.to_s
+      end
+
+      def redirect?(body)
+        body[:disable_redirect] != true
+      end
+
+      def 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}"}"
+      end
+
+      def escape_search(value)
+        value.to_s.gsub("\"", "\\\"")
+      end
+    end
+  end
+end