mongoid-ultra 9.0.0.0.alpha1

data/lib/mongoid/clients/options.rb

@@ -0,0 +1,119 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+    module Options
+      extend ActiveSupport::Concern
+
+      # Change the persistence context for this object during the block.
+      #
+      # @example Save the current document to a different collection.
+      #   model.with(collection: "bands") do |m|
+      #     m.save
+      #   end
+      #
+      # @param [ Hash | Mongoid::PersistenceContext ] options_or_context
+      #   The storage options or a persistence context.
+      #
+      # @option options [ String | Symbol ] :collection The collection name.
+      # @option options [ String | Symbol ] :database The database name.
+      # @option options [ String | Symbol ] :client The client name.
+      def with(options_or_context, &block)
+        original_context = PersistenceContext.get(self)
+        original_cluster = persistence_context.cluster
+        set_persistence_context(options_or_context)
+        yield self
+      ensure
+        clear_persistence_context(original_cluster, original_context)
+      end
+
+      def collection(parent = nil)
+        persistence_context.collection(parent)
+      end
+
+      def collection_name
+        persistence_context.collection_name
+      end
+
+      def mongo_client
+        persistence_context.client
+      end
+
+      def persistence_context
+        if embedded? && !_root?
+          _root.persistence_context
+        else
+          PersistenceContext.get(self) ||
+              PersistenceContext.get(self.class) ||
+              PersistenceContext.new(self.class)
+        end
+      end
+
+      def persistence_context?
+        if embedded? && !_root?
+          _root.persistence_context?
+        else
+          !!(PersistenceContext.get(self) || PersistenceContext.get(self.class))
+        end
+      end
+
+      private
+
+      def set_persistence_context(options_or_context)
+        PersistenceContext.set(self, options_or_context)
+      end
+
+      def clear_persistence_context(original_cluster = nil, context = nil)
+        PersistenceContext.clear(self, original_cluster, context)
+      end
+
+      module ClassMethods
+
+        def client_name
+          persistence_context.client_name
+        end
+
+        def collection_name
+          persistence_context.collection_name
+        end
+
+        def database_name
+          persistence_context.database_name
+        end
+
+        def collection
+          persistence_context.collection
+        end
+
+        def mongo_client
+          persistence_context.client
+        end
+
+        # Change the persistence context for this class during the block.
+        #
+        # @example Save the current document to a different collection.
+        #   Model.with(collection: "bands") do |m|
+        #     m.create
+        #   end
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String | Symbol ] :collection The collection name.
+        # @option options [ String | Symbol ] :database The database name.
+        # @option options [ String | Symbol ] :client The client name.
+        def with(options, &block)
+          original_context = PersistenceContext.get(self)
+          original_cluster = persistence_context.cluster
+          PersistenceContext.set(self, options)
+          yield self
+        ensure
+          PersistenceContext.clear(self, original_cluster, original_context)
+        end
+
+        def persistence_context
+          PersistenceContext.get(self) || PersistenceContext.new(self)
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/sessions.rb

