mongo_trails 10.3.1 → 14.0.0

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.0'
+end

data/lib/mongo_trails/version_concern.rb

@@ -1,336 +1,47 @@
 # frozen_string_literal: true
 
-require "mongo_trails/attribute_serializers/object_changes_attribute"
-require "mongo_trails/queries/versions/where_object"
-require "mongo_trails/queries/versions/where_object_changes"
-
 module PaperTrail
-  # Originally, PaperTrail did not provide this module, and all of this
-  # functionality was in `PaperTrail::Version`. That model still exists (and is
-  # used by most apps) but by moving the functionality to this module, people
-  # can include this concern instead of sub-classing the `Version` model.
   module VersionConcern
     extend ::ActiveSupport::Concern
 
-    # :nodoc:
     module ClassMethods
-      def item_subtype_column_present?
-        column_names.include?("item_subtype")
-      end
-
       def with_item_keys(item_type, item_id)
-        where(item_type: item_type).and(item_id: item_id)
-      end
-
-      def creates
-        where event: "create"
-      end
-
-      def updates
-        where event: "update"
-      end
-
-      def destroys
-        where event: "destroy"
-      end
-
-      def not_creates
-        where "event <> ?", "create"
+        where(item_type: item_type, item_id: item_id)
       end
 
       def between(start_time, end_time)
-        where(:created_at.gt => start_time).and(:created_at.lt => end_time).order(timestamp_sort_order)
+        where(:created_at.gt => start_time, :created_at.lt => end_time).order(timestamp_sort_order)
       end
 
-      # Defaults to using the primary key as the secondary sort order if
-      # possible.
-      def timestamp_sort_order(direction = "asc")
+      def timestamp_sort_order(direction = 'asc')
         { created_at: direction.downcase }
       end
 
-      # Given a hash of attributes like `name: 'Joan'`, query the
-      # `versions.objects` column.
-      #
-      # ```
-      # SELECT "versions".*
-      # FROM "versions"
-      # WHERE ("versions"."object" LIKE '%
-      # name: Joan
-      # %')
-      # ```
-      #
-      # This is useful for finding versions where a given attribute had a given
-      # value. Imagine, in the example above, that Joan had changed her name
-      # and we wanted to find the versions before that change.
-      #
-      # Based on the data type of the `object` column, the appropriate SQL
-      # operator is used. For example, a text column will use `like`, and a
-      # jsonb column will use `@>`.
-      #
-      # @api public
-      def where_object(args = {})
-        raise ArgumentError, "expected to receive a Hash" unless args.is_a?(Hash)
-        Queries::Versions::WhereObject.new(self, args).execute
-      end
-
-      # Given a hash of attributes like `name: 'Joan'`, query the
-      # `versions.objects_changes` column.
-      #
-      # ```
-      # SELECT "versions".*
-      # FROM "versions"
-      # WHERE .. ("versions"."object_changes" LIKE '%
-      # name:
-      # - Joan
-      # %' OR "versions"."object_changes" LIKE '%
-      # name:
-      # -%
-      # - Joan
-      # %')
-      # ```
-      #
-      # This is useful for finding versions immediately before and after a given
-      # attribute had a given value. Imagine, in the example above, that someone
-      # changed their name to Joan and we wanted to find the versions
-      # immediately before and after that change.
-      #
-      # Based on the data type of the `object` column, the appropriate SQL
-      # operator is used. For example, a text column will use `like`, and a
-      # jsonb column will use `@>`.
-      #
-      # @api public
-      def where_object_changes(args = {})
-        raise ArgumentError, "expected to receive a Hash" unless args.is_a?(Hash)
-        Queries::Versions::WhereObjectChanges.new(self, args).execute
-      end
-
-      def primary_key_is_int?
-        @primary_key_is_int ||= columns_hash[primary_key].type == :integer
-      rescue StandardError # TODO: Rescue something more specific
-        true
-      end
-
-      # Returns whether the `object` column is using the `json` type supported
-      # by PostgreSQL.
       def object_col_is_json?
-        # %i[json jsonb].include?(columns_hash["object"].type)
         true
       end
 
-      # Returns whether the `object_changes` column is using the `json` type
-      # supported by PostgreSQL.
       def object_changes_col_is_json?
-        # %i[json jsonb].include?(columns_hash["object_changes"].try(:type))
         true
       end
 
-      # Returns versions before `obj`.
-      #
-      # @param obj - a `Version` or a timestamp
-      # @param timestamp_arg - boolean - When true, `obj` is a timestamp.
-      #   Default: false.
-      # @return `ActiveRecord::Relation`
-      # @api public
-      def preceding(obj, timestamp_arg = false)
-        if timestamp_arg != true && primary_key_is_int?
-          preceding_by_id(obj)
-        else
-          preceding_by_timestamp(obj)
-        end
-      end
-
-      # Returns versions after `obj`.
-      #
-      # @param obj - a `Version` or a timestamp
-      # @param timestamp_arg - boolean - When true, `obj` is a timestamp.
-      #   Default: false.
-      # @return `ActiveRecord::Relation`
-      # @api public
-      def subsequent(obj, timestamp_arg = false)
-        if timestamp_arg != true && primary_key_is_int?
-          subsequent_by_id(obj)
-        else
-          subsequent_by_timestamp(obj)
-        end
-      end
-
-      private
-
-      # @api private
       def preceding_by_id(obj)
         where(:integer_id.lt => obj.integer_id).order(integer_id: :desc)
       end
 
-      # @api private
       def preceding_by_timestamp(obj)
         obj = obj.send(:created_at) if obj.is_a?(self)
