better_auth 0.8.0 → 0.11.0

data/lib/better_auth/adapters/sql.rb

@@ -2,6 +2,7 @@
 
 require "securerandom"
 require "json"
+require "monitor"
 require "time"
 
 module BetterAuth
@@ -15,6 +16,7 @@ module BetterAuth
         super(options)
         @connection = connection
         @dialect = dialect.to_sym
+        @connection_lock = Monitor.new
       end
 
       def create(model:, data:, force_allow_id: false)
@@ -30,7 +32,36 @@ module BetterAuth
         row = rows.first
         return normalize_record(model, row) if row
 
-        find_one(model: model, where: [{field: "id", value: input.fetch("id")}])
+        lookup = create_lookup(model, input)
+        lookup ? find_one(model: model, where: [lookup]) : input
+      end
+
+      def create_if_absent(model:, data:, conflict_field: "id", force_allow_id: true)
+        model = model.to_s
+        field = atomic_schema_field(schema_for(model).fetch(:fields), conflict_field)
+        input = transform_input(model, data, "create", force_allow_id)
+        raise APIError.new("BAD_REQUEST", message: "Missing conflict field #{conflict_field}") unless input.key?(field)
+
+        columns = input.keys.map { |key| storage_field(model, key) }
+        params = input.values
+        values = params.each_index.map { |index| placeholder(index + 1) }.join(", ")
+        table = quote(table_for(model))
+        conflict_column = quote(storage_field(model, field))
+        quoted_columns = columns.map { |column| quote(column) }.join(", ")
+
+        case dialect
+        when :postgres, :sqlite
+          sql = "INSERT INTO #{table} (#{quoted_columns}) VALUES (#{values}) ON CONFLICT (#{conflict_column}) DO NOTHING RETURNING #{conflict_column}"
+          !execute(sql, params).empty?
+        when :mysql
+          transaction { create_if_absent_mysql(model, field, input, table, quoted_columns, values, params) }
+        when :mssql
+          sql = "INSERT INTO #{table} (#{quoted_columns}) OUTPUT inserted.#{conflict_column} " \
+            "SELECT #{values} WHERE NOT EXISTS (SELECT 1 FROM #{table} WITH (UPDLOCK, HOLDLOCK) WHERE #{conflict_column} = #{placeholder(params.length + 1)})"
+          !execute(sql, params + [input.fetch(field)]).empty?
+        else
+          raise NotImplementedError, "create_if_absent is unsupported for #{dialect}"
+        end
       end
 
       def find_one(model:, where: [], select: nil, join: nil)
@@ -61,21 +92,29 @@ module BetterAuth
 
       def update(model:, where:, update:)
         model = model.to_s
+        return nil if Array(where).empty?
+
+        ensure_update_input_has_fields!(model, update)
         if dialect == :postgres
           records = update_many(model: model, where: where, update: update, returning: true)
           return records.is_a?(Array) ? records.first : records
         end
 
-        existing = find_one(model: model, where: where, select: ["id"])
+        existing = find_one(model: model, where: where)
         return nil unless existing
 
-        update_many(model: model, where: where, update: update)
-        find_one(model: model, where: [{field: "id", value: existing.fetch("id")}])
+        updated_count = update_many(model: model, where: where, update: update)
+        return nil unless updated_count.to_i.positive?
+
+        lookup = record_lookup(model, existing)
+        lookup ? find_one(model: model, where: [lookup]) : find_one(model: model, where: where)
       end
 
       def update_many(model:, where:, update:, returning: false)
         model = model.to_s
+        ensure_update_input_has_fields!(model, update)
         data = transform_input(model, update, "update", true)
+        ensure_update_data!(data)
         params = []
         assignments = data.each_key.map do |field|
           params << data[field]
@@ -87,11 +126,11 @@ module BetterAuth
         sql << " SET "
         sql << assignments.join(", ")
         sql << " WHERE #{where_sql}" unless where_sql.empty?
