better_auth-rails 0.2.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: cc3d5bd26fdfd519d462f2634d4187d3a52a7334864cd2fcddf43c22b88c0975
-  data.tar.gz: 9b3f4ff8abd83a3264706fbb6e8406835168d781f6a247eba896f4736b4041a6
+  metadata.gz: d3bbbf52a2438b83d1668fc4b3d15eb28f162e9cc81cd4e88c37008407fcb5ff
+  data.tar.gz: d2b18b69ffcfb01601aa9a48e01883d0b1a6cc032e087b1fa92c5efa9d2eba08
 SHA512:
-  metadata.gz: 78edf35b13082e9ab5ab0a964978dcf9fce608abcee9c080268a9868e1e7e9a24ce73033e36c3547e7b5eaacbbdf1573b695c95e2ac3805ce04f9048291f7e24
-  data.tar.gz: c9a6a504de5d9560d4223ce47a8c4f9b2b3c331b890f061bac1ae56d9ef7a9a0e30a57d4f7c683aff2a32d9869fe2dc307686aac72e453e4dd7412de070a5272
+  metadata.gz: 4b70675596c580f94602b8505fc0df556da325a614aaff02c19b9939ff9d959354405986c55c0737c1d7f6b10dfeabc0f3168a75eff9736607651d26dc020544
+  data.tar.gz: 2cfa4a247413b9caa48c21613873021ccde047d813f34adf311b83bfa58192f186375d215f9eb883c81debf1b7406e4e628a2d721811bf060fab5db9c1ca5aed

data/README.md

@@ -80,48 +80,47 @@ BetterAuth::Rails.configure do |config|
 
   config.base_url = ENV["BETTER_AUTH_URL"]
   config.base_path = "/api/auth"
-  config.database = ->(options) { BetterAuth::Rails::ActiveRecordAdapter.new(options) }
   config.trusted_origins = [
     ENV["BETTER_AUTH_URL"]
   ].compact
 
-  config.session = {
-    cookie_cache: {
-      enabled: true,
-      max_age: 5 * 60,
-      strategy: "jwe"
-    }
-  }
-
-  config.advanced = {
-    ip_address: {
-      ip_address_headers: ["x-forwarded-for"],
-      disable_ip_tracking: false
-    }
-  }
-
-  config.experimental = {
-    joins: false
-  }
-
-  config.social_providers = {
-    # github: BetterAuth::SocialProviders.github(
+  config.session do |session|
+    session.cookie_cache do |cookie|
+      cookie.enabled = true
+      cookie.max_age = 5 * 60
+      cookie.strategy = "jwe"
+    end
+  end
+
+  config.advanced do |advanced|
+    advanced.ip_address do |ip|
+      ip.ip_address_headers = ["x-forwarded-for"]
+      ip.disable_ip_tracking = false
+    end
+  end
+
+  config.experimental do |experimental|
+    experimental.joins = false
+  end
+
+  config.social_providers do |providers|
+    # providers.github = BetterAuth::SocialProviders.github(
     #   client_id: ENV.fetch("GITHUB_CLIENT_ID"),
     #   client_secret: ENV.fetch("GITHUB_CLIENT_SECRET")
     # )
-  }
+  end
 
   config.plugins = []
