better_auth 0.8.0 → 0.11.0

data/lib/better_auth/adapters/memory.rb

@@ -2,21 +2,52 @@
 
 require "securerandom"
 require "time"
+require "monitor"
 
 module BetterAuth
   module Adapters
     class Memory < Base
+      include JoinSupport
+
+      LOCK_REGISTRY_GUARD = Mutex.new
+      LOCKS_BY_DATABASE = {}
+
+      class << self
+        def lock_for(database)
+          LOCK_REGISTRY_GUARD.synchronize do
+            LOCKS_BY_DATABASE[database.object_id] ||= Monitor.new
+          end
+        end
+      end
+
       attr_reader :db
 
       def initialize(options, db = nil)
         super(options)
         @db = db || build_db
+        @lock = self.class.lock_for(@db)
       end
 
       def create(model:, data:, force_allow_id: false)
-        model = model.to_s
-        table_for(model) << transform_input(model, data, "create", force_allow_id)
-        table_for(model).last
+        @lock.synchronize do
+          model = model.to_s
+          table_for(model) << transform_input(model, data, "create", force_allow_id)
+          table_for(model).last
+        end
+      end
+
+      def create_if_absent(model:, data:, conflict_field: "id", force_allow_id: true)
+        @lock.synchronize do
+          model = model.to_s
+          fields = Schema.auth_tables(options).fetch(model).fetch(:fields)
+          field = atomic_schema_field(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)
+          next false if table_for(model).any? { |record| record[field] == input[field] }
+
+          table_for(model) << input
+          true
+        end
       end
 
       def find_one(model:, where: [], select: nil, join: nil)
@@ -24,28 +55,42 @@ module BetterAuth
       end
 
       def find_many(model:, where: [], sort_by: nil, limit: nil, offset: nil, select: nil, join: nil)
-        model = model.to_s
-        records = table_for(model).select { |record| matches_where?(record, where || []) }.map(&:dup)
-        records = records.map { |record| apply_join(model, record, join) } if join
-        records = sort_records(model, records, sort_by) if sort_by
-        records = records.drop(offset.to_i) if offset
-        records = records.first(limit.to_i) if limit
-        records = records.map { |record| select_fields(model, record, select) } if select && !select.empty?
-        records
+        @lock.synchronize do
+          model = model.to_s
+          records = table_for(model).select { |record| matches_where?(record, where || []) }.map(&:dup)
+          records = records.map { |record| apply_join(model, record, join) } if join
+          records = sort_records(model, records, sort_by) if sort_by
+          records = records.drop(offset.to_i) if offset
+          records = records.first(limit.to_i) if limit
+          records = records.map { |record| select_fields(model, record, select, join: join) } if select && !select.empty?
+          records
+        end
       end
 
       def update(model:, where:, update:)
-        records = table_for(model).select { |record| matches_where?(record, where || []) }
-        data = transform_input(model.to_s, update, "update", true)
-        records.each { |record| record.merge!(data) }
-        records.first
+        @lock.synchronize do
+          model = model.to_s
+          next nil if Array(where).empty?
+
+          ensure_update_input_has_fields!(model, update)
+          records = table_for(model).select { |record| matches_where?(record, where) }
+          data = transform_input(model, update, "update", true)
+          ensure_update_data!(data)
+          records.each { |record| record.merge!(data) }
+          records.first
+        end
       end
 
       def update_many(model:, where:, update:)
-        records = table_for(model).select { |record| matches_where?(record, where || []) }
-        data = transform_input(model.to_s, update, "update", true)
-        records.each { |record| record.merge!(data) }
-        records.first
+        @lock.synchronize do
+          model = model.to_s
+          ensure_update_input_has_fields!(model, update)
+          records = table_for(model).select { |record| matches_where?(record, where || []) }
+          data = transform_input(model, update, "update", true)
+          ensure_update_data!(data)
+          records.each { |record| record.merge!(data) }
+          records.length
+        end
       end
 
       def delete(model:, where:)