-        sql << " RETURNING *" if dialect == :postgres
-        rows = execute(sql, params).map { |row| normalize_record(model, row) }
-        return rows if returning || dialect == :postgres
+        sql << " RETURNING *" if dialect == :postgres && returning
+        result = execute(sql, params, affected_rows_result: !returning)
+        return result.map { |row| normalize_record(model, row) } if returning
 
-        nil
+        affected_rows(result)
       end
 
       def delete(model:, where:)
@@ -99,14 +138,15 @@ module BetterAuth
         nil
       end
 
-      def delete_many(model:, where:)
+      def delete_many(model:, where:, limit: nil)
         model = model.to_s
         params = []
         where_sql = build_where(model, where || [], params)
         sql = +"DELETE FROM "
         sql << quote(table_for(model))
         sql << " WHERE #{where_sql}" unless where_sql.empty?
-        result = execute(sql, params)
+        sql << " LIMIT #{Integer(limit)}" if limit && dialect == :mysql
+        result = execute(sql, params, affected_rows_result: true)
         affected_rows(result)
       end
 
@@ -121,18 +161,217 @@ module BetterAuth
         (row["count"] || row[:count] || 0).to_i
       end
 
+      def consume_one(model:, where:)
+        model = model.to_s
+        case dialect
+        when :postgres, :sqlite
+          consume_one_with_returning(model, where)
+        when :mssql
+          consume_one_with_output(model, where)
+        else
+          transaction { consume_one_with_lock(model, where) }
+        end
+      end
+
+      def increment_one(model:, where:, increment:, set: nil, allow_server_managed: false)
+        model = model.to_s
+        increments, assignments = normalize_atomic_update(model, increment, set, allow_server_managed)
+        case dialect
+        when :postgres, :sqlite
+          increment_one_with_returning(model, where, increments, assignments)
+        when :mssql
+          increment_one_with_output(model, where, increments, assignments)
+        else
+          transaction { increment_one_with_lock(model, where, increments, assignments) }
+        end
+      end
+
       def transaction
-        execute("BEGIN", [])
-        result = yield self
-        execute("COMMIT", [])
-        result
-      rescue
-        execute("ROLLBACK", [])
-        raise
+        return yield active_transaction_adapter if active_transaction_adapter
+
+        @connection_lock.synchronize do
+          execute("BEGIN", [])
+          result = with_transaction_context(self) { yield self }
+          execute("COMMIT", [])
+          result
+        rescue
+          execute("ROLLBACK", [])
+          raise
+        end
       end
 
       private
 
