better_auth-mongo-adapter 0.6.2 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c3abe1d68b1d2865e2f74cefbcd53ee67fd1f2384b20a20db6532d7fe3fc4c96
-  data.tar.gz: 6e8b7e4e3ad10076e7cc2ad9f8b9982be4d355e64dcac381c6a7c6624e2ed369
+  metadata.gz: 86afd33544ccb8e9fff5ccfa4e055cd31007086648c7985f1e9b64f40176f68e
+  data.tar.gz: 953a82389a1bbc913d702396fe0c4a66abcf79f042d4a5fb6bcd36eecaf233b3
 SHA512:
-  metadata.gz: 369ce690cbe825954bd2e716d32ec6dac751d18e766a4656e2d904e834e85f4fbab26a0b77dc939d7c6e52648aba18866adcf01cde4e9935a60583ca7ebd6a52
-  data.tar.gz: 32e903a2de49c6b6718c280e7d185dbc4d6d43a22349cd960b3e219a4b6154efd402e6e3a1cc5493460d12dd9062083de005bf9a5ee4a00aabd67ef7535513fe
+  metadata.gz: c67b4588a64b8fbb648ee5ec5fe029a67a6cd56c8c7ef35a48aacad33abecdff31f91eef0c2d110295c622cd877cbdb783a6583337c6bad0ce77985c2bdae34b
+  data.tar.gz: 86ab56e50db549d6ad11e28b06282376581651ecbdc540f15c5e2c114fab2a55ae8c21c9a7b11178826b78d9edce7a69875459c8be77a096dafec831405e6998

data/CHANGELOG.md

@@ -2,6 +2,18 @@
 
 ## Unreleased
 
+- Deprecated this package in favor of `better_auth-mongodb`.
+- Kept `require "better_auth/mongo_adapter"` as a compatibility entrypoint.
+
+## 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

@@ -1,6 +1,20 @@
 # better_auth-mongo-adapter
 
-MongoDB database adapter package for Better Auth Ruby.
+Deprecated compatibility package for Better Auth Ruby MongoDB support.
+
+New applications should use `better_auth-mongodb`:
+
+```ruby
+gem "better_auth-mongodb"
+```
+
+```ruby
+require "better_auth/mongodb"
+```
+
+This package remains available so existing applications that install
+`better_auth-mongo-adapter` and require `better_auth/mongo_adapter` continue to
+load the same adapter.
 
 ## Installation
 
@@ -18,16 +32,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.8.0"
   end
 end

data/lib/better_auth/mongo_adapter.rb

@@ -1,641 +1,9 @@
 # frozen_string_literal: true
 
-require "better_auth"
-require "mongo"
-require "securerandom"
-require "time"
+warn "The better_auth-mongo-adapter gem is deprecated; use better_auth-mongodb and require \"better_auth/mongodb\" instead.", uplevel: 1
 
