mongo_trails 10.3.1 → 14.0.1

data/lib/mongo_trails/mongo_support/version.rb

@@ -1,20 +1,136 @@
-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
+        initialize_counter(counter_id, max_id)
+      end
+
+      def initialize_counter(counter_id, max_id)
+        AutoIncrementCounters.collection.find(_id: counter_id).find_one_and_update(
+          { '$setOnInsert' => { sequence: max_id } },
+          upsert: true,
+          return_document: :after
+        )
+      rescue Mongo::Error::OperationFailure => e
+        # DocumentDB can return E11000 when another writer creates this exact counter after the
+        # existence check. The caller can safely increment the counter created by that writer.
+        raise unless e.code == 11_000
+      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 +138,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

data/lib/mongo_trails/record_trail.rb

@@ -1,126 +1,31 @@
 # frozen_string_literal: true
 
-require "mongo_trails/events/create"
-require "mongo_trails/events/destroy"
-require "mongo_trails/events/update"
-
 module PaperTrail
-  # Represents the "paper trail" for a single record.
   class RecordTrail
-    RAILS_GTE_5_1 = ::ActiveRecord.gem_version >= ::Gem::Version.new("5.1.0.beta1")
-
-    def initialize(record)
-      @record = record
-    end
-
-    # Invoked after rollbacks to ensure versions records are not created for
-    # changes that never actually took place. Optimization: Use lazy `reset`
-    # instead of eager `reload` because, in many use cases, the association will
-    # not be used.
-    def clear_rolled_back_versions
-      versions_reset
-    end
-
-    def versions_reset
-      @record.class.paper_trail.version_class.reset
-    end
-
-    # Invoked via`after_update` callback for when a previous version is
-    # reified and then saved.
-    def clear_version_instance
-      @record.send("#{@record.class.version_association_name}=", nil)
-    end
-
-    # Is PT enabled for this particular record?
-    # @api private
-    def enabled?
-      PaperTrail.enabled? &&
-        PaperTrail.request.enabled? &&
-        PaperTrail.request.enabled_for_model?(@record.class)
-    end
-
-    # Returns true if this instance is the current, live one;
-    # returns false if this instance came from a previous version.
-    def live?
-      source_version.nil?
-    end
-
-    # Returns the object (not a Version) as it became next.
-    # NOTE: if self (the item) was not reified from a version, i.e. it is the
-    #  "live" item, we return nil.  Perhaps we should return self instead?
-    def next_version
-      subsequent_version = source_version.next
-      subsequent_version ? subsequent_version.reify : @record.class.find(@record.id)
-    rescue StandardError # TODO: Rescue something more specific
-      nil
-    end
-
-    # Returns who put `@record` into its current state.
-    #
-    # @api public
-    def originator
-      (source_version || versions.last).try(:whodunnit)
-    end
-
-    # Returns the object (not a Version) as it was most recently.
-    #
-    # @api public
-    def previous_version
-      (source_version ? source_version.previous : versions.last).try(:reify)
-    end
-
     def record_create
       return unless enabled?
 
-      build_version_on_create(in_after_callback: true).tap do |version|
-        version.save!
-        # Because the version object was created using version_class.new instead
-        # of versions_assoc.build?, the association cache is unaware. So, we
-        # invalidate the `versions` association cache with `reset`.
-        versions_reset
-      end
-    end
+      version = build_version_on_create(in_after_callback: true)
+      return if exceeds_record_size_limit?(version)
 
-    # PT-AT extends this method to add its transaction id.
-    #
-    # @api private
-    def data_for_create
-      {}
+      version.mongo_trails_source_item = @record
+      version.save_version!
     end
 
-    # `recording_order` is "after" or "before". See ModelConfig#on_destroy.
-    #
-    # @api private
-    # @return - The created version object, so that plugins can use it, e.g.
-    # paper_trail-association_tracking
     def record_destroy(recording_order)
       return unless enabled? && !@record.new_record?
-      in_after_callback = recording_order == "after"
-      event = Events::Destroy.new(@record, in_after_callback)
 
-      # Merge data from `Event` with data from PT-AT. We no longer use
-      # `data_for_destroy` but PT-AT still does.
+      in_after_callback = recording_order == 'after'
+      event = Events::Destroy.new(@record, in_after_callback)
       data = event.data.merge(data_for_destroy)
 
-      version = @record.class.paper_trail.version_class.create(data)
-      if version.errors.any?
-        log_version_errors(version, :destroy)
-      else
-        assign_and_reset_version_association(version)
-        version
-      end
-    end
+      version = @record.class.paper_trail.version_class.new(data)
+      return if exceeds_record_size_limit?(version)
 
-    # PT-AT extends this method to add its transaction id.
-    #
-    # @api private
-    def data_for_destroy
-      {}
+      version.mongo_trails_source_item = @record
+      version.save_version
     end
 
-    # @api private
-    # @return - The created version object, so that plugins can use it, e.g.
-    # paper_trail-association_tracking
     def record_update(force:, in_after_callback:, is_touch:)
       return unless enabled?
 
@@ -129,176 +34,30 @@ module PaperTrail
         in_after_callback: in_after_callback,
         is_touch: is_touch
       )
-      return unless version
+      return unless version && !exceeds_record_size_limit?(version)
 
-      if version.save
-        # Because the version object was created using version_class.new instead
-        # of versions_assoc.build?, the association cache is unaware. So, we
-        # invalidate the `versions` association cache with `reset`.
-        versions_reset
-        version
-      else
-        log_version_errors(version, :update)
-      end
+      version.mongo_trails_source_item = @record
+      version.save_version
     end
 