+      def consume_one_with_returning(model, where)
+        params = []
+        where_sql = build_where(model, where || [], params)
+        lookup = quote(storage_field(model, atomic_lookup_field(model)))
+        lock = (dialect == :postgres) ? " FOR UPDATE" : ""
+        table = quote(table_for(model))
+        sql = "DELETE FROM #{table} WHERE #{lookup} IN (SELECT #{lookup} FROM #{table}"
+        sql << " WHERE #{where_sql}" unless where_sql.empty?
+        sql << " LIMIT 1#{lock}) RETURNING *"
+        normalize_record(model, execute(sql, params).first)
+      end
+
+      def consume_one_with_output(model, where)
+        params = []
+        where_sql = build_where(model, where || [], params)
+        sql = "DELETE TOP (1) FROM #{quote(table_for(model))} OUTPUT deleted.*"
+        sql << " WHERE #{where_sql}" unless where_sql.empty?
+        normalize_record(model, execute(sql, params).first)
+      end
+
+      def consume_one_with_lock(model, where)
+        target = select_atomic_target(model, where)
+        return nil unless target
+
+        lookup = record_lookup(model, target)
+        raise Error, "#{self.class} cannot atomically identify a #{model} row" unless lookup
+
+        deleted = delete_many(model: model, where: [lookup], limit: 1)
+        ensure_numeric_affected_rows!(deleted, "delete_many")
+        deleted.positive? ? target : nil
+      end
+
+      def increment_one_with_returning(model, where, increments, assignments)
+        params = []
+        assignment_sql = atomic_assignments_sql(model, increments, assignments, params)
+        where_sql = build_where(model, where || [], params)
+        lookup = quote(storage_field(model, atomic_lookup_field(model)))
+        lock = (dialect == :postgres) ? " FOR UPDATE" : ""
+        table = quote(table_for(model))
+        sql = "UPDATE #{table} SET #{assignment_sql} WHERE #{lookup} IN (SELECT #{lookup} FROM #{table}"
+        sql << " WHERE #{where_sql}" unless where_sql.empty?
+        sql << " LIMIT 1#{lock}) RETURNING *"
+        normalize_record(model, execute(sql, params).first)
+      end
+
+      def increment_one_with_output(model, where, increments, assignments)
+        params = []
+        assignment_sql = atomic_assignments_sql(model, increments, assignments, params)
+        where_sql = build_where(model, where || [], params)
+        sql = "UPDATE TOP (1) #{quote(table_for(model))} SET #{assignment_sql} OUTPUT inserted.*"
+        sql << " WHERE #{where_sql}" unless where_sql.empty?
+        normalize_record(model, execute(sql, params).first)
+      end
+
+      def increment_one_with_lock(model, where, increments, assignments)
+        target = select_atomic_target(model, where)
+        return nil unless target
+
+        lookup = record_lookup(model, target)
+        raise Error, "#{self.class} cannot atomically identify a #{model} row" unless lookup
+
+        params = []
+        assignment_sql = atomic_assignments_sql(model, increments, assignments, params)
+        guarded_where = Array(where) + [lookup.merge(connector: "AND")]
+        where_sql = build_where(model, guarded_where, params)
+        sql = "UPDATE #{quote(table_for(model))} SET #{assignment_sql} WHERE #{where_sql} LIMIT 1"
+        affected = affected_rows(execute(sql, params, affected_rows_result: true))
+        ensure_numeric_affected_rows!(affected, "update")
+        find_one(model: model, where: [lookup])
+      end
+
+      def select_atomic_target(model, where)
+        params = []
+        where_sql = build_where(model, where || [], params)
+        sql = "SELECT #{select_sql(model, nil, nil)} FROM #{quote(table_for(model))}"
+        sql << " WHERE #{where_sql}" unless where_sql.empty?
+        sql << " LIMIT 1 FOR UPDATE"
+        normalize_record(model, execute(sql, params).first)
+      end
+
+      def normalize_atomic_update(model, increment, set, allow_server_managed)
+        raise APIError.new("BAD_REQUEST", message: "increment must be a Hash") unless increment.is_a?(Hash)
+
+        fields = schema_for(model).fetch(:fields)
+        increments = increment.each_with_object({}) do |(field, delta), result|
+          logical_field = atomic_schema_field(fields, field)
+          attributes = fields[logical_field]
+          valid_field = attributes && logical_field != "id" && attributes[:type] == "number"
+          valid_field = false if attributes && attributes[:input] == false && allow_server_managed != true
+          unless valid_field
+            raise APIError.new("BAD_REQUEST", message: "Invalid increment field #{field}; expected a mutable numeric field")
+          end
+          if !delta.is_a?(Numeric) || (delta.respond_to?(:finite?) && !delta.finite?)
+            raise APIError.new("BAD_REQUEST", message: "Increment delta for #{field} must be numeric")
+          end
+
+          result[logical_field] = delta
+        end
+        assignments = if set.nil? || set.empty?
+          {}
+        else
+          ensure_update_input_has_fields!(model, set)
+          transform_input(model, set, "update", true)
+        end
+        increments.reject! { |field, _delta| assignments.key?(field) }
+        if increments.empty? && assignments.empty?
+          raise APIError.new("BAD_REQUEST", message: "increment_one requires a non-empty increment or set")
+        end
+
+        [increments, assignments]
+      end
+
+      def atomic_assignments_sql(model, increments, assignments, params)
+        increment_sql = increments.map do |field, delta|
+          column = quote(storage_field(model, field))
+          params << delta
+          "#{column} = COALESCE(#{column}, 0) + #{placeholder(params.length)}"
+        end
+        set_sql = assignments.map do |field, value|
+          params << value
+          "#{quote(storage_field(model, field))} = #{placeholder(params.length)}"
+        end
+        (increment_sql + set_sql).join(", ")
+      end
+
+      def atomic_schema_field(fields, field)
+        candidate = storage_key(field)
+        return candidate if fields.key?(candidate)
+
+        fields.find { |logical, attributes| storage_key(attributes[:field_name] || logical) == candidate }&.first
+      end
+
+      def create_if_absent_mysql(model, field, input, table, columns, values, params)
+        savepoint = "better_auth_create_if_absent"
+        execute("SAVEPOINT #{savepoint}", [])
+        begin
+          execute("INSERT INTO #{table} (#{columns}) VALUES (#{values})", params)
+          execute("RELEASE SAVEPOINT #{savepoint}", [])
+          true
+        rescue => error
+          execute("ROLLBACK TO SAVEPOINT #{savepoint}", [])
+          execute("RELEASE SAVEPOINT #{savepoint}", [])
+          existing = find_one(model: model, where: [{field: field, value: input.fetch(field)}])
+          return false if mysql_duplicate_error?(error) && existing
+
+          raise error
+        end
+      end
+
+      def mysql_duplicate_error?(error)
+        (error.respond_to?(:error_number) && error.error_number == 1062) ||
+          (error.respond_to?(:errno) && error.errno == 1062)
+      end
+
+      def atomic_lookup_field(model)
+        fields = schema_for(model).fetch(:fields)
+        return "id" if fields.key?("id")
+
+        unique = fields.find { |_field, attributes| attributes[:unique] }
+        return unique.first if unique
+
+        raise Error, "#{self.class} cannot atomically identify a #{model} row without an id or unique field"
+      end
+
+      def ensure_numeric_affected_rows!(value, operation)
+        return value if value.is_a?(Numeric)
+
+        raise Error, "#{self.class} returned a non-numeric affected-row result from #{operation}"
+      end
+
       def transform_input(model, data, action, force_allow_id)
         fields = Schema.auth_tables(options).fetch(model).fetch(:fields)
         input = stringify_keys(data)