-module BetterAuth
-  module Adapters
-    class MongoDB < Base
-      class MongoAdapterError < Error
-        attr_reader :code
-
-        def initialize(code, message)
-          @code = code
-          super(message)
-        end
-      end
-
-      attr_reader :database, :client, :use_plural
-
-      def initialize(options = nil, database:, client: nil, transaction: nil, use_plural: false, session: nil)
-        require "mongo" unless database
-
-        super(options || Configuration.new(secret: Configuration::DEFAULT_SECRET, database: :memory))
-        @database = database
-        @client = client
-        @transaction_enabled = transaction.nil? ? !client.nil? : !!transaction
-        @use_plural = !!use_plural
-        @session = session
-      end
-
-      def create(model:, data:, force_allow_id: false)
-        model = model.to_s
-        record = transform_input(model, data, "create", force_allow_id)
-        document = to_document(model, record)
-        collection_for(model).insert_one(document, session_options)
-        from_document(model, document)
-      end
-
-      def find_one(model:, where: [], select: nil, join: nil)
-        find_many(model: model, where: where, select: select, join: join, limit: 1).first
-      end
-
-      def find_many(model:, where: [], sort_by: nil, limit: nil, offset: nil, select: nil, join: nil)
-        model = model.to_s
-        pipeline = [{"$match" => mongo_filter(model, where || [])}]
-        pipeline.concat(join_stages(model, join)) if join
-        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
-
-        collection_for(model)
-          .aggregate(pipeline, session_options)
-          .to_a
-          .map { |document| from_document(model, stringify_document(document), join: join) }
-      end
-
-      def update(model:, where:, update:)
-        model = model.to_s
-        data = transform_input(model, update, "update", true)
-        document = to_document(model, data)
-        document.delete("_id")
-        result = collection_for(model).find_one_and_update(
-          mongo_filter(model, where || []),
-          {"$set" => document},
-          session_options.merge(return_document: :after)
-        )
-        result = unwrap_update_result(result)
-        result ? from_document(model, stringify_document(result)) : nil
-      end
-
-      def update_many(model:, where:, update:)
-        model = model.to_s
-        data = transform_input(model, update, "update", true)
-        document = to_document(model, data)
-        document.delete("_id")
-        result = collection_for(model).update_many(
-          mongo_filter(model, where || []),
-          {"$set" => document},
-          session_options
-        )
-        result.respond_to?(:modified_count) ? result.modified_count : result.to_i
-      end
-
-      def delete(model:, where:)
-        collection_for(model.to_s).delete_one(mongo_filter(model.to_s, where || []), session_options)
-        nil
-      end
-
-      def delete_many(model:, where:)
-        result = collection_for(model.to_s).delete_many(mongo_filter(model.to_s, where || []), session_options)
-        result.respond_to?(:deleted_count) ? result.deleted_count : result.to_i
-      end
-
-      def count(model:, where: nil)
-        pipeline = [
-          {"$match" => mongo_filter(model.to_s, where || [])},
-          {"$count" => "total"}
-        ]
-        row = collection_for(model.to_s).aggregate(pipeline, session_options).to_a.first
-        return 0 unless row
-
-        (row["total"] || row[:total] || 0).to_i
-      end
-
-      def transaction
-        return yield self unless client && @transaction_enabled && client.respond_to?(:start_session)
-
-        session = client.start_session
-        begin
-          session.start_transaction
-          adapter = self.class.new(options, database: database, client: client, transaction: @transaction_enabled, use_plural: use_plural, session: session)
-          result = yield adapter
-          session.commit_transaction
-          result
-        rescue
-          session.abort_transaction
-          raise
-        ensure
-          session.end_session
-        end
-      end
-
-      private
-
-      def transform_input(model, data, action, force_allow_id)
-        fields = fields_for(model)
-        input = stringify_keys(data)
-        output = {}
-
-        fields.each do |field, attributes|
-          next if field == "id" && input.key?(field) && !force_allow_id
-
-          value_provided = input.key?(field)
-          value = input[field]
-          if value_provided && attributes[:input] == false && value && !force_allow_id
-            raise APIError.new("BAD_REQUEST", message: "#{field} is not allowed to be set")
-          end
-
-          if !value_provided && action == "create" && attributes.key?(:default_value)
-            value = resolve_default(attributes[:default_value])
-            value_provided = true
-          elsif !value_provided && action == "update" && attributes[:on_update]
-            value = resolve_default(attributes[:on_update])
-            value_provided = true
-          end
-
-          if !value_provided && action == "create" && attributes[:required]
-            raise APIError.new("BAD_REQUEST", message: "#{field} is required") unless field == "id"
-          end
-          output[field] = coerce_value(value, attributes) if value_provided
-        end
-
-        output["id"] = generated_id if action == "create" && !output.key?("id")
-        output
-      end
-
-      def mongo_filter(model, where)
-        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]}
-          else
-            {"$and" => [filter, condition]}
-          end
-        end
-      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)
-        key = (field == "id") ? "_id" : storage_field(model, field)
-        mode = (fetch_key(clause, :mode) || "sensitive").to_s
-        id_field = id_field?(field, attributes)
-        insensitive = !id_field && mode == "insensitive" && insensitive_value?(value)
-        value = coerce_where_value(value, attributes)
-
-        case operator
-        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) }}}
-        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) }}}
-        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"
-          {key => {"$#{operator}" => store_value(field, value, attributes, strict_id: true)}}
-        when "contains", "starts_with", "ends_with"
-          regex_condition(key, value.to_s, operator.to_sym, insensitive: insensitive)
-        else
-          raise MongoAdapterError.new("UNSUPPORTED_OPERATOR", "Unsupported operator: #{operator}")
-        end
-      end
-
-      def insensitive_value?(value)
-        value.is_a?(String) || (value.is_a?(Array) && value.all? { |entry| entry.is_a?(String) })
-      end
-
-      def insensitive_in_condition(key, values)
-        return {"$expr" => {"$eq" => [1, 0]}} if values.empty?
-
-        {"$or" => values.map { |value| regex_condition(key, value, :eq, insensitive: true) }}
-      end
-
-      def insensitive_not_in_condition(key, values)
-        return {} if values.empty?
-
-        {"$nor" => values.map { |value| regex_condition(key, value, :eq, insensitive: true) }}
-      end
-
-      def regex_condition(key, value, operator, insensitive:)
-        {key => regex_for(value, operator, insensitive: insensitive)}
-      end
-
-      def regex_for(value, operator, insensitive:)
-        escaped = Regexp.escape(value.to_s[0, 256])
-        pattern = case operator.to_s
-        when "eq" then "\\A#{escaped}\\z"
-        when "starts_with" then "\\A#{escaped}"
-        when "ends_with" then "#{escaped}\\z"
-        else escaped
-        end
-        Regexp.new(pattern, insensitive ? Regexp::IGNORECASE : nil)
-      end
-
-      def join_stages(model, join)
-        normalized_join(model, join).flat_map do |join_model, config|
-          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]
-          unique = relation == "one-to-one" || config[:unique]
-          should_limit = !unique && limit && limit.to_i.positive?
-
-          lookup = if should_limit
-            {
-              "$lookup" => {
-                "from" => collection_name(join_model),
-                "let" => {"localFieldValue" => "$#{local_field}"},
-                "pipeline" => [
-                  {"$match" => {"$expr" => {"$eq" => ["$#{foreign_field}", "$$localFieldValue"]}}},
-                  {"$limit" => limit.to_i}
-                ],
-                "as" => join_model
-              }
-            }
-          else
-            {
-              "$lookup" => {
-                "from" => collection_name(join_model),
-                "localField" => local_field,
-                "foreignField" => foreign_field,
-                "as" => join_model
-              }
-            }
-          end
-
-          unique ? [lookup, {"$unwind" => {"path" => "$#{join_model}", "preserveNullAndEmptyArrays" => true}}] : [lookup]
-        end
-      end
-
-      def normalized_join(model, join)
-        join.each_with_object({}) do |(join_model, config), result|
-          join_model = join_model.to_s
-          result[join_model] = normalize_join_config(model, join_model, config)
-        end
-      end
-
-      def normalize_join_config(model, join_model, config)
-        if config.is_a?(Hash) && (config.key?(:on) || config.key?("on"))
-          on = config[:on] || config["on"]
-          relation = config[:relation] || config["relation"]
-          limit = config[:limit] || config["limit"]
-          from = fetch_key(on, :from)
-          to = fetch_key(on, :to)
-          return {from: Schema.storage_key(from), to: Schema.storage_key(to), relation: relation, limit: limit, unique: unique_join_field?(join_model, to)}
-        end
-
-        inferred = inferred_join_config(model, join_model)
-        if config.is_a?(Hash)
-          limit = config[:limit] || config["limit"]
-          relation = config[:relation] || config["relation"]
-          inferred = inferred.merge(limit: limit) if limit
-          inferred = inferred.merge(relation: relation) if relation
-        end
-        inferred
-      end
-
-      def inferred_join_config(model, join_model)
-        base_model = default_model_name(model)
-        target_model = default_model_name(join_model)
-        foreign_keys = fields_for(target_model).select do |_field, attributes|
-          reference_model_matches?(attributes, base_model)
-        end
-        forward_join = true
-
-        if foreign_keys.empty?
-          foreign_keys = fields_for(base_model).select do |_field, attributes|
-            reference_model_matches?(attributes, target_model)
-          end
-          forward_join = false
-        end
-
-        if foreign_keys.empty?
-          raise Error, "No foreign key found for model #{join_model} and base model #{model} while performing join operation."
-        end
-        if foreign_keys.length > 1
-          raise Error, "Multiple foreign keys found for model #{join_model} and base model #{model} while performing join operation. Only one foreign key is supported."
-        end
-
-        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 reference_model_matches?(attributes, model)
-        reference = attributes[:references]
-        return false unless reference
-
-        default_model_name(reference[:model] || reference["model"]) == model
-      end
-
-      def unique_join_field?(model, field)
-        field = resolve_field(model, field)
-        field == "id" || fields_for(model).dig(field, :unique) == true
-      end
-
-      def storage_field_for_join(model, field)
-        field = resolve_field(model, field)
-        (field == "id") ? "_id" : storage_field(model, field)
-      end
-
-      def projection_for(model, select, join)
-        selected_fields = Array(select).map { |field| storage_field_for_join(model, field) }
-        Array(select).each_with_object({}) do |field, projection|
-          projection[storage_field_for_join(model, field)] = 1
-        end.tap do |projection|
-          projection["_id"] = 0 unless selected_fields.include?("_id")
-          normalized_join(model, join).each_key { |join_model| projection[join_model] = 1 } if join
-        end
-      end
-
-      def sort_field(model, sort_by)
-        field = resolve_field(model, fetch_key(sort_by, :field))
-        storage_field_for_join(model, field)
-      end
-
-      def sort_direction(sort_by)
-        (fetch_key(sort_by, :direction).to_s == "desc") ? -1 : 1
-      end
-
-      def collection_for(model)
-        database.collection(collection_name(model))
-      end
-
-      def collection_name(model)
-        model = default_model_name(model)
-        configured = configured_model_name(model)
-        return "#{configured}s" if configured && use_plural
-        return configured if configured
-        return schema_for(model).fetch(:model_name) if use_plural
-
-        model.to_s
-      end
-
-      def to_document(model, record)
-        fields_for(model).each_with_object({}) do |(field, attributes), document|
-          next unless record.key?(field)
+require "better_auth/mongodb"
 
