better_auth-mongo-adapter 0.6.2 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3abe1d68b1d2865e2f74cefbcd53ee67fd1f2384b20a20db6532d7fe3fc4c96
-  data.tar.gz: 6e8b7e4e3ad10076e7cc2ad9f8b9982be4d355e64dcac381c6a7c6624e2ed369
+  metadata.gz: 8422b43a0fc6310519286bca03295aecb91752ae5c4cd5997ff5be64486af7c9
+  data.tar.gz: ed65ca011f7f4a5913ae03830c049b8fcc023200c47ad9da125e55f6569272ba
 SHA512:
-  metadata.gz: 369ce690cbe825954bd2e716d32ec6dac751d18e766a4656e2d904e834e85f4fbab26a0b77dc939d7c6e52648aba18866adcf01cde4e9935a60583ca7ebd6a52
-  data.tar.gz: 32e903a2de49c6b6718c280e7d185dbc4d6d43a22349cd960b3e219a4b6154efd402e6e3a1cc5493460d12dd9062083de005bf9a5ee4a00aabd67ef7535513fe
+  metadata.gz: 285006c97e41014ba65eb450e520bd9ac82848a0d796894ba526f1427a605808d51e25d174cd35d4f11884e235b4cc9465017a91c874b6aed5b6e45b41c8550a
+  data.tar.gz: 16029924074e406bb142a50936b4b77a1a90367c5aaf8a390ecfb8723f051a1e2c98c770bea4bab1daa7784c7a9763946c46b5a55c9fc3d5a5620dfc5e830d16

data/CHANGELOG.md

@@ -2,6 +2,15 @@
 
 ## Unreleased
 
+## 0.7.0 - 2026-05-05
+
+- Added explicit `ensure_indexes!` setup helper for Mongo indexes derived from Better Auth schema metadata.
+- Updated MongoDB setup docs to use the lambda adapter form, clearer standalone/replica-set transaction guidance, and production index guidance.
+- Consolidated Mongo fake test support and strengthened transaction rollback coverage for staged mutations.
+- Apply `advanced[:database][:default_find_many_limit]` to uncapped `find_many` calls and one-to-many Mongo `$lookup` joins, defaulting to 100 when omitted.
+- Match upstream Mongo where-clause semantics for mixed connectors by bucketing multi-clause filters into `$and` and `$or` arrays instead of left-fold nesting.
+- Allow scalar values for `in` and `not_in` filters as an intentional Ruby adapter-family adaptation.
+
 ## 0.1.1 - 2026-04-30
 
 - Fixed inferred limited joins so explicit relation and limit configuration is preserved.

data/README.md