@@ -54,26 +99,103 @@ module BetterAuth
       end
 
       def delete_many(model:, where:)
-        table = table_for(model)
-        matches = table.select { |record| matches_where?(record, where || []) }
-        @db[model.to_s] = table.reject { |record| matches.include?(record) }
-        matches.length
+        @lock.synchronize do
+          table = table_for(model)
+          matches = table.select { |record| matches_where?(record, where || []) }
+          @db[model.to_s] = table.reject { |record| matches.include?(record) }
+          matches.length
+        end
       end
 
       def count(model:, where: nil)
         find_many(model: model, where: where || []).length
       end
 
+      def consume_one(model:, where:)
+        @lock.synchronize do
+          table = table_for(model)
+          index = table.index { |record| matches_where?(record, where || []) }
+          index ? table.delete_at(index) : nil
+        end
+      end
+
+      def increment_one(model:, where:, increment:, set: nil, allow_server_managed: false)
+        @lock.synchronize do
+          model = model.to_s
+          increments = normalized_increments(model, increment, allow_server_managed)
+          assignments = normalized_increment_set(model, set)
+          raise APIError.new("BAD_REQUEST", message: "increment_one requires a non-empty increment or set") if increments.empty? && assignments.empty?
+
+          target = table_for(model).find { |record| matches_where?(record, where || []) }
+          next nil unless target
+
+          increments.each do |field, delta|
+            current = target[field]
+            target[field] = (current.is_a?(Numeric) ? current : 0) + delta
+          end
+          target.merge!(assignments)
+          target
+        end
+      end
+
       def transaction
-        snapshot = Marshal.load(Marshal.dump(db))
-        yield self
-      rescue
-        @db = snapshot
-        raise
+        return yield active_transaction_adapter if active_transaction_adapter
+
+        @lock.synchronize do
+          snapshot = transaction_snapshot(db)
+          begin
+            with_transaction_context(self) { yield self }
+          rescue
+            db.replace(snapshot)
+            raise
+          end
+        end
       end
 
       private
 
+      def transaction_snapshot(value, copies = {})
+        object_id = value.object_id
+        return copies.fetch(object_id) if copies.key?(object_id)
+
+        copy = case value
+        when Hash
+          value.dup.tap do |hash|
+            hash.clear
+            copies[object_id] = hash
+            if value.default_proc
+              hash.default_proc = value.default_proc
+            else
+              hash.default = transaction_snapshot(value.default, copies)
+            end
+            value.each do |key, child|
+              hash[transaction_snapshot(key, copies)] = transaction_snapshot(child, copies)
+            end
+          end
+        when Array
+          value.dup.tap do |array|
+            array.clear
+            copies[object_id] = array
+            value.each { |child| array << transaction_snapshot(child, copies) }
+          end
+        when Struct
+          value.dup.tap do |struct|
+            copies[object_id] = struct
+            value.each_pair do |member, child|
+              struct[member] = transaction_snapshot(child, copies)
+            end
+          end
+        when String, Time
+          value.dup.tap { |object| copies[object_id] = object }
+        when Proc, Method, UnboundMethod, NilClass, TrueClass, FalseClass, Symbol, Numeric
+          return value
+        else
+          raise TypeError, "Unsupported Memory transaction snapshot value: #{value.class}"
+        end
+        copy.freeze if value.frozen?
+        copy
+      end
+
       def build_db
         Schema.auth_tables(options).keys.to_h { |model| [model, []] }
       end
@@ -109,16 +231,68 @@ module BetterAuth
             raise APIError.new("BAD_REQUEST", message: "#{field} is required") unless field == "id"
           end
 
-          output[field] = coerce_value(value, attributes) if value_provided
+          output[field] = coerce_value(value, field, attributes) if value_provided
         end
 
-        output["id"] = generated_id if action == "create" && !output.key?("id")
+        output["id"] = generated_id(model) if action == "create" && fields.key?("id") && (!output.key?("id") || output["id"].nil?)
         output
       end
 