@@ -160,10 +399,47 @@ module BetterAuth
           output[field] = coerce_value(value, attributes) if value_provided
         end
 
-        output["id"] = generated_id if action == "create" && !output.key?("id")
+        output["id"] = generated_id if action == "create" && !output.key?("id") && fields.key?("id")
         output
       end
 
+      def create_lookup(model, input)
+        fields = schema_for(model).fetch(:fields)
+        return {field: "id", value: input.fetch("id")} if fields.key?("id") && input.key?("id")
+
+        unique_field = fields.find { |field, attributes| attributes[:unique] && input.key?(field) }
+        return {field: unique_field.first, value: input.fetch(unique_field.first)} if unique_field
+
+        nil
+      end
+
+      def record_lookup(model, record)
+        fields = schema_for(model).fetch(:fields)
+        return {field: "id", value: record.fetch("id")} if fields.key?("id") && record.key?("id")
+
+        unique_field = fields.find { |field, attributes| attributes[:unique] && record.key?(field) }
+        return {field: unique_field.first, value: record.fetch(unique_field.first)} if unique_field
+
+        nil
+      end
+
+      def ensure_update_data!(data)
+        raise APIError.new("BAD_REQUEST", message: "No fields to update") if data.empty?
+      end
+
+      def ensure_update_input_has_fields!(model, update)
+        raise APIError.new("BAD_REQUEST", message: "No fields to update") unless update.is_a?(Hash)
+
+        fields = schema_for(model).fetch(:fields)
+        input = stringify_keys(update)
+        has_updatable_field = input.any? do |field, _value|
+          next false if field == "id" || field == "_id"
+
+          fields.key?(field) || fields.any? { |logical_field, attributes| storage_key(attributes[:field_name] || logical_field) == field }
+        end
+        raise APIError.new("BAD_REQUEST", message: "No fields to update") unless has_updatable_field
+      end
+
       def select_sql(model, select, join)
         fields = Array(select).empty? ? schema_for(model).fetch(:fields).keys : Array(select).map { |field| storage_key(field) }
         columns = fields.map do |field|