-        where(:created_at.lt => obj).order(timestamp_sort_order("desc"))
+        where(:created_at.lt => obj).order(timestamp_sort_order('desc'))
       end
 
-      # @api private
       def subsequent_by_id(version)
         where(:integer_id.gt => version.integer_id).order(integer_id: :asc)
       end
 
-      # @api private
       def subsequent_by_timestamp(obj)
         obj = obj.send(:created_at) if obj.is_a?(self)
         where(:created_at.gt => obj).order(timestamp_sort_order)
       end
     end
-
-    # @api private
-    def object_deserialized
-      if self.class.object_col_is_json?
-        object
-      else
-        PaperTrail.serializer.load(object)
-      end
-    end
-
-    # Restore the item from this version.
-    #
-    # Options:
-    #
-    # - :mark_for_destruction
-    #   - `true` - Mark the has_one/has_many associations that did not exist in
-    #     the reified version for destruction, instead of removing them.
-    #   - `false` - Default. Useful for persisting the reified version.
-    # - :dup
-    #   - `false` - Default.
-    #   - `true` - Always create a new object instance. Useful for
-    #     comparing two versions of the same object.
-    # - :unversioned_attributes
-    #   - `:nil` - Default. Attributes undefined in version record are set to
-    #     nil in reified record.
-    #   - `:preserve` - Attributes undefined in version record are not modified.
-    #
-    def reify(options = {})
-      unless self.class.fields.keys.include? "object"
-        raise "reify can't be called without an object column"
-      end
-      return nil if object.nil?
-      ::PaperTrail::Reifier.reify(self, options)
-    end
-
-    # Returns what changed in this version of the item.
-    # `ActiveModel::Dirty#changes`. returns `nil` if your `versions` table does
-    # not have an `object_changes` text column.
-    def changeset
-      return nil unless self.class.fields.keys.include? "object_changes"
-      @changeset ||= load_changeset
-    end
-
-    # Returns who put the item into the state stored in this version.
-    def paper_trail_originator
-      @paper_trail_originator ||= previous.try(:whodunnit)
-    end
-
-    # Returns who changed the item from the state it had in this version. This
-    # is an alias for `whodunnit`.
-    def terminator
-      @terminator ||= whodunnit
-    end
-    alias version_author terminator
-
-    def sibling_versions(reload = false)
-      if reload || !defined?(@sibling_versions) || @sibling_versions.nil?
-        @sibling_versions = self.class.with_item_keys(item_type, item_id)
-      end
-      @sibling_versions
-    end
-
-    def next
-      @next ||= sibling_versions.subsequent(self).first
-    end
-
-    def previous
-      @previous ||= sibling_versions.preceding(self).first
-    end
-
-    # Returns an integer representing the chronological position of the
-    # version among its siblings (see `sibling_versions`). The "create" event,
-    # for example, has an index of 0.
-    # @api public
-    def index
-      @index ||= RecordHistory.new(sibling_versions, self.class).index(self)
-    end
-
-    private
-
-    # @api private
-    def load_changeset
-      if PaperTrail.config.object_changes_adapter&.respond_to?(:load_changeset)
-        return PaperTrail.config.object_changes_adapter.load_changeset(self)
-      end
-
-      # First, deserialize the `object_changes` column.
-      changes = HashWithIndifferentAccess.new(object_changes_deserialized)
-
-      # The next step is, perhaps unfortunately, called "de-serialization",
-      # and appears to be responsible for custom attribute serializers. For an
-      # example of a custom attribute serializer, see
-      # `Person::TimeZoneSerializer` in the test suite.
-      #
-      # Is `item.class` good enough? Does it handle `inheritance_column`
-      # as well as `Reifier#version_reification_class`? We were using
-      # `item_type.constantize`, but that is problematic when the STI parent
-      # is not versioned. (See `Vehicle` and `Car` in the test suite).
-      #
-      # Note: `item` returns nil if `event` is "destroy".
-      unless item.nil?
-        AttributeSerializers::ObjectChangesAttribute.
-          new(item.class).
-          deserialize(changes)
-      end
-
-      # Finally, return a Hash mapping each attribute name to
-      # a two-element array representing before and after.
-      changes
-    end
-
-    # If the `object_changes` column is a Postgres JSON column, then
-    # ActiveRecord will deserialize it for us. Otherwise, it's a string column
-    # and we must deserialize it ourselves.
-    # @api private
-    def object_changes_deserialized
-      if self.class.object_changes_col_is_json?
-        object_changes
-      else
-        begin
-          PaperTrail.serializer.load(object_changes)
-        rescue StandardError # TODO: Rescue something more specific
-          {}
-        end
-      end
-    end
-
-    # Enforces the `version_limit`, if set. Default: no limit.
-    # @api private
-    def enforce_version_limit!
-      limit = version_limit
-      return unless limit.is_a? Numeric
-      previous_versions = sibling_versions.not_creates.
-        order(self.class.timestamp_sort_order("asc"))
-      return unless previous_versions.size > limit
-      excess_versions = previous_versions - previous_versions.last(limit)
-      excess_versions.map(&:destroy)
-    end
-
-    # See docs section 2.e. Limiting the Number of Versions Created.
-    # The version limit can be global or per-model.
-    #
-    # @api private
-    #
-    # TODO: Duplication: similar `constantize` in Reifier#version_reification_class
-    def version_limit
-      if self.class.item_subtype_column_present?
-        klass = (item_subtype || item_type).constantize
-        if klass&.paper_trail_options&.key?(:limit)
-          return klass.paper_trail_options[:limit]
-        end
-      end
-      PaperTrail.config.version_limit
-    end
   end
 end