-  config.hooks = {
-    before: [],
-    after: []
-  }
+  config.hooks do |hooks|
+    hooks.before = []
+    hooks.after = []
+  end
 end
 ```
 
 Rails configuration is a thin option builder for the core Rack auth object. The same option concepts are available in core Ruby through `BetterAuth.auth(...)`; Rails places them in `config/initializers/better_auth.rb` so applications can rely on credentials, ActiveRecord, and Rails environment configuration.
 
-The ActiveRecord adapter uses whichever database adapter the Rails app is already configured with, including PostgreSQL and MySQL.
+Rails uses `BetterAuth::Rails::ActiveRecordAdapter` by default. The adapter uses whichever database adapter the Rails app is already configured with, including PostgreSQL and MySQL. To be explicit, set `config.database_adapter = :active_record`; for custom adapters, assign `config.database` directly.
 
 ### JavaScript Client
 

data/lib/better_auth/rails/active_record_adapter.rb

@@ -20,12 +20,16 @@ module BetterAuth
 
       attr_reader :connection
 
-      def initialize(options, connection: nil)
+      def initialize(options = nil, connection: nil)
         super(options)
-        @connection = connection || ::ActiveRecord::Base
+        @connection = connection || (options ? ::ActiveRecord::Base : nil)
         @models = {}
       end
 
+      def call(options)
+        self.class.new(options, connection: connection)
+      end
+
       def create(model:, data:, force_allow_id: false)
         model = model.to_s
         input = transform_input(model, data, "create", force_allow_id)
@@ -219,36 +223,107 @@ module BetterAuth
       end
 
       def define_join_associations(model, klass)
-        case model
-        when "session", "account"
-          return unless klass.respond_to?(:belongs_to)
-
-          klass.belongs_to(
-            :user,
-            class_name: model_class("user").name,
-            foreign_key: storage_field(model, "userId"),
-            primary_key: storage_field("user", "id"),
-            optional: true
-          )
-        when "user"
-          return unless klass.respond_to?(:has_many)
-
-          klass.has_many(
-            :accounts,
-            class_name: model_class("account").name,
-            foreign_key: storage_field("account", "userId"),
-            primary_key: storage_field("user", "id")
-          )
+        schema_models.each_key do |join_model|
+          next if join_model == model
+
+          definition = safe_join_definition(model, join_model)
+          next unless definition
+
+          association = definition.fetch(:association)
+          next if association_defined?(klass, association)
+
+          if definition[:owner] == :base && definition[:collection]
+            next unless klass.respond_to?(:has_many)
+
+            klass.has_many(
+              association,
+              class_name: model_class(join_model).name,
+              foreign_key: storage_field(join_model, definition.fetch(:to)),
+              primary_key: storage_field(model, definition.fetch(:from))
+            )
+          elsif definition[:owner] == :base
+            next unless klass.respond_to?(:has_one)
+
+            klass.has_one(
+              association,
+              class_name: model_class(join_model).name,
+              foreign_key: storage_field(join_model, definition.fetch(:to)),
+              primary_key: storage_field(model, definition.fetch(:from))
+            )
+          else
+            next unless klass.respond_to?(:belongs_to)
+
+            klass.belongs_to(
+              association,
+              class_name: model_class(join_model).name,
+              foreign_key: storage_field(model, definition.fetch(:from)),
+              primary_key: storage_field(join_model, definition.fetch(:to)),
+              optional: true
+            )
+          end
         end
       end
 
       def join_definition(model, join_model)
-        case [model.to_s, join_model.to_s]
-        when ["session", "user"], ["account", "user"]
-          {association: :user, collection: false}
-        when ["user", "account"]
-          {association: :accounts, collection: true}
+        inferred_join_config(model.to_s, join_model.to_s).merge(association: join_model.to_sym)
+      end
+
+      def safe_join_definition(model, join_model)
+        join_definition(model, join_model)
+      rescue BetterAuth::Error
+        nil
+      end
+
+      def inferred_join_config(model, join_model)
+        foreign_keys = schema_for(join_model).fetch(:fields).select do |_field, attributes|
+          reference_model_matches?(attributes, model)
         end
+
+        unless foreign_keys.empty?
+          raise BetterAuth::Error, "Multiple foreign keys found for model #{join_model} and base model #{model} while performing join operation. Only one foreign key is supported." if foreign_keys.length > 1
+
+          foreign_key, attributes = foreign_keys.first
+          reference = attributes.fetch(:references)
+          unique = attributes[:unique] == true
+          return {
+            from: reference.fetch(:field).to_s,
+            to: foreign_key,
+            collection: !unique,
+            owner: :base
+          }
+        end
+
+        foreign_keys = schema_for(model).fetch(:fields).select do |_field, attributes|
+          reference_model_matches?(attributes, join_model)
+        end
+
+        raise BetterAuth::Error, "No foreign key found for model #{join_model} and base model #{model} while performing join operation." if foreign_keys.empty?
+        raise BetterAuth::Error, "Multiple foreign keys found for model #{join_model} and base model #{model} while performing join operation. Only one foreign key is supported." if foreign_keys.length > 1
+
+        foreign_key, attributes = foreign_keys.first
+        reference = attributes.fetch(:references)
+        {
+          from: foreign_key,
+          to: reference.fetch(:field).to_s,
+          collection: false,
+          owner: :join
+        }
+      end
+
+      def reference_model_matches?(attributes, model)
+        reference = attributes[:references]
+        return false unless reference
+
+        reference_model = reference[:model] || reference["model"]
+        reference_model.to_s == model.to_s || reference_model.to_s == table_for(model)
+      end
+
+      def association_defined?(klass, association)
+        klass.respond_to?(:reflect_on_association) && klass.reflect_on_association(association)
+      end
+
+      def schema_models
+        BetterAuth::Schema.auth_tables(options)
       end
 
       def model_namespace

data/lib/better_auth/rails/configuration.rb

@@ -29,9 +29,35 @@ module BetterAuth
         disabled_paths
         logger
       ].freeze
+      BLOCK_OPTION_NAMES = %i[
+        rate_limit
+        session
+        account
+        user
+        verification
+        advanced
+        email_and_password
+        email_verification
+        social_providers
+        experimental
+        database_hooks
+        hooks
+        on_api_error
+      ].freeze
 
       attr_accessor(*AUTH_OPTION_NAMES)
 
+      BLOCK_OPTION_NAMES.each do |name|
+        define_method(name) do |&block|
+          value = instance_variable_get(:"@#{name}")
+          return value unless block
+
+          builder = OptionBuilder.new(value.is_a?(Hash) ? value : {})
+          block.call(builder)
+          public_send(:"#{name}=", deep_merge(value.is_a?(Hash) ? value : {}, builder.to_h))
+        end
+      end
+
       def initialize
         @base_path = BetterAuth::Configuration::DEFAULT_BASE_PATH
         @plugins = []
@@ -39,6 +65,15 @@ module BetterAuth
         @database = ->(options) { ActiveRecordAdapter.new(options) }
       end
 
+      def database_adapter=(adapter)
+        case adapter&.to_sym
+        when :active_record
+          self.database = ->(options) { ActiveRecordAdapter.new(options) }
+        else
+          raise ArgumentError, "Unsupported database_adapter: #{adapter.inspect}. Use :active_record or assign a custom adapter with config.database = ..."
+        end
+      end
+
       def to_auth_options
         AUTH_OPTION_NAMES.each_with_object({}) do |name, options|
           value = public_send(name)
@@ -48,6 +83,18 @@ module BetterAuth
           options[name] = value
         end
       end
+
+      private
+
+      def deep_merge(base, override)
+        base.merge(override) do |_key, old_value, new_value|
+          if old_value.is_a?(Hash) && new_value.is_a?(Hash)
+            deep_merge(old_value, new_value)
+          else
+            new_value
+          end
+        end
+      end
     end
   end
 end

data/lib/better_auth/rails/option_builder.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module BetterAuth
+  module Rails
+    class OptionBuilder
+      def initialize(values = {})
+        @values = deep_dup(symbolize_keys(values || {}))
+      end
+
+      def to_h
+        deep_dup(@values)
+      end
+
+      def method_missing(name, *args, &block)
+        method_name = name.to_s
+        if method_name.end_with?("=")
+          key = method_name.delete_suffix("=").to_sym
+          @values[key] = args.first
+        elsif block
+          key = method_name.to_sym
+          nested = self.class.new(@values[key].is_a?(Hash) ? @values[key] : {})
+          yield nested
+          @values[key] = nested.to_h
+        elsif args.empty?
+          @values[method_name.to_sym]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(_name, _include_private = false)
+        true
+      end
+
+      private
+
+      def symbolize_keys(value)
+        return value unless value.is_a?(Hash)
+
+        value.each_with_object({}) do |(key, object_value), result|
+          normalized_key = key.to_s
+            .gsub(/([a-z\d])([A-Z])/, "\\1_\\2")
+            .tr("-", "_")
+            .downcase
+            .to_sym
+          result[normalized_key] = object_value.is_a?(Hash) ? symbolize_keys(object_value) : object_value
+        end
+      end
+
+      def deep_dup(value)
+        return value.transform_values { |entry| deep_dup(entry) } if value.is_a?(Hash)
+        return value.map { |entry| deep_dup(entry) } if value.is_a?(Array)
+
+        value
+      end
+    end
+  end
+end

data/lib/better_auth/rails/version.rb

@@ -2,6 +2,6 @@
 
 module BetterAuth
   module Rails
-    VERSION = "0.2.1"
+    VERSION = "0.5.0"
   end
 end

data/lib/better_auth/rails.rb

@@ -2,6 +2,7 @@
 
 require "better_auth"
 require_relative "rails/version"
+require_relative "rails/option_builder"
 require_relative "rails/configuration"
 require_relative "rails/migration"
 require_relative "rails/active_record_adapter"

data/lib/generators/better_auth/install/templates/initializer.rb.tt

@@ -8,43 +8,50 @@ BetterAuth::Rails.configure do |config|
 
   config.base_url = ENV["BETTER_AUTH_URL"]
   config.base_path = "/api/auth"
-  config.database = ->(options) { BetterAuth::Rails::ActiveRecordAdapter.new(options) }
   config.trusted_origins = [
     ENV["BETTER_AUTH_URL"]
   ].compact
 
-  config.session = {
-    cookie_cache: {
-      enabled: true,
-      max_age: 5 * 60,
-      strategy: "jwe"
-    }
-  }
-
-  config.advanced = {
-    ip_address: {
-      ip_address_headers: ["x-forwarded-for"],
-      disable_ip_tracking: false
-    }
-  }
-
-  config.experimental = {
-    joins: false
-  }
-
-  config.social_providers = {
-    # github: BetterAuth::SocialProviders.github(
+  # Rails apps use BetterAuth::Rails::ActiveRecordAdapter by default.
+  # For a custom adapter, assign config.database directly.
+
+  # config.email_and_password do |auth|
+  #   auth.enabled = true
+  #   auth.require_email_verification = true
+  # end
+
+  config.session do |session|
+    session.cookie_cache do |cookie|
+      cookie.enabled = true
+      cookie.max_age = 5 * 60
+      cookie.strategy = "jwe"
+    end
+  end
+
+  config.advanced do |advanced|
+    advanced.ip_address do |ip|
+      ip.ip_address_headers = ["x-forwarded-for"]
+      ip.disable_ip_tracking = false
+    end
+  end
+
+  config.experimental do |experimental|
+    experimental.joins = false
+  end
+
+  config.social_providers do |providers|
+    # providers.github = BetterAuth::SocialProviders.github(
     #   client_id: ENV.fetch("GITHUB_CLIENT_ID"),
     #   client_secret: ENV.fetch("GITHUB_CLIENT_SECRET")
     # )
-  }
+  end
 
   # Add Better Auth plugins here.
   config.plugins = []
 
   # Add Better Auth hooks here. Auth decisions still run through the core gem.
-  config.hooks = {
-    before: [],
-    after: []
-  }
+  config.hooks do |hooks|
+    hooks.before = []
+    hooks.after = []
+  end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_auth-rails
 version: !ruby/object:Gem::Version
-  version: 0.2.1
+  version: 0.5.0
 platform: ruby
 authors:
 - Sebastian Sala
@@ -167,6 +167,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.5'
+- !ruby/object:Gem::Dependency
+  name: mysql2
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
 description: Rails integration for Better Auth Ruby. Provides middleware, controller
   helpers, and generators.
 email:
@@ -184,6 +198,7 @@ files:
 - lib/better_auth/rails/controller_helpers.rb
 - lib/better_auth/rails/migration.rb
 - lib/better_auth/rails/mounted_app.rb
+- lib/better_auth/rails/option_builder.rb
 - lib/better_auth/rails/railtie.rb
 - lib/better_auth/rails/routing.rb
 - lib/better_auth/rails/version.rb