@@ -220,39 +496,51 @@ module BetterAuth
       end
 
       def build_where(model, where, params)
-        Array(where).each_with_index.map do |clause, index|
-          field = storage_key(fetch_key(clause, :field))
-          column = "#{quote(table_for(model))}.#{quote(storage_field(model, field))}"
-          operator = (fetch_key(clause, :operator) || "eq").to_s
-          value = fetch_key(clause, :value)
-          attributes = schema_for(model).fetch(:fields).fetch(field)
-
-          expression = case operator
+        and_clauses, or_clauses = grouped_where_clauses(where)
+        and_sql = and_clauses.map { |clause| build_where_clause(model, clause, params) }
+        or_sql = or_clauses.map { |clause| build_where_clause(model, clause, params) }
+        return and_sql.join(" AND ") if or_sql.empty?
+        return or_sql.join(" OR ") if and_sql.empty?
+
+        "(#{and_sql.join(" AND ")}) AND (#{or_sql.join(" OR ")})"
+      end
+
+      def build_where_clause(model, clause, params)
+        field = storage_key(fetch_key(clause, :field))
+        column = "#{quote(table_for(model))}.#{quote(storage_field(model, field))}"
+        operator = (fetch_key(clause, :operator) || "eq").to_s
+        value = fetch_key(clause, :value)
+        attributes = schema_for(model).fetch(:fields).fetch(field)
+        insensitive = insensitive_string_predicate?(clause, attributes)
+        predicate_column = insensitive ? "LOWER(#{column})" : column
+
+        if value.nil? && %w[eq ne].include?(operator)
+          null_operator = (operator == "ne") ? "IS NOT NULL" : "IS NULL"
+          "#{column} #{null_operator}"
+        else
+          case operator
           when "in", "not_in"
-            values = Array(value).map { |entry| coerce_where_value(entry, attributes) }
+            values = Array(value).map { |entry| insensitive ? entry.to_s.downcase : coerce_where_value(entry, attributes) }
             placeholders = values.map do |entry|
               params << entry
               placeholder(params.length)
             end.join(", ")
             sql_operator = (operator == "not_in") ? "NOT IN" : "IN"
-            "#{column} #{sql_operator} (#{placeholders})"
+            "#{predicate_column} #{sql_operator} (#{placeholders})"
           when "contains", "starts_with", "ends_with"
-            escaped = escape_like(value)
+            escaped = escape_like(insensitive ? value.to_s.downcase : value)
             pattern = case operator
             when "starts_with" then "#{escaped}%"
             when "ends_with" then "%#{escaped}"
             else "%#{escaped}%"
             end
             params << pattern
-            "#{column} LIKE #{placeholder(params.length)} ESCAPE #{escape_literal}"
+            "#{predicate_column} LIKE #{placeholder(params.length)} ESCAPE #{escape_literal}"
           else
-            params << coerce_where_value(value, attributes)
-            "#{column} #{sql_operator(operator)} #{placeholder(params.length)}"
+            params << (insensitive ? value.to_s.downcase : coerce_where_value(value, attributes))
+            "#{predicate_column} #{sql_operator(operator)} #{placeholder(params.length)}"
           end