@@ -18,16 +18,85 @@ mongo_client = Mongo::Client.new(ENV.fetch("BETTER_AUTH_MONGODB_URL"))
 
 auth = BetterAuth.auth(
   secret: ENV.fetch("BETTER_AUTH_SECRET"),
-  database: BetterAuth::Adapters::MongoDB.new(
-    database: mongo_client.database,
-    client: mongo_client,
-    transaction: false
-  )
+  database: ->(options) {
+    BetterAuth::Adapters::MongoDB.new(
+      options,
+      database: mongo_client.database,
+      client: mongo_client,
+      transaction: false
+    )
+  }
 )
 ```
 
+The lambda form lets Better Auth pass the final configuration into the adapter,
+including plugins, custom schemas, and advanced database options.
+
 ## Notes
 
 This package depends on the official `mongo` gem. Keeping MongoDB support outside `better_auth` avoids installing MongoDB client dependencies for applications that only use SQL, Rails, Hanami, or in-memory storage.
 
 The adapter stores Better Auth models in singular MongoDB collections by default, maps logical `id` values to Mongo `_id`, converts ObjectId-compatible ids through the Mongo driver, and supports the shared Better Auth database adapter contract.
+
+Transactions are deployment-dependent. MongoDB multi-document transactions may
+be unavailable on standalone servers and usually require a replica set plus
+compatible driver/session settings. The setup example uses `transaction: false`;
+enable transactions only when the MongoDB deployment supports them.
+
+When using a replica set, remove `transaction: false` or pass
+`transaction: true`. When using standalone local MongoDB, keep
+`transaction: false`.
+
+## Indexes
+
+MongoDB does not run SQL-style migrations. The adapter can create recommended
+indexes from Better Auth schema metadata, but this is an explicit setup step:
+
+```ruby
+adapter = BetterAuth::Adapters::MongoDB.new(
+  options,
+  database: mongo_client.database,
+  client: mongo_client,
+  transaction: false
+)
+
+adapter.ensure_indexes!
+```
+
+`ensure_indexes!` creates indexes for schema fields marked `unique: true` or
+`index: true`, including plugin schemas and custom model or field names. It
+skips Mongo `_id` because MongoDB creates that index automatically. The method
+returns a summary of requested indexes so deployment scripts can log what was
+applied.
+
+## Limits
+
+By default, `find_many` calls without an explicit `limit:` are capped at 100 records. Configure the default with Better Auth's advanced database option:
+
+```ruby
+auth = BetterAuth.auth(
+  secret: ENV.fetch("BETTER_AUTH_SECRET"),
+  advanced: {
+    database: {
+      default_find_many_limit: 250
+    }
+  },
+  database: ->(options) {
+    BetterAuth::Adapters::MongoDB.new(
+      options,
+      database: mongo_client.database,
+      client: mongo_client,
+      transaction: false
+    )
+  }
+)
+```
+
+The same default applies to one-to-many join lookups when the join config does not set `limit:`. Passing an explicit `limit:` to `find_many` or to the join config overrides the default.
+
+One-to-one joins ignore one-to-many limits. They are returned as a single object or `nil`.
+
+Ruby's adapters accept scalar values for `in` and `not_in` filters and coerce
+them to a one-element list. This is an intentional Ruby adapter-family behavior;
+upstream's TypeScript adapter factory is stricter before the Mongo adapter sees
+the query.

data/lib/better_auth/mongo_adapter/version.rb

@@ -2,6 +2,6 @@
 
 module BetterAuth
   module MongoAdapter
-    VERSION = "0.6.2"
+    VERSION = "0.7.0"
   end
 end

data/lib/better_auth/mongo_adapter.rb

@@ -49,7 +49,8 @@ module BetterAuth
         pipeline << {"$project" => projection_for(model, select, join)} if select && !select.empty?
         pipeline << {"$sort" => {sort_field(model, sort_by) => sort_direction(sort_by)}} if sort_by
         pipeline << {"$skip" => offset.to_i} if offset
-        pipeline << {"$limit" => limit.to_i} if limit
+        effective_limit = limit.nil? ? default_find_many_limit : limit.to_i
+        pipeline << {"$limit" => effective_limit} if effective_limit.positive?
 
         collection_for(model)
           .aggregate(pipeline, session_options)
@@ -105,6 +106,26 @@ module BetterAuth
         (row["total"] || row[:total] || 0).to_i
       end
 
+      def ensure_indexes!
+        Schema.auth_tables(options).flat_map do |model, table|
+          table.fetch(:fields).filter_map do |field, attributes|
+            next if field == "id"
+            next unless attributes[:unique] || attributes[:index]
+
+            collection = collection_for(model)
+            key = storage_field(model, field)
+            index_options = attributes[:unique] ? {unique: true} : {}
+            collection.indexes.create_one({key => 1}, index_options)
+            {
+              collection: collection_name(model),
+              field: field,
+              keys: {key => 1},
+              unique: attributes[:unique] == true
+            }
+          end
+        end
+      end
+
       def transaction
         return yield self unless client && @transaction_enabled && client.respond_to?(:start_session)
 
@@ -161,24 +182,40 @@ module BetterAuth
         clauses = Array(where)
         return {} if clauses.empty?
 
-        clauses.each_with_index.reduce(nil) do |filter, (clause, index)|
-          condition = condition_for(model, clause)
-          next condition if index.zero?
-
-          if fetch_key(clause, :connector).to_s.upcase == "OR"
-            {"$or" => [filter, condition]}
+        conditions = clauses.map do |clause|
+          connector = if fetch_key(clause, :connector).to_s.upcase == "OR"
+            "OR"
           else
-            {"$and" => [filter, condition]}
+            "AND"
           end
+          {condition: condition_for(model, clause), connector: connector}
         end
+        return conditions.first.fetch(:condition) if conditions.one?
+
+        result = {}
+        and_conditions = conditions.select { |entry| entry.fetch(:connector) == "AND" }.map { |entry| entry.fetch(:condition) }
+        or_conditions = conditions.select { |entry| entry.fetch(:connector) == "OR" }.map { |entry| entry.fetch(:condition) }
+        result["$and"] = and_conditions if and_conditions.any?
+        result["$or"] = or_conditions if or_conditions.any?
+        result
+      end
+
+      def default_find_many_limit
+        value = options.advanced.dig(:database, :default_find_many_limit)
+        return 100 if value.nil?
+
+        Integer(value)
+      rescue ArgumentError, TypeError
+        100
+      end
+
+      def array_operator_values(value)
+        value.is_a?(Array) ? value : [value]
       end
 
       def condition_for(model, clause)
         operator = (fetch_key(clause, :operator) || "eq").to_s.downcase
         value = fetch_key(clause, :value)
-        if operator == "in" && !value.is_a?(Array)
-          raise MongoAdapterError.new("UNSUPPORTED_OPERATOR", "Value must be an array")
-        end
 
         field = resolve_field(model, fetch_key(clause, :field))
         attributes = fields_for(model).fetch(field)
@@ -192,9 +229,9 @@ module BetterAuth
         when "eq"
           (insensitive && value.is_a?(String)) ? regex_condition(key, value, :eq, insensitive: true) : {key => store_value(field, value, attributes, strict_id: true)}
         when "in"
-          (insensitive && value.is_a?(Array)) ? insensitive_in_condition(key, value) : {key => {"$in" => Array(value).map { |entry| store_value(field, entry, attributes, strict_id: true) }}}
+          (insensitive && value.is_a?(Array)) ? insensitive_in_condition(key, value) : {key => {"$in" => array_operator_values(value).map { |entry| store_value(field, entry, attributes, strict_id: true) }}}
         when "not_in"
-          (insensitive && value.is_a?(Array)) ? insensitive_not_in_condition(key, value) : {key => {"$nin" => Array(value).map { |entry| store_value(field, entry, attributes, strict_id: true) }}}
+          (insensitive && value.is_a?(Array)) ? insensitive_not_in_condition(key, value) : {key => {"$nin" => array_operator_values(value).map { |entry| store_value(field, entry, attributes, strict_id: true) }}}
         when "ne"
           (insensitive && value.is_a?(String)) ? {key => {"$not" => regex_for(value, :eq, insensitive: true)}} : {key => {"$ne" => store_value(field, value, attributes, strict_id: true)}}
         when "gt", "gte", "lt", "lte"
@@ -242,9 +279,10 @@ module BetterAuth
           local_field = storage_field_for_join(model, config.fetch(:from))
           foreign_field = storage_field_for_join(join_model, config.fetch(:to))
           relation = config[:relation]
-          limit = config[:limit]
+          limit = config.key?(:limit) ? config[:limit] : nil
+          effective_limit = limit.nil? ? default_find_many_limit : limit.to_i
           unique = relation == "one-to-one" || config[:unique]
-          should_limit = !unique && limit && limit.to_i.positive?
+          should_limit = !unique && effective_limit.positive?
 
           lookup = if should_limit
             {
@@ -253,7 +291,7 @@ module BetterAuth
                 "let" => {"localFieldValue" => "$#{local_field}"},
                 "pipeline" => [
                   {"$match" => {"$expr" => {"$eq" => ["$#{foreign_field}", "$$localFieldValue"]}}},
-                  {"$limit" => limit.to_i}
+                  {"$limit" => effective_limit}
                 ],
                 "as" => join_model
               }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_auth-mongo-adapter
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.7.0
 platform: ruby
 authors:
 - Sebastian Sala