mongo_trails 10.3.1 → 14.0.0

data/lib/mongo_trails/model_config.rb

@@ -1,178 +1,8 @@
 # frozen_string_literal: true
 
 module PaperTrail
-  # Configures an ActiveRecord model, mostly at application boot time, but also
-  # sometimes mid-request, with methods like enable/disable.
   class ModelConfig
-    E_CANNOT_RECORD_AFTER_DESTROY = <<-STR.strip_heredoc.freeze
-      paper_trail.on_destroy(:after) is incompatible with ActiveRecord's
-      belongs_to_required_by_default. Use on_destroy(:before)
-      or disable belongs_to_required_by_default.
-    STR
-    E_HPT_ABSTRACT_CLASS = <<~STR.squish.freeze
-      An application model (%s) has been configured to use PaperTrail (via
-      `has_paper_trail`), but the version model it has been told to use (%s) is
-      an `abstract_class`. This could happen when an advanced feature called
-      Custom Version Classes (http://bit.ly/2G4ch0G) is misconfigured. When all
-      version classes are custom, PaperTrail::Version is configured to be an
-      `abstract_class`. This is fine, but all application models must be
-      configured to use concrete (not abstract) version models.
-    STR
-    E_MODEL_LIMIT_REQUIRES_ITEM_SUBTYPE = <<~STR.squish.freeze
-      To use PaperTrail's per-model limit in your %s model, you must have an
-      item_subtype column in your versions table. See documentation sections
-      2.e.1 Per-model limit, and 4.b.1 The optional item_subtype column.
-    STR
-    DPR_PASSING_ASSOC_NAME_DIRECTLY_TO_VERSIONS_OPTION = <<~STR.squish
-      Passing versions association name as `has_paper_trail versions: %{versions_name}`
-      is deprecated. Use `has_paper_trail versions: {name: %{versions_name}}` instead.
-      The hash you pass to `versions:` is now passed directly to `has_many`.
-    STR
-    DPR_CLASS_NAME_OPTION = <<~STR.squish
-      Passing Version class name as `has_paper_trail class_name: %{class_name}`
-      is deprecated. Use `has_paper_trail versions: {class_name: %{class_name}}`
-      instead. The hash you pass to `versions:` is now passed directly to `has_many`.
-    STR
-
-    def initialize(model_class)
-      @model_class = model_class
-    end
-
-    # Adds a callback that records a version after a "create" event.
-    #
-    # @api public
-    def on_create
-      @model_class.after_create { |r|
-        r.paper_trail.record_create if r.paper_trail.save_version?
-      }
-      return if @model_class.paper_trail_options[:on].include?(:create)
-      @model_class.paper_trail_options[:on] << :create
-    end
-
-    # Adds a callback that records a version before or after a "destroy" event.
-    #
-    # @api public
-    def on_destroy(recording_order = "before")
-      unless %w[after before].include?(recording_order.to_s)
-        raise ArgumentError, 'recording order can only be "after" or "before"'
-      end
-
-      if recording_order.to_s == "after" && cannot_record_after_destroy?
-        raise E_CANNOT_RECORD_AFTER_DESTROY
-      end
-
-      @model_class.send(
-        "#{recording_order}_destroy",
-        lambda do |r|
-          return unless r.paper_trail.save_version?
-          r.paper_trail.record_destroy(recording_order)
-        end
-      )
-
-      return if @model_class.paper_trail_options[:on].include?(:destroy)
-      @model_class.paper_trail_options[:on] << :destroy
-    end
-
-    # Adds a callback that records a version after an "update" event.
-    #
-    # @api public
-    def on_update
-      @model_class.before_save { |r|
-        r.paper_trail.reset_timestamp_attrs_for_update_if_needed
-      }
-      @model_class.after_update { |r|
-        if r.paper_trail.save_version?
-          r.paper_trail.record_update(
-            force: false,
-            in_after_callback: true,
-            is_touch: false
-          )
-        end
-      }
-      @model_class.after_update { |r|
-        r.paper_trail.clear_version_instance
-      }
-      return if @model_class.paper_trail_options[:on].include?(:update)
-      @model_class.paper_trail_options[:on] << :update
-    end
-
-    # Adds a callback that records a version after a "touch" event.
-    # @api public
-    def on_touch
-      @model_class.after_touch { |r|
-        r.paper_trail.record_update(
-          force: true,
-          in_after_callback: true,
-          is_touch: true
-        )
-      }
-    end
-
-    # Set up `@model_class` for PaperTrail. Installs callbacks, associations,
-    # "class attributes", instance methods, and more.
-    # @api private
-    def setup(options = {})
-      options[:on] ||= %i[create update destroy touch]
-      options[:on] = Array(options[:on]) # Support single symbol
-      @model_class.send :include, ::PaperTrail::Model::InstanceMethods
-      setup_options(options)
-      setup_associations(options)
-      check_presence_of_item_subtype_column(options)
-      @model_class.after_rollback { paper_trail.clear_rolled_back_versions }
-      setup_callbacks_from_options options[:on]
-    end
-
-    def version_class
-      @_version_class ||= @model_class.version_class_name.constantize
-    end
-
-    private
-
-    # Raises an error if the provided class is an `abstract_class`.
-    # @api private
-    def assert_concrete_activerecord_class(class_name)
-      if class_name.constantize.abstract_class?
-        raise format(E_HPT_ABSTRACT_CLASS, @model_class, class_name)
-      end
-    end
-
-    def cannot_record_after_destroy?
-      ::ActiveRecord::Base.belongs_to_required_by_default
-    end
-
-    # Some options require the presence of the `item_subtype` column. Currently
-    # only `limit`, but in the future there may be others.
-    #
-    # @api private
-    def check_presence_of_item_subtype_column(options)
-      return unless options.key?(:limit)
-      return if version_class.item_subtype_column_present?
-      raise format(E_MODEL_LIMIT_REQUIRES_ITEM_SUBTYPE, @model_class.name)
-    end
-
-    def check_version_class_name(options)
-      # @api private - `version_class_name`
-      @model_class.class_attribute :version_class_name
-      if options[:class_name]
-        ::ActiveSupport::Deprecation.warn(
-          format(
-            DPR_CLASS_NAME_OPTION,
-            class_name: options[:class_name].inspect
-          ),
-          caller(1)
-        )
-        options[:versions][:class_name] = options[:class_name]
-      end
-      @model_class.version_class_name = options[:versions][:class_name] || "PaperTrail::Version"
-    end
-
-    def check_versions_association_name(options)
-      # @api private - versions_association_name
-      @model_class.class_attribute :versions_association_name
-      @model_class.versions_association_name = options[:versions][:name] || :versions
-    end
-
-    def define_has_many_mongo_versions(options)
+    def define_has_many_versions(options)
       options = ensure_versions_option_is_hash(options)
       check_version_class_name(options)
       check_versions_association_name(options)
@@ -184,66 +14,5 @@ module PaperTrail
         end
       RUBY
     end
-
-    def ensure_versions_option_is_hash(options)
-      unless options[:versions].is_a?(Hash)
-        if options[:versions]
-          ::ActiveSupport::Deprecation.warn(
-            format(
-              DPR_PASSING_ASSOC_NAME_DIRECTLY_TO_VERSIONS_OPTION,
-              versions_name: options[:versions].inspect
-            ),
-            caller(1)
-          )
-        end
-        options[:versions] = {
-          name: options[:versions]
-        }
-      end
-      options
-    end
-
-    def get_versions_scope(options)
-      options[:versions][:scope] || -> { order(model.timestamp_sort_order) }
-    end
-
-    def setup_associations(options)
-      # @api private - version_association_name
-      @model_class.class_attribute :version_association_name
-      @model_class.version_association_name = options[:version] || :version
-
-      # The version this instance was reified from.
-      # @api public
-      @model_class.send :attr_accessor, @model_class.version_association_name
-
-      # @api public - paper_trail_event
-      @model_class.send :attr_accessor, :paper_trail_event
-
-      define_has_many_mongo_versions(options)
-    end
-
-    def setup_callbacks_from_options(options_on = [])
-      options_on.each do |event|
-        public_send("on_#{event}")
-      end
-    end
-
-    def setup_options(options)
-      # @api public - paper_trail_options - Let's encourage plugins to use eg.
-      # `paper_trail_options[:versions][:class_name]` rather than
-      # `version_class_name` because the former is documented and the latter is
-      # not.
-      @model_class.class_attribute :paper_trail_options
-      @model_class.paper_trail_options = options.dup
-
-      %i[ignore skip only].each do |k|
-        @model_class.paper_trail_options[k] = [@model_class.paper_trail_options[k]].
-          flatten.
-          compact.
-          map { |attr| attr.is_a?(Hash) ? attr.stringify_keys : attr.to_s }
-      end
-
-      @model_class.paper_trail_options[:meta] ||= {}
-    end
   end
 end

data/lib/mongo_trails/mongo_support/config.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'mongoid'
 
 Mongoid.configure do |config|
@@ -6,4 +8,8 @@ Mongoid.configure do |config|
   config.log_level = :error
 end
 
-Mongoid::QueryCache.enabled = false
+if defined?(Mongo::QueryCache)
+  Mongo::QueryCache.enabled = false
+elsif defined?(Mongoid::QueryCache)
+  Mongoid::QueryCache.enabled = false
+end

data/lib/mongo_trails/mongo_support/criteria.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Mongoid
+  class Criteria
+    def reset; end
+  end
+end

data/lib/mongo_trails/mongo_support/version.rb

@@ -1,20 +1,129 @@
-require "mongoid"
-require "autoinc"
+# frozen_string_literal: true
+
+require 'mongoid'
+require 'time'
+require 'mongo_trails/mongo_support/version_commit_wrap'
+
+begin
+  require 'sidekiq'
+  require 'mongo_trails/mongo_support/write_version_worker'
+  require 'mongo_trails/mongo_support/criteria'
+rescue LoadError
+  # Continue without Sidekiq
+end
 
 class AutoIncrementCounters
   include Mongoid::Document
+
+  store_in collection: 'auto_increment_counters'
+
+  field :sequence, type: Integer, default: 0
 end
 
-module PaperTrail
+PaperTrail.config.has_paper_trail_defaults = { versions: { class_name: 'MongoTrails::Version' } }
+
+module MongoTrails
   class Version
+    class << self
+      def find(id)
+        find_by(integer_id: id)
+      end
+
+      def incrementing_fields
+        @incrementing_fields ||= {
+          integer_id: {
+            scope: -> { MongoTrails::Version.prefix_map },
+            step: 1
+          }
+        }
+      end
+
+      def prefix_map
+        (PaperTrail.config.mongo_prefix.is_a?(Proc) && PaperTrail.config.mongo_prefix.call) || 'paper_trail'
+      end
+
+      def next_integer_id
+        next_integer_ids(1).first
+      end
+
+      def next_integer_ids(count, scope: prefix_map)
+        return [] if count.to_i <= 0
+
+        counter_id = counter_key(scope)
+        ensure_counter_initialized(counter_id, scope)
+
+        counter = AutoIncrementCounters.collection.find(_id: counter_id).find_one_and_update(
+          { '$inc' => { sequence: count } },
+          upsert: true,
+          return_document: :after
+        )
+        max_integer_id = counter.fetch('sequence')
+
+        ((max_integer_id - count + 1)..max_integer_id).to_a
+      end
+
+      def bulk_insert_attributes(version)
+        version = version.is_a?(self) ? version : new(version)
+        attrs = version.attributes.dup
+        attrs.delete('_id') if attrs['_id'].nil?
+        attrs
+      end
+
+      def table_name; end
+
+      def abstract_class?
+        false
+      end
+
+      def columns_hash
+        fields
+      end
+
+      def column_names
+        fields.keys
+      end
+
+      def belongs_to(_name, _options = {}, &block); end
+
+      def validates_presence_of(_name); end
+
+      def after_create(_name); end
+
+      private
+
+      def counter_key(scope)
+        "#{name}:#{scope || prefix_map}"
+      end
+
+      def ensure_counter_initialized(counter_id, _scope)
+        existing_counter = AutoIncrementCounters.collection.find(_id: counter_id).first
+        return if existing_counter.present?
+
+        max_id = maximum_existing_integer_id
+
+        AutoIncrementCounters.collection.find(_id: counter_id).find_one_and_update(
+          { '$setOnInsert' => { sequence: max_id } },
+          upsert: true,
+          return_document: :after
+        )
+      end
+
+      def maximum_existing_integer_id
+        pipeline = [
+          { '$match' => {} },
+          { '$group' => { _id: nil, max_integer_id: { '$max' => '$integer_id' } } }
+        ]
+        Version.collection.aggregate(pipeline).first&.dig('max_integer_id').to_i
+      end
+    end
+
     include PaperTrail::VersionConcern
     include Mongoid::Document
-    include Mongoid::Autoinc
 
-    store_in collection: ->() { "#{PaperTrail::Version.prefix_map}_versions" }
+    store_in collection: -> { "#{MongoTrails::Version.prefix_map}_versions" }
 
     field :item_type, type: String
-    field :item_id, type: Integer
+    field :item_id, type: String
     field :event, type: String
     field :whodunnit, type: String
     field :object, type: Hash
@@ -22,35 +131,149 @@ module PaperTrail
     field :created_at, type: DateTime
     field :integer_id, type: Integer
 
-    increments :integer_id, scope: -> { PaperTrail::Version.prefix_map }
+    index({ item_type: -1, item_id: -1 }, { background: true })
 
-    class << self
-      def reset
-        Mongoid::QueryCache.clear_cache
-      end
+    before_create :assign_integer_id
 
-      def find(id)
-        find_by(integer_id: id)
-      end
+    attr_accessor :mongo_trails_source_item
 
-      def prefix_map
-        (PaperTrail.config.mongo_prefix.is_a?(Proc) ? PaperTrail.config.mongo_prefix.call : 'paper_trail') || 'paper_trail'
-      end
+    def save_version
+      schedule_version_persistence(bang: false)
+    end
+
+    def save_version!
+      schedule_version_persistence(bang: true)
     end
 
     def initialize(data)
+      data = data.to_h.deep_symbolize_keys
       item = data.delete(:item)
       if item.present?
         data[:item_type] = item.class.name
         data[:item_id] = item.id
       end
-      data[:created_at] = Time.zone&.now || Time.now
+      data[:created_at] = normalize_created_at(data[:created_at])
 
       super
     end
 
     def item
-      item_type.constantize.find(item_id)
+      item_type.constantize.find_by(id: item_id)
+    end
+
+    def object=(value)
+      super(escape_value(value))
+    end
+
+    def object
+      unescape_value(super)
+    end
+
+    def object_changes
+      unescape_value(super)
+    end
+
+    def object_changes=(value)
+      super(escape_value(value))
+    end
+
+    def unescape_value(value)
+      value&.deep_transform_keys { |key| parser.unescape(force_utf8(key)) }
+    end
+
+    def escape_value(value)
+      value&.deep_transform_keys { |key| parser.escape(force_utf8(key.to_s), /[$.]/) }
+    end
+
+    private
+
+    def schedule_version_persistence(bang:)
+      connection = transaction_connection
+      return persist_version(self, bang:) unless connection.transaction_open?
+      unless mongo_trails_source_item
+        return VersionCommitWrap.new { persist_version(self, bang:) }.add_to_transaction(connection)
+      end
+
+      if (propagation = callback_propagation)
+        merge_callback_propagation(propagation, connection:, bang:)
+      else
+        register_callback_propagation(connection:, bang:)
+      end
+    end
+
+    def transaction_connection
+      mongo_trails_source_item ? mongo_trails_source_item.class.connection : ActiveRecord::Base.connection
+    end
+
+    def callback_propagation
+      return callback_propagations[event] unless event == 'update'
+
+      callback_propagations[event] || callback_propagations['create']
+    end
+
+    def callback_propagations
+      mongo_trails_source_item.instance_variable_get(:@mongo_trails_callback_propagations) ||
+        mongo_trails_source_item.instance_variable_set(:@mongo_trails_callback_propagations, {})
+    end
+
+    def register_callback_propagation(connection:, bang:)
+      propagation = CallbackPropagation.new(mongo_trails_source_item, self, bang:)
+      callback_propagations[event] = propagation
+      VersionCommitWrap.new(rollback: -> { propagation.clear }) { propagation.persist }.add_to_transaction(connection)
+    end
+
+    def merge_callback_propagation(propagation, connection:, bang:)
+      snapshot = propagation.snapshot
+      VersionCommitWrap.new(rollback: -> { propagation.restore!(snapshot) }) {}.add_to_transaction(connection)
+      propagation.merge!(self, bang:)
+    end
+
+    def assign_integer_id
+      self.integer_id ||= self.class.next_integer_id
+    end
+
+    def normalize_created_at(value)
+      return value if value.is_a?(Time) || value.is_a?(DateTime)
+      return current_time if value.nil?
+
+      parse_time(value)
+    rescue ArgumentError
+      current_time
+    end
+
+    def persist_version(version, bang: false)
+      return version.send(:async_save!) if sidekiq_enabled?
+
+      bang ? version.save! : version.save
+    end
+
+    def parse_time(value)
+      time_zone&.parse(value.to_s) || Time.parse(value.to_s)
+    end
+
+    def current_time = time_zone&.now || Time.now
+    def time_zone = Time.zone
+
+    def sidekiq_enabled?
+      defined?(Sidekiq) && PaperTrail.config.enable_sidekiq
+    end
+
+    def force_utf8(value)
+      value.respond_to?(:force_encoding) ? value.dup.force_encoding('UTF-8') : value
+    end
+
+    def parser
+      @parser ||= URI::Parser.new
+    end
+
+    def async_save!
+      worker = defined?(PaperTrail.config.sidekiq_worker.queue) ? PaperTrail.config.sidekiq_worker : PaperTrail::WriteVersionWorker
+      args = attributes.as_json
+      if worker == PaperTrail::WriteVersionWorker
+        worker.set(PaperTrail.config.sidekiq_options).perform_async(args)
+      else
+        worker.perform_async(args)
+      end
     end
   end
 end

data/lib/mongo_trails/mongo_support/version_commit_wrap.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module MongoTrails
+  class VersionCommitWrap
+    def initialize(rollback: nil, &callback)
+      @callback = callback
+      @rollback = rollback
+      @executed = false
+    end
+
+    def has_transactional_callbacks? # rubocop:disable Naming/PredicatePrefix
+      true
+    end
+
+    def trigger_transactional_callbacks?
+      true
+    end
+
+    def before_committed!; end
+
+    def rolledback!(*)
+      @executed = true
+      @rollback&.call
+    end
+
+    def committed!(**)
+      return if @executed
+
+      @executed = true
+      @callback.call
+    end
+
+    def add_to_transaction(connection = ActiveRecord::Base.connection)
+      connection.add_transaction_record(self)
+    end
+  end
+end

data/lib/mongo_trails/mongo_support/write_version_worker.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module PaperTrail
+  class WriteVersionWorker
+    include Sidekiq::Job
+
+    def perform(obj)
+      MongoTrails::Version.new(obj).save!
+    end
+  end
+end