-
-          connector = (index.positive? && fetch_key(clause, :connector).to_s.upcase == "OR") ? "OR" : "AND"
-          index.zero? ? expression : "#{connector} #{expression}"
-        end.join(" ")
+        end
       end
 
       def order_sql(model, sort_by)
@@ -286,34 +574,66 @@ module BetterAuth
         }.fetch(operator, "=")
       end
 
-      def execute(sql, params)
-        if connection.respond_to?(:exec_params)
-          result = connection.exec_params(sql, params)
-          return result.to_a if result.respond_to?(:to_a)
-
-          result
-        elsif connection.respond_to?(:query) && params.empty?
-          result = connection.query(sql)
-          result.respond_to?(:to_a) ? result.to_a : result
-        elsif connection.respond_to?(:prepare)
-          statement = connection.prepare(sql)
-          result = statement.execute(*params)
-          result.respond_to?(:to_a) ? result.to_a : result
-        elsif connection.respond_to?(:execute)
-          result = connection.execute(sql, params)
-          result.respond_to?(:to_a) ? result.to_a : result
-        else
-          raise Error, "SQL connection must respond to exec_params or prepare"
+      def insensitive_string_predicate?(clause, attributes)
+        fetch_key(clause, :mode).to_s == "insensitive" && attributes[:type] == "string"
+      end
+
+      def execute(sql, params, affected_rows_result: false)
+        @connection_lock.synchronize do
+          if connection.respond_to?(:exec_params)
+            result = connection.exec_params(sql, params)
+            return affected_rows_result ? result : [] if result.respond_to?(:fields) && result.fields.empty?
+            return result.to_a if result.respond_to?(:to_a)
+
+            result
+          elsif connection.respond_to?(:query) && params.empty?
+            result = connection.query(sql)
+            result.respond_to?(:to_a) ? result.to_a : result
+          elsif dialect == :sqlite && connection.respond_to?(:execute)
+            result = connection.execute(sql, params)
+            result.respond_to?(:to_a) ? result.to_a : result
+          elsif connection.respond_to?(:prepare)
+            statement = connection.prepare(sql)
+            result = nil
+            begin
+              result = statement.execute(*params)
+              if result.nil?
+                return [] unless affected_rows_result
+                return statement.affected_rows if statement.respond_to?(:affected_rows)
+                return connection.affected_rows if connection.respond_to?(:affected_rows)
+              end
+
+              rows = result.respond_to?(:to_a) ? result.to_a : result
+              rows
+            ensure
+              if result.respond_to?(:close)
+                result.close
+              elsif statement.respond_to?(:close)
+                statement.close
+              end
+            end
+          elsif connection.respond_to?(:execute)
+            result = connection.execute(sql, params)
+            result.respond_to?(:to_a) ? result.to_a : result
+          else
+            raise Error, "SQL connection must respond to exec_params or prepare"
+          end
         end
       end
 
       def affected_rows(result)
-        return result.cmd_tuples if result.respond_to?(:cmd_tuples)
-        return result.affected_rows if result.respond_to?(:affected_rows)
-        return connection.changes if connection.respond_to?(:changes)
-        return result.to_i if result.respond_to?(:to_i)
-
-        0
+        value = if result.respond_to?(:cmd_tuples)
+          result.cmd_tuples
+        elsif result.respond_to?(:affected_rows)
+          result.affected_rows
+        elsif result.is_a?(Numeric)
+          result
+        elsif connection.respond_to?(:affected_rows)
+          connection.affected_rows
+        elsif connection.respond_to?(:changes)
+          connection.changes
+        end
+        ensure_numeric_affected_rows!(value, "SQL mutation")
       end
 
       def normalize_record(model, row, join: nil)
@@ -360,6 +680,8 @@ module BetterAuth
             if config[:relation] == "one-to-one" || config[:unique] == true
               grouped[key][join_model] = joined
             else
+              next if grouped[key][join_model].length >= join_limit(config)
+
               grouped[key][join_model] << joined
             end
           end