-          key = (field == "id") ? "_id" : storage_field(model, field)
-          document[key] = store_value(field, record[field], attributes)
-        end
-      end
-
-      def from_document(model, document, join: nil)
-        fields = fields_for(model)
-        record = fields.each_with_object({}) do |(field, attributes), output|
-          key = (field == "id") ? "_id" : storage_field(model, field)
-          output[field] = output_value(field, fetch_document(document, key), attributes) if document_key?(document, key)
-        end
-
-        if join
-          normalized_join(model, join).each do |join_model, config|
-            next unless document_key?(document, join_model)
-
-            joined_value = fetch_document(document, join_model)
-            record[join_model] = if joined_value.is_a?(Array)
-              joined_value.map { |entry| from_document(join_model, stringify_document(entry)) }
-            elsif joined_value
-              from_document(join_model, stringify_document(joined_value))
-            elsif config[:relation] == "one-to-one"
-              nil
-            else
-              []
-            end
-          end
-        end
-
-        record
-      end
-
-      def stringify_document(document)
-        document.each_with_object({}) { |(key, value), result| result[key.to_s] = value }
-      end
-
-      def unwrap_update_result(result)
-        return result unless result.is_a?(Hash)
-        return result if document_key?(result, "_id")
-
-        if result.key?("value") && (result.key?("ok") || result.key?("lastErrorObject"))
-          return result["value"]
-        end
-        if result.key?(:value) && (result.key?(:ok) || result.key?(:last_error_object))
-          return result[:value]
-        end
-
-        result
-      end
-
-      def store_value(field, value, attributes, strict_id: false)
-        return nil if value.nil?
-        return Array(value).map { |entry| store_value(field, entry, attributes, strict_id: strict_id) } if value.is_a?(Array)
-
-        if id_field?(field, attributes)
-          return value if custom_id_generator?
-          return bson_id(value, strict: strict_id)
-        end
-
-        input_value(value, attributes)
-      end
-
-      def output_value(field, value, attributes)
-        return nil if value.nil?
-        if id_field?(field, attributes)
-          return value.to_uuid if bson_uuid?(value)
-          return value.to_s if value.is_a?(BSON::ObjectId)
-          return value.map { |entry| output_value(field, entry, attributes) } if value.is_a?(Array)
-          return value
-        end
-
-        output_scalar_value(value, attributes)
-      end
-
-      def id_field?(field, attributes)
-        field.to_s == "id" || attributes.dig(:references, :field) == "id"
-      end
-
-      def bson_id(value, strict:)
-        if use_uuid_ids?
-          return value if bson_uuid?(value)
-          return BSON::Binary.from_uuid(value.to_s) if value.is_a?(String)
-          raise MongoAdapterError.new("INVALID_ID", "Invalid id value") if strict
-
-          return value
-        end
-
-        return value if value.is_a?(BSON::ObjectId)
-        return BSON::ObjectId.from_string(value.to_s) if value.is_a?(String)
-        raise MongoAdapterError.new("INVALID_ID", "Invalid id value") if strict
-
-        value
-      rescue BSON::Error::InvalidObjectId, ArgumentError
-        value
-      end
-
-      def bson_uuid?(value)
-        defined?(BSON::Binary) && value.is_a?(BSON::Binary) && value.respond_to?(:to_uuid) && value.type == :uuid
-      end
-
-      def generated_id
-        generator = options.advanced.dig(:database, :generate_id)
-        return generator.call if generator.respond_to?(:call)
-        return SecureRandom.uuid if use_uuid_ids?
-        return BSON::ObjectId.new.to_s if defined?(BSON::ObjectId)
-
-        SecureRandom.hex(12)
-      end
-
-      def use_uuid_ids?
-        options.advanced.dig(:database, :generate_id) == "uuid"
-      end
-
-      def custom_id_generator?
-        options.advanced.dig(:database, :generate_id).respond_to?(:call)
-      end
-
-      def resolve_default(default)
-        default.respond_to?(:call) ? default.call : default
-      end
-
-      def coerce_value(value, attributes)
-        return value if value.nil?
-        return Time.parse(value) if attributes[:type] == "date" && value.is_a?(String)
-
-        value
-      end
-
-      def input_value(value, attributes)
-        value = coerce_value(value, attributes)
-        return JSON.generate(value) if attributes[:type] == "json" && (value.is_a?(Hash) || value.is_a?(Array))
-
-        value
-      end
-
-      def output_scalar_value(value, attributes)
-        return JSON.parse(value) if attributes[:type] == "json" && value.is_a?(String)
-
-        coerce_value(value, attributes)
-      rescue JSON::ParserError
-        value
-      end
-
-      def coerce_where_value(value, attributes)
-        return value.map { |entry| coerce_where_value(entry, attributes) } if value.is_a?(Array)
-        return value == "true" if attributes[:type] == "boolean" && value.is_a?(String)
-        if attributes[:type] == "number" && value.is_a?(String) && !value.strip.empty?
-          parsed = Float(value)
-          return parsed.to_i if parsed.to_i == parsed
-
-          return parsed
-        end
-        return JSON.generate(value) if attributes[:type] == "json" && (value.is_a?(Hash) || value.is_a?(Array))
-
-        value
-      rescue ArgumentError
-        value
-      end
-
-      def session_options
-        @session ? {session: @session} : {}
-      end
-
-      def document_key?(document, key)
-        document.key?(key) || document.key?(key.to_sym)
-      end
-
-      def fetch_document(document, key)
-        return document[key] if document.key?(key)
-
-        document[key.to_sym]
-      end
-
-      def stringify_keys(data)
-        data.each_with_object({}) do |(key, value), result|
-          result[Schema.storage_key(key)] = value
-        end
-      end
-
-      def fetch_key(hash, key)
-        [key, key.to_s, Schema.storage_key(key), Schema.storage_key(key).to_sym].each do |candidate|
-          return hash[candidate] if hash.key?(candidate)
-        end
-        nil
-      end
-
-      def schema_for(model)
-        Schema.auth_tables(options).fetch(default_model_name(model))
-      end
-
-      def fields_for(model)
-        schema_for(model).fetch(:fields).merge("id" => {type: "string", required: true})
-      end
-
-      def default_model_name(model)
-        model = model.to_s
-        tables = Schema.auth_tables(options)
-        return model if tables.key?(model)
-
-        pluraless = model.end_with?("s") ? model[0...-1] : nil
-        return pluraless if pluraless && tables.key?(pluraless)
-
-        matched = tables.find { |_key, table| table[:model_name].to_s == model }
-        return matched.first if matched
-
-        raise Error, "Model \"#{model}\" not found in schema"
-      end
-
-      def configured_model_name(model)
-        configured = configured_model_option(model, :model_name)
-        return configured.to_s if configured
-
-        return nil if core_model?(model)
-
-        table_model_name = schema_for(model).fetch(:model_name).to_s
-        (table_model_name == physical_name(model)) ? nil : table_model_name
-      end
-
-      def configured_model_option(model, key)
-        data = options.respond_to?(model.to_sym) ? options.public_send(model.to_sym) : nil
-        data[key] || data[key.to_s] if data.respond_to?(:[])
-      end
-
-      def core_model?(model)
-        ["user", "session", "account", "verification", "rateLimit"].include?(model.to_s)
-      end
-
-      def resolve_field(model, field)
-        field = Schema.storage_key(field)
-        return "id" if field == "id" || field == "_id"
-
-        fields = fields_for(model)
-        return field if fields.key?(field)
-
-        matched = fields.find { |_key, attributes| attributes[:field_name].to_s == field.to_s }
-        return matched.first if matched
-
-        raise Error, "Field #{field} not found in model #{model}"
-      end
-
-      def storage_field(model, field)
-        fields_for(model).fetch(field.to_s).fetch(:field_name, physical_name(field))
-      end
-
-      def physical_name(value)
-        value.to_s
-          .gsub(/([a-z\d])([A-Z])/, "\\1_\\2")
-          .tr("-", "_")
-          .downcase
-      end
-    end
-  end
+module BetterAuth
+  MongoAdapter = MongoDB unless const_defined?(:MongoAdapter, false)
 end

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.8.0
 platform: ruby
 authors:
 - Sebastian Sala
@@ -10,73 +10,19 @@ cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: better_auth
+  name: better_auth-mongodb
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '0.1'
-- !ruby/object:Gem::Dependency
-  name: bigdecimal
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.1'
-    - - "<"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '5.0'
+        version: 0.8.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '3.1'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '5.0'
-- !ruby/object:Gem::Dependency
-  name: logger
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.6'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '1.6'
-    - - "<"
-      - !ruby/object:Gem::Version
-        version: '2.0'
-- !ruby/object:Gem::Dependency
-  name: mongo
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: '2.21'
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
+    - - '='
       - !ruby/object:Gem::Version
-        version: '2.21'
+        version: 0.8.0
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
@@ -147,8 +93,8 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '0.22'
-description: Adds a MongoDB database adapter for Better Auth Ruby without requiring
-  MongoDB dependencies in the core gem.
+description: Deprecated compatibility package for Better Auth Ruby MongoDB support.
+  Use the better_auth-mongodb gem and require "better_auth/mongodb" instead.
 email:
 - sebastian.sala.tech@gmail.com
 executables: []