@@ -0,0 +1,146 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+
+    # Encapsulates behavior for using sessions and transactions.
+    module Sessions
+      def self.included(base)
+        base.include(ClassMethods)
+      end
+
+      module ClassMethods
+
+        # Execute a block within the context of a session.
+        #
+        # @example Execute some operations in the context of a session.
+        #   Band.with_session(causal_consistency: true) do
+        #     band = Band.create
+        #     band.records << Record.new
+        #     band.save
+        #     band.reload.records
+        #   end
+        #
+        # @param [ Hash ] options The session options. Please see the driver
+        #   documentation for the available session options.
+        #
+        # @raise [ Errors::InvalidSessionUse ] If an operation is attempted on a model using another
+        #   client from which the session was started or if sessions are nested.
+        #
+        # @return [ Object ] The result of calling the block.
+        #
+        # @yieldparam [ Mongo::Session ] The session being used for the block.
+        def with_session(options = {})
+          if Threaded.get_session(client: persistence_context.client)
+            raise Mongoid::Errors::InvalidSessionNesting.new
+          end
+          session = persistence_context.client.start_session(options)
+          Threaded.set_session(session, client: persistence_context.client)
+          yield(session)
+        rescue Mongo::Error::InvalidSession => ex
+          if Mongo::Error::SessionsNotSupported === ex
+            raise Mongoid::Errors::SessionsNotSupported.new
+          else
+            raise ex
+          end
+        rescue Mongo::Error::OperationFailure => ex
+          if (ex.code == 40415 && ex.server_message =~ /startTransaction/) ||
+             (ex.code == 20 && ex.server_message =~ /Transaction/)
+            raise Mongoid::Errors::TransactionsNotSupported.new
+          else
+            raise ex
+          end
+        ensure
+          Threaded.clear_session(client: persistence_context.client)
+        end
+
+        # Executes a block within the context of a transaction.
+        #
+        # If the block does not raise an error, the transaction is committed.
+        # If an error is raised, the transaction is aborted. The error is passed on
+        # except for the `Mongoid::Errors::Rollback`. This error is not passed on,
+        # so you can raise is if you want to deliberately rollback the transaction.
+        #
+        # @param [ Hash ] options The transaction options. Please see the driver
+        #   documentation for the available session options.
+        # @param [ Hash ] session_options The session options. A MongoDB
+        #   transaction must be started inside a session, therefore a session will
+        #   be started. Please see the driver documentation for the available session options.
+        #
+        # @raise [ Mongoid::Errors::InvalidTransactionNesting ] If the transaction is
+        #   opened on a client that already has an open transaction.
+        # @raise [ Mongoid::Errors::TransactionsNotSupported ] If MongoDB deployment
+        #   the client is connected to does not support transactions.
+        # @raise [ Mongoid::Errors::TransactionError ] If there is an error raised
+        #   by MongoDB deployment or MongoDB driver.
+        #
+        # @yield Provided block will be executed inside a transaction.
+        def transaction(options = {}, session_options: {})
+          with_session(session_options) do |session|
+            begin
+              session.start_transaction(options)
+              yield
+              commit_transaction(session)
+            rescue Mongoid::Errors::Rollback
+              abort_transaction(session)
+            rescue Mongoid::Errors::InvalidSessionNesting
+              # Session should be ended here.
+              raise Mongoid::Errors::InvalidTransactionNesting.new
+            rescue Mongo::Error::InvalidSession, Mongo::Error::InvalidTransactionOperation => e
+              abort_transaction(session)
+              raise Mongoid::Errors::TransactionError(e)
+            rescue StandardError => e
+              abort_transaction(session)
+              raise e
+            end
+          end
+        end
+
+        private
+
+        # @return [ Mongo::Session ] Session for the current client.
+        def _session
+          Threaded.get_session(client: persistence_context.client)
+        end
+
+        # This method should be used to detect whether a persistence operation
+        # is executed inside transaction or not.
+        #
+        # Currently this method is used to detect when +after_commit+ callbacks
+        # should be triggered. If we introduce implicit transactions and
+        # therefore do not need to handle two different ways of triggering callbacks,
+        # we may want to remove this method.
+        #
+        # @return [ true | false ] Whether there is a session for the current
+        #   client, and there is a transaction in progress for this session.
+        def in_transaction?
+          _session&.in_transaction? || false
+        end
+
+        # Commits the active transaction on the session, and calls
+        # after_commit callbacks on modified documents.
+        #
+        # @param [ Mongo::Session ] session Session on which
+        #   a transaction is started.
+        def commit_transaction(session)
+          session.commit_transaction
+          Threaded.clear_modified_documents(session).each do |doc|
+            doc.run_after_callbacks(:commit)
+          end
+        end
+
+        # Aborts the active transaction on the session, and calls
+        # after_rollback callbacks on modified documents.
+        #
+        # @param [ Mongo::Session ] session Session on which
+        #   a transaction is started.
+        def abort_transaction(session)
+          session.abort_transaction
+          Threaded.clear_modified_documents(session).each do |doc|
+            doc.run_after_callbacks(:rollback)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/storage_options.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+    module StorageOptions
+      extend ActiveSupport::Concern
+
+      included do
+        class_attribute :storage_options, instance_writer: false, default: storage_options_defaults
+      end
+
+      module ClassMethods
+
+        # Give this model specific custom default storage options.
+        #
+        # @example Store this model by default in "artists"
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in collection: "artists"
+        #   end
+        #
+        # @example Store this model by default in the sharded db.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in database: "echo_shard"
+        #   end
+        #
+        # @example Store this model by default in a different client.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in client: "analytics"
+        #   end
+        #
+        # @example Store this model with a combination of options.
+        #   class Band
+        #     include Mongoid::Document
+        #     store_in collection: "artists", database: "music"
+        #   end
+        #
+        # @param [ Hash ] options The storage options.
+        #
+        # @option options [ String | Symbol ] :collection The collection name.
+        # @option options [ String | Symbol ] :database The database name.
+        # @option options [ String | Symbol ] :client The client name.
+        #
+        # @return [ Class ] The model class.
+        def store_in(options)
+          Validators::Storage.validate(self, options)
+          self.storage_options = self.storage_options.merge(options)
+        end
+
+        # Reset the store_in options
+        #
+        # @example Reset the store_in options
+        #   Model.reset_storage_options!
+        def reset_storage_options!
+          self.storage_options = storage_options_defaults.dup
+          PersistenceContext.clear(self)
+        end
+
+        # Get the default storage options.
+        #
+        # @example Get the default storage options.
+        #   Model.storage_options_defaults
+        #
+        # @return [ Hash ] Default storage options.
+        def storage_options_defaults
+          {
+            collection: name.collectionize.to_sym,
+            client: :default
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/validators/storage.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Mongoid
+  module Clients
+    module Validators
+
+      # Validates the options passed to :store_in.
+      module Storage
+        extend self
+
+        # The valid options for storage.
+        VALID_OPTIONS = [ :collection, :collection_options, :database, :client ].freeze
+
+        # Validate the options provided to :store_in.
+        #
+        # @example Validate the options.
+        #   Storage.validate(:collection_name)
+        #
+        # @param [ Class ] klass The model class.
+        # @param [ Hash | String | Symbol ] options The provided options.
+        def validate(klass, options)
+          valid_keys?(options) or raise Errors::InvalidStorageOptions.new(klass, options)
+        end
+
+        private
+
+        # Determine if all keys in the options hash are valid.
+        #
+        # @api private
+        #
+        # @example Are all keys valid?
+        #   validator.valid_keys?({ collection: "name" })
+        #
+        # @param [ Hash ] options The options hash.
+        #
+        # @return [ true | false ] If all keys are valid.
+        def valid_keys?(options)
+          return false unless options.is_a?(::Hash)
+          options.keys.all? do |key|
+            VALID_OPTIONS.include?(key)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/clients/validators.rb

@@ -0,0 +1,3 @@
+# frozen_string_literal: true
+
+require "mongoid/clients/validators/storage"

data/lib/mongoid/clients.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "mongoid/clients/factory"
+require "mongoid/clients/validators"
+require "mongoid/clients/storage_options"
+require "mongoid/clients/options"
+require "mongoid/clients/sessions"
+
+module Mongoid
+  module Clients
+    extend ActiveSupport::Concern
+    include StorageOptions
+    include Options
+    include Sessions
+
+    class << self
+
+      # Clear all clients from the current thread.
+      #
+      # @example Clear all clients.
+      #   Mongoid::Clients.clear
+      #
+      # @return [ Array ] The empty clients.
+      def clear
+        clients.clear
+      end
+
+      # Get the default client.
+      #
+      # @example Get the default client.
+      #   Mongoid::Clients.default
+      #
+      # @return [ Mongo::Client ] The default client.
+      def default
+        with_name(:default)
+      end
+
+      # Disconnect all active clients.
+      #
+      # @example Disconnect all active clients.
+      #   Mongoid::Clients.disconnect
+      #
+      # @return [ true ] True.
+      def disconnect
+        clients.values.each do |client|
+          client.close
+        end
+      end
+
+      # Get a client with the provided name.
+      #
+      # @example Get a client with the name.
+      #   Mongoid::Clients.with_name(:replica)
+      #
+      # @param [ String | Symbol ] name The name of the client.
+      #
+      # @return [ Mongo::Client ] The named client.
+      def with_name(name)
+        name_as_symbol = name.to_sym
+        return clients[name_as_symbol] if clients[name_as_symbol]
+        CREATE_LOCK.synchronize do
+          clients[name_as_symbol] ||= Clients::Factory.create(name)
+        end
+      end
+
+      def set(name, client)
+        clients[name.to_sym] = client
+      end
+
+      def clients
+        @clients ||= {}
+      end
+
+      private
+
+      CREATE_LOCK = Mutex.new
+    end
+  end
+end

data/lib/mongoid/collection_configurable.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Mongoid
+
+  # Encapsulates behavior around defining collections.
+  module CollectionConfigurable
+    extend ActiveSupport::Concern
+
+    module ClassMethods
+      # Create the collection for the called upon Mongoid model.
+      #
+      # This method does not re-create existing collections.
+      #
+      # If the document includes `store_in` macro with `collection_options` key,
+      #   these options are used when creating the collection.
+      #
+      # @param [ true | false ] force If true, the method will drop existing
+      #   collections before creating new ones. If false, the method will create
+      #   only new collection (that do not exist in the database).
+      #
+      # @raise [ Errors::CreateCollectionFailure ] If collection creation failed.
+      # @raise [ Errors::DropCollectionFailure ] If an attempt to drop collection failed.
+      def create_collection(force: false)
+        if collection_name.empty?
+          # This is most probably an anonymous class, we ignore them.
+          return
+        end
+        if collection_name.match(/^system\./)
+          # We do not do anything with system collections.
+          return
+        end
+        if force
+          collection.drop
+        end
+        if coll_options = collection.database.list_collections(filter: { name: collection_name.to_s }).first
+          if force
+            raise Errors::DropCollectionFailure.new(collection_name)
+          else
+            logger.debug(
+              "MONGOID: Collection '#{collection_name}' already exists " +
+              "in database '#{database_name}' with options '#{coll_options}'."
+            )
+          end
+        else
+          begin
+            collection.database[collection_name, storage_options.fetch(:collection_options, {})].create
+          rescue Mongo::Error::OperationFailure => e
+            raise Errors::CreateCollectionFailure.new(
+              collection_name,
+              storage_options[:collection_options],
+              e
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mongoid/composable.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require "mongoid/changeable"
+require "mongoid/collection_configurable"
+require "mongoid/encryptable"
+require "mongoid/findable"
+require "mongoid/indexable"
+require "mongoid/inspectable"
+require "mongoid/interceptable"
+require "mongoid/matcher"
+require "mongoid/matchable"
+require "mongoid/persistable"
+require "mongoid/reloadable"
+require "mongoid/selectable"
+require "mongoid/scopable"
+require "mongoid/serializable"
+require "mongoid/shardable"
+require "mongoid/stateful"
+require "mongoid/cacheable"
+require "mongoid/traversable"
+require "mongoid/validatable"
+
+module Mongoid
+
+  # This module provides inclusions of all behavior in a Mongoid document.
+  module Composable
+    extend ActiveSupport::Concern
+
+    # All modules that a +Document+ is composed of are defined in this
+    # module, to keep the document class from getting too cluttered.
+    included do
+      extend Findable
+    end
+
+    include ActiveModel::Model
+    include ActiveModel::ForbiddenAttributesProtection
+    include ActiveModel::Serializers::JSON
+    include Atomic
+    include Changeable
+    include Clients
+    include CollectionConfigurable
+    include Attributes
+    include Evolvable
+    include Fields
+    include Indexable
+    include Inspectable
+    include Matchable
+    include Persistable
+    include Association
+    include Reloadable
+    include Scopable
+    include Selectable
+    include Serializable
+    include Shardable
+    include Stateful
+    include Cacheable
+    include Threaded::Lifecycle
+    include Traversable
+    include Validatable
+    include Interceptable
+    include Copyable
+    include Equality
+    include Encryptable
+
+    MODULES = [
+      Atomic,
+      Attributes,
+      Copyable,
+      Changeable,
+      Evolvable,
+      Fields,
+      Indexable,
+      Inspectable,
+      Interceptable,
+      Matchable,
+      Persistable,
+      Association,
+      Reloadable,
+      Scopable,
+      Serializable,
+      Clients,
+      Clients::Options,
+      Shardable,
+      Stateful,
+      Cacheable,
+      Threaded::Lifecycle,
+      Traversable,
+      Validatable,
+      Equality,
+      Association::Referenced::Syncable,
+      Association::Macros,
+      ActiveModel::Model,
+      ActiveModel::Validations
+    ]
+
+    # These are methods names defined in included blocks that may conflict
+    # with user-defined association or field names.
+    # They won't be in the list of Module.instance_methods on which the
+    # #prohibited_methods code below is dependent so we must track them
+    # separately.
+    #
+    # @return [ Array<Symbol> ] A list of reserved method names.
+    RESERVED_METHOD_NAMES = [ :fields,
+                              :aliased_fields,
+                              :localized_fields,
+                              :index_specifications,
+                              :shard_key_fields,
+                              :nested_attributes,
+                              :readonly_attributes,
+                              :storage_options,
+                              :cascades,
+                              :cyclic,
+                              :cache_timestamp_format
+                            ]
+
+    class << self
+
+      # Get a list of methods that would be a bad idea to define as field names
+      # or override when including Mongoid::Document.
+      #
+      # @example Bad thing!
+      #   Mongoid::Components.prohibited_methods
+      #
+      # @return [ Array<Symbol> ]
+      def prohibited_methods
+        @prohibited_methods ||= MODULES.flat_map do |mod|
+          mod.instance_methods.map(&:to_sym)
+        end + RESERVED_METHOD_NAMES
+      end
+    end
+  end
+end