-      def generated_id
+      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.auth_tables(options).fetch(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| Schema.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 normalized_increments(model, increment, allow_server_managed)
+        raise APIError.new("BAD_REQUEST", message: "increment must be a Hash") unless increment.is_a?(Hash)
+
+        fields = Schema.auth_tables(options).fetch(model).fetch(:fields)
+        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
+      end
+
+      def normalized_increment_set(model, set)
+        return {} if set.nil? || set.empty?
+
+        ensure_update_input_has_fields!(model, set)
+        transform_input(model, set, "update", true)
+      end
+
+      def atomic_schema_field(fields, field)
+        candidate = Schema.storage_key(field)
+        return candidate if fields.key?(candidate)
+
+        fields.find { |logical, attributes| Schema.storage_key(attributes[:field_name] || logical) == candidate }&.first
+      end
+
+      def generated_id(model)
         generator = options.advanced.dig(:database, :generate_id)
         return generator.call.to_s if generator.respond_to?(:call)
+        return table_for(model).length + 1 if generator == "serial"
         return SecureRandom.uuid if generator == "uuid"
 
         SecureRandom.hex(16)
@@ -128,8 +302,9 @@ module BetterAuth
         default.respond_to?(:call) ? default.call : default
       end
 
-      def coerce_value(value, attributes)
+      def coerce_value(value, field, attributes)
         return value if value.nil?
+        return coerce_number(value) if serial_id_field?(field, attributes)
         return Time.parse(value) if attributes[:type] == "date" && value.is_a?(String)
 
         value
@@ -139,24 +314,19 @@ module BetterAuth
         clauses = Array(where)
         return true if clauses.empty?
 
-        result = evaluate_clause(record, clauses.first)
-        clauses.each do |clause|
-          clause_result = evaluate_clause(record, clause)
-          if fetch_key(clause, :connector).to_s.upcase == "OR"
-            result ||= clause_result
-          else
-            result &&= clause_result
-          end
-        end
-        result
+        and_clauses, or_clauses = grouped_where_clauses(clauses)
+        and_clauses.all? { |clause| evaluate_clause(record, clause) } &&
+          (or_clauses.empty? || or_clauses.any? { |clause| evaluate_clause(record, clause) })
       end
 
       def evaluate_clause(record, clause)
         field = Schema.storage_key(fetch_key(clause, :field))
         value = fetch_key(clause, :value)
         operator = (fetch_key(clause, :operator) || "eq").to_s
+        mode = (fetch_key(clause, :mode) || "sensitive").to_s
         current = record[field]
         comparable = coerce_where_value(record, field, value, operator)
+        current, comparable = insensitive_values(current, comparable) if insensitive_comparison?(mode, current, comparable)
 
         case operator
         when "in"
@@ -187,9 +357,9 @@ module BetterAuth
       def coerce_where_value(record, field, value, operator)
         attributes = schema_for_record_field(record, field)
         return value unless attributes
-        return Array(value).map { |entry| coerce_scalar_where_value(entry, attributes) } if %w[in not_in].include?(operator)
+        return Array(value).map { |entry| coerce_scalar_where_value(entry, field, attributes) } if %w[in not_in].include?(operator)
 
-        coerce_scalar_where_value(value, attributes)
+        coerce_scalar_where_value(value, field, attributes)
       end
 
       def schema_for_record_field(record, field)
@@ -201,8 +371,9 @@ module BetterAuth
         nil
       end
 
-      def coerce_scalar_where_value(value, attributes)
+      def coerce_scalar_where_value(value, field, attributes)
         return value if value.nil?
+        return coerce_number(value) if serial_id_field?(field, attributes)
 
         case attributes[:type]
         when "boolean"
@@ -221,6 +392,32 @@ module BetterAuth
         value
       end
 
+      def serial_id_field?(field, attributes)
+        return false unless options.advanced.dig(:database, :generate_id) == "serial"
+        return true if field.to_s == "id"
+
+        reference = attributes[:references]
+        return false unless reference
+
+        (reference[:field] || reference["field"]).to_s == "id"
+      end
+
+      def insensitive_comparison?(mode, current, comparable)
+        return false unless mode == "insensitive"
+
+        current.is_a?(String) && (comparable.is_a?(String) || comparable.is_a?(Array))
+      end
+
+      def insensitive_values(current, comparable)
+        normalized_current = current.downcase
+        normalized_comparable = if comparable.is_a?(Array)
+          comparable.map { |entry| entry.is_a?(String) ? entry.downcase : entry }
+        else
+          comparable.downcase
+        end
+        [normalized_current, normalized_comparable]
+      end
+
       def coerce_number(value)
         return value unless value.is_a?(String)
         return value.to_i if /\A-?\d+\z/.match?(value)
@@ -245,25 +442,77 @@ module BetterAuth
         value.nil? ? "" : value
       end
 
-      def select_fields(_model, record, select)
+      def select_fields(model, record, select, join: nil)
         fields = Array(select).map { |field| Schema.storage_key(field) }
-        record.slice(*fields)
+        selected = record.slice(*fields)
+        normalized_join(model, join).each_key do |join_model|
+          selected[join_model] = record[join_model] if record.key?(join_model)
+        end
+        selected
       end
 
       def apply_join(model, record, join)
         joined = record.dup
-        join.each_key do |join_model|
-          join_model = join_model.to_s
-          joined[join_model] = case [model, join_model]
-          when ["session", "user"], ["account", "user"]
-            table_for("user").find { |user| user["id"] == record["userId"] }
-          when ["user", "account"]
-            table_for("account").select { |account| account["userId"] == record["id"] }
+        normalized_join(model, join).each do |join_model, config|
+          matches = table_for(join_model).select do |join_record|
+            join_record[config.fetch(:to)] == record[config.fetch(:from)]
+          end.map(&:dup)
+
+          joined[join_model] = if one_to_one_join?(config)
+            matches.first
+          else
+            matches.first(join_limit(config))
           end
         end
         joined
       end
 
+      def one_to_one_join?(config)
+        config[:relation] == "one-to-one" || config[:unique] == true
+      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
+        forward_join = true
+
+        if foreign_keys.empty?
+          foreign_keys = schema_for(model).fetch(:fields).select do |_field, attributes|
+            reference_model_matches?(attributes, join_model)
+          end
+          forward_join = false
+        end
+
+        raise Error, "No foreign key found for model #{join_model} and base model #{model} while performing join operation." if foreign_keys.empty?
+        raise 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)
+        if forward_join
+          unique = attributes[:unique] == true
+          {from: reference.fetch(:field).to_s, to: foreign_key, relation: unique ? "one-to-one" : "one-to-many", unique: unique}
+        else
+          {from: foreign_key, to: reference.fetch(:field).to_s, relation: "one-to-one", unique: true}
+        end
+      end
+
+      def schema_for(model)
+        Schema.auth_tables(options).fetch(model.to_s)
+      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 == schema_for(model).fetch(:model_name)
+      end
+
+      def storage_key(field)
+        Schema.storage_key(field)
+      end
+
       def stringify_keys(data)
         data.each_with_object({}) do |(key, value), result|
           result[Schema.storage_key(key)] = value

data/lib/better_auth/adapters/mssql.rb

@@ -17,16 +17,20 @@ module BetterAuth
       end
 
       def transaction
+        return yield active_transaction_adapter if active_transaction_adapter
         return super unless connection.respond_to?(:transaction)
 
-        connection.transaction { yield self }
+        connection.transaction { with_transaction_context(self) { yield self } }
       end
 
       private
 
-      def execute(sql, params)
+      def execute(sql, params, affected_rows_result: false)
         if connection.respond_to?(:fetch)
-          connection.fetch(sql, *params).all.map { |row| stringify_row(row) }
+          dataset = connection.fetch(sql, *params)
+          return dataset.delete if affected_rows_result
+
+          dataset.all.map { |row| stringify_row(row) }
         else
           super
         end