-    # PT-AT extends this method to add its transaction id.
-    #
-    # @api private
-    def data_for_update
-      {}
-    end
-
-    # @api private
-    # @return - The created version object, so that plugins can use it, e.g.
-    # paper_trail-association_tracking
     def record_update_columns(changes)
       return unless enabled?
-      event = Events::Update.new(@record, false, false, changes)
 
-      # Merge data from `Event` with data from PT-AT. We no longer use
-      # `data_for_update_columns` but PT-AT still does.
+      event = Events::Update.new(@record, false, false, changes)
       data = event.data.merge(data_for_update_columns)
-
       versions_assoc = @record.send(@record.class.versions_association_name)
-      version = versions_assoc.create(data)
-      if version.errors.any?
-        log_version_errors(version, :update)
-      else
-        version
-      end
-    end
+      version = versions_assoc.new(data)
+      return if exceeds_record_size_limit?(version)
 
-    # PT-AT extends this method to add its transaction id.
-    #
-    # @api private
-    def data_for_update_columns
-      {}
-    end
-
-    # Invoked via callback when a user attempts to persist a reified
-    # `Version`.
-    def reset_timestamp_attrs_for_update_if_needed
-      return if live?
-      @record.send(:timestamp_attributes_for_update_in_model).each do |column|
-        @record.send("restore_#{column}!")
-      end
-    end
-
-    # AR callback.
-    # @api private
-    def save_version?
-      if_condition = @record.paper_trail_options[:if]
-      unless_condition = @record.paper_trail_options[:unless]
-      (if_condition.blank? || if_condition.call(@record)) && !unless_condition.try(:call, @record)
-    end
-
-    def source_version
-      version
-    end
-
-    # Save, and create a version record regardless of options such as `:on`,
-    # `:if`, or `:unless`.
-    #
-    # Arguments are passed to `save`.
-    #
-    # This is an "update" event. That is, we record the same data we would in
-    # the case of a normal AR `update`.
-    def save_with_version(*args)
-      ::PaperTrail.request(enabled: false) do
-        @record.save(*args)
-      end
-      record_update(force: true, in_after_callback: false, is_touch: false)
-    end
-
-    # Like the `update_column` method from `ActiveRecord::Persistence`, but also
-    # creates a version to record those changes.
-    # @api public
-    def update_column(name, value)
-      update_columns(name => value)
-    end
-
-    # Like the `update_columns` method from `ActiveRecord::Persistence`, but also
-    # creates a version to record those changes.
-    # @api public
-    def update_columns(attributes)
-      # `@record.update_columns` skips dirty-tracking, so we can't just use
-      # `@record.changes` or @record.saved_changes` from `ActiveModel::Dirty`.
-      # We need to build our own hash with the changes that will be made
-      # directly to the database.
-      changes = {}
-      attributes.each do |k, v|
-        changes[k] = [@record[k], v]
-      end
-      @record.update_columns(attributes)
-      record_update_columns(changes)
-    end
-
-    # Returns the object (not a Version) as it was at the given timestamp.
-    def version_at(timestamp, reify_options = {})
-      # Because a version stores how its object looked *before* the change,
-      # we need to look for the first version created *after* the timestamp.
-      v = versions.subsequent(timestamp, true).first
-      return v.reify(reify_options) if v
-      @record unless @record.destroyed?
-    end
-
-    # Returns the objects (not Versions) as they were between the given times.
-    def versions_between(start_time, end_time)
-      versions = send(@record.class.versions_association_name).between(start_time, end_time)
-      versions.collect { |version| version_at(version.created_at) }
+      version.mongo_trails_source_item = @record
+      version.save_version
     end
 
     private
 
-    # @api private
-    def assign_and_reset_version_association(version)
-      @record.send("#{@record.class.version_association_name}=", version)
-      @record.send(@record.class.versions_association_name).reset
-    end
-
-    # @api private
-    def build_version_on_create(in_after_callback:)
-      event = Events::Create.new(@record, in_after_callback)
-
-      # Merge data from `Event` with data from PT-AT. We no longer use
-      # `data_for_create` but PT-AT still does.
-      data = event.data.merge!(data_for_create)
-
-      # Pure `version_class.new` reduces memory usage compared to `versions_assoc.build`
-      @record.class.paper_trail.version_class.new(data)
-    end
-
-    # @api private
-    def build_version_on_update(force:, in_after_callback:, is_touch:)
-      event = Events::Update.new(@record, in_after_callback, is_touch, nil)
-      return unless force || event.changed_notably?
-
-      # Merge data from `Event` with data from PT-AT. We no longer use
-      # `data_for_update` but PT-AT still does. To save memory, we use `merge!`
-      # instead of `merge`.
-      data = event.data.merge!(data_for_update)
-
-      # Using `version_class.new` reduces memory usage compared to
-      # `versions_assoc.build`. It's a trade-off though. We have to clear
-      # the association cache (see `versions.reset`) and that could cause an
-      # additional query in certain applications.
-      @record.class.paper_trail.version_class.new(data)
-    end
-
-    def log_version_errors(version, action)
-      version.logger&.warn(
-        "Unable to create version for #{action} of #{@record.class.name}" \
-          "##{@record.id}: " + version.errors.full_messages.join(", ")
-      )
-    end
-
-    def version
-      @record.public_send(@record.class.version_association_name)
-    end
-
-    def versions
-      @record.public_send(@record.class.versions_association_name)
+    def exceeds_record_size_limit?(version)
+      size_limit = PaperTrail.config.mongo_trails_config&.dig(:record_size_limit)
+      size_limit && size_limit.to_i < version.to_json.to_s.bytesize
     end
   end
 end

data/lib/mongo_trails/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module MongoTrails
+  VERSION = '14.0.1'
+end