RubyGems - better_auth-mongo-adapter - Versions diffs - 0.7.0 → 0.8.0 - Mend

better_auth-mongo-adapter 0.7.0 → 0.8.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (6) hide show

checksums.yaml +4 -4
data/CHANGELOG.md +3 -0
data/README.md +15 -1
data/lib/better_auth/mongo_adapter/version.rb +1 -1
data/lib/better_auth/mongo_adapter.rb +4 -674
metadata +8 -62

checksums.yaml CHANGED Viewed

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8422b43a0fc6310519286bca03295aecb91752ae5c4cd5997ff5be64486af7c9
-  data.tar.gz: ed65ca011f7f4a5913ae03830c049b8fcc023200c47ad9da125e55f6569272ba
+  metadata.gz: 86afd33544ccb8e9fff5ccfa4e055cd31007086648c7985f1e9b64f40176f68e
+  data.tar.gz: 953a82389a1bbc913d702396fe0c4a66abcf79f042d4a5fb6bcd36eecaf233b3
 SHA512:
-  metadata.gz: 285006c97e41014ba65eb450e520bd9ac82848a0d796894ba526f1427a605808d51e25d174cd35d4f11884e235b4cc9465017a91c874b6aed5b6e45b41c8550a
-  data.tar.gz: 16029924074e406bb142a50936b4b77a1a90367c5aaf8a390ecfb8723f051a1e2c98c770bea4bab1daa7784c7a9763946c46b5a55c9fc3d5a5620dfc5e830d16
+  metadata.gz: c67b4588a64b8fbb648ee5ec5fe029a67a6cd56c8c7ef35a48aacad33abecdff31f91eef0c2d110295c622cd877cbdb783a6583337c6bad0ce77985c2bdae34b
+  data.tar.gz: 86ab56e50db549d6ad11e28b06282376581651ecbdc540f15c5e2c114fab2a55ae8c21c9a7b11178826b78d9edce7a69875459c8be77a096dafec831405e6998

data/CHANGELOG.md CHANGED Viewed

@@ -2,6 +2,9 @@
 ## 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.

data/README.md CHANGED Viewed

@@ -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

data/lib/better_auth/mongo_adapter/version.rb CHANGED Viewed

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

data/lib/better_auth/mongo_adapter.rb CHANGED Viewed

@@ -1,679 +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
-        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)
-          .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 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)
-        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?
-        conditions = clauses.map do |clause|
-          connector = if fetch_key(clause, :connector).to_s.upcase == "OR"
-            "OR"
-          else
-            "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)
-        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_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_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"
-          {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.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 && effective_limit.positive?
-          lookup = if should_limit
-            {
-              "$lookup" => {
-                "from" => collection_name(join_model),
-                "let" => {"localFieldValue" => "$#{local_field}"},
-                "pipeline" => [
-                  {"$match" => {"$expr" => {"$eq" => ["$#{foreign_field}", "$$localFieldValue"]}}},
-                  {"$limit" => effective_limit}
-                ],
-                "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
+require "better_auth/mongodb"
-      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)
-          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 CHANGED Viewed

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: better_auth-mongo-adapter
 version: !ruby/object:Gem::Version
-  version: 0.7.0
+  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: []