@@ -406,11 +728,11 @@ module BetterAuth
       end
 
       def escape_like(value)
-        value.to_s.gsub(/[\\%_]/) { |match| "\\#{match}" }
+        value.to_s.gsub(/[!%_]/) { |match| "!#{match}" }
       end
 
       def escape_literal
-        (dialect == :postgres) ? "'\\\\'" : "'\\'"
+        "'!'"
       end
 
       def resolve_default(default)
@@ -420,9 +742,13 @@ module BetterAuth
       def coerce_value(value, attributes)
         return value if value.nil?
         return value ? 1 : 0 if dialect == :sqlite && attributes[:type] == "boolean"
-        return value.iso8601(6) if dialect == :sqlite && attributes[:type] == "date" && value.respond_to?(:iso8601)
+        if dialect == :sqlite && attributes[:type] == "date"
+          value = Time.parse(value) if value.is_a?(String)
+          return value.iso8601(6) if value.respond_to?(:iso8601)
+        end
         return Time.parse(value) if attributes[:type] == "date" && value.is_a?(String)
         return JSON.generate(value) if json_like?(attributes) && !value.is_a?(String)
+        return value.encode(Encoding::UTF_8) if attributes[:type] == "string" && value.is_a?(String) && value.encoding == Encoding::ASCII_8BIT
 
         value
       end
@@ -446,6 +772,7 @@ module BetterAuth
       def coerce_output_value(value, attributes)
         return value if value.nil?
         return coerce_boolean(value) if attributes[:type] == "boolean"
+        return coerce_number(value) if attributes[:type] == "number"
         return Time.parse(value) if attributes[:type] == "date" && value.is_a?(String)
         return parse_json_value(value) if json_like?(attributes) && value.is_a?(String)
 

data/lib/better_auth/api.rb

@@ -70,15 +70,7 @@ module BetterAuth
     def prepare_context_for_call!(request, headers)
       return unless context.respond_to?(:prepare_for_api_call!)
 
-      source = direct_call_source(request, headers)
-      if context.options.dynamic_base_url? && source.nil? && !dynamic_base_url_fallback?
-        raise APIError.new(
-          "INTERNAL_SERVER_ERROR",
-          message: "Dynamic baseURL could not be resolved for this direct auth.api call. Pass `headers: request.headers` (or `request`) to the call, or add `fallback` to your baseURL config."
-        )
-      end
-
-      context.prepare_for_api_call!(source)
+      context.prepare_for_api_call!(direct_call_source(request, headers))
     end
 
     def direct_call_source(request, headers)
@@ -88,13 +80,6 @@ module BetterAuth
       nil
     end
 
-    def dynamic_base_url_fallback?
-      config = context.options.base_url_config
-      return false unless config.is_a?(Hash)
-
-      !!(config[:fallback] || config["fallback"])
-    end
-
     def run_endpoint_with_hooks(endpoint, endpoint_context)
       before = run_before_hooks(endpoint_context)
       return normalize_short_circuit(before, endpoint_context) if before
@@ -114,11 +99,7 @@ module BetterAuth
       endpoint_context.returned = result.response
       endpoint_context.response_headers = result.headers.dup
 
-      after_result = run_after_hooks(endpoint_context)
-      result.response = after_result.response
-      result.headers = after_result.headers
-      result.status = after_result.status if after_result.status
-      result
+      run_after_hooks(endpoint_context)
     rescue APIError => error
       Endpoint::Result.new(response: error, status: error.status_code, headers: error.headers)
     end
@@ -163,9 +144,7 @@ module BetterAuth
         next unless hook_result
 
         normalized = Endpoint::Result.from_value(hook_result, endpoint_context)
-        result.response = normalized.response
-        result.status = normalized.status
-        result.headers = normalized.headers
+        result = normalized
         endpoint_context.returned = result.response
         endpoint_context.response_headers = result.headers
       end