[E] Improve soft deletion process

* We need to destroy certain large / unwieldy associations outside
  of the transaction that happens during the `destroy!` process. This
  prevents performance issues that come from locking too many rows at
  once. Records that reach this job already are intended to be taken
  out of the database, so we do not need to follow the normal type of
  data integrity concerns in order to remove them.
* Slight adjustment to stylesheets to prevent the styles from blowing
  up the console when inspecting stylesheet records.

Author: scryptmouse

api/app/jobs/soft_deletions/purge_job.rb

@@ -5,12 +5,13 @@ module SoftDeletions
   class PurgeJob < ApplicationJob
     queue_as :deletions
 
-    discard_on ActiveJob::DeserializationError, ActiveRecord::RecordNotFound, ActiveRecord::RecordNotDestroyed
+    discard_on ActiveJob::DeserializationError, ActiveRecord::RecordNotFound, ActiveRecord::RecordNotDestroyed,
+                SoftDeletions::Unpurgeable
 
     # @param [SoftDeletable] record
     # @return [void]
     def perform(record)
-      record.destroy! if record.marked_for_purge?
+      record.soft_deletion_purge!
     end
   end
 end

api/app/models/concerns/soft_deletable.rb

@@ -6,6 +6,7 @@ module SoftDeletable
   SOFT_DELETABLE_DEPENDENTS = %i[destroy delete_all].freeze
 
   include Filterable
+  include SoftDeletionSupport
 
   included do
     define_model_callbacks :mark_for_purge, :soft_delete
@@ -78,6 +79,13 @@ def soft_delete!
     soft_delete or raise ActiveRecord::RecordNotDestroyed.new("Failed to destroy the record", self)
   end
 
+  # @see SoftDeletions::Purge
+  # @see SoftDeletions::Purger
+  # @return [void]
+  def soft_deletion_purge!
+    ManifoldApi::Container["soft_deletions.purge"].call(self).value!
+  end
+
   private
 
   # @return [void]

api/app/models/concerns/soft_deletion_support.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Support methods for detecting if soft-deletion is happening.
+# Models do not have to be soft-deletable to take advantage of this concern.
+module SoftDeletionSupport
+  extend ActiveSupport::Concern
+
+  # @see SoftDeletions::Current
+  def soft_deleting?
+    SoftDeletions::Current.active?
+  end
+end

api/app/models/stylesheet.rb

@@ -12,6 +12,8 @@ class Stylesheet < ApplicationRecord
   include SerializedAbilitiesFor
   self.authorizer_name = "ProjectChildAuthorizer"
 
+  self.filter_attributes = [/\Araw_styles\z/, /\Astyles\z/].freeze
+
   # Associations
   belongs_to :text
   has_one :project, through: :text

api/app/models/text.rb

@@ -75,6 +75,8 @@ class Text < ApplicationRecord
   has_many :text_sections, -> { order(position: :asc) }, dependent: :destroy,
            inverse_of: :text, autosave: true
   has_one_readonly :text_section_aggregation, inverse_of: :text
+  has_many :text_section_nodes, -> { reorder(nil) }, through: :text_sections
+  has_many :text_section_stylesheets, -> { reorder(nil) }, through: :text_sections
   has_many :stylesheets, -> { order(position: :asc) }, dependent: :destroy,
            inverse_of: :text
   has_many :favorites, as: :favoritable, dependent: :destroy, inverse_of: :favoritable

api/app/models/text_section.rb

@@ -12,6 +12,7 @@ class TextSection < ApplicationRecord
   include HasKeywordSearch
   include SearchIndexable
   include SerializedAbilitiesFor
+  include SoftDeletionSupport
 
   KIND_COVER_IMAGE = "cover_image"
   KIND_NAVIGATION = "navigation"
@@ -47,7 +48,7 @@ class TextSection < ApplicationRecord
   has_many :annotations, dependent: :nullify
   has_many :resources, through: :annotations
   has_many :resource_collections, through: :annotations
-  has_many :text_section_nodes, inverse_of: :text_section, dependent: :destroy
+  has_many :text_section_nodes, inverse_of: :text_section, dependent: :delete_all
   has_many :text_section_stylesheets, dependent: :destroy
   has_many :stylesheets,
            -> { order(position: :asc) },
@@ -76,7 +77,7 @@ class TextSection < ApplicationRecord
   validates :slug, presence: true, allow_nil: true
 
   before_validation :update_body_json
-  after_destroy :remove_linked_toc_entries
+  after_destroy :remove_linked_toc_entries, unless: :skip_removal_of_toc_entries?
   after_save_commit :asynchronously_index_nodes!
   after_commit :maybe_adopt_or_orphan_annotations!, on: [:update, :destroy]
 
@@ -119,6 +120,10 @@ def packaging_identifier
     has_unique_source_identifier? ? source_identifier : slug
   end
 
+  def skip_removal_of_toc_entries?
+    destroyed_by_association || soft_deleting?
+  end
+
   def slug_candidates
     reserved_words = %w(all new edit session login logout users admin
                         stylesheets assets javascripts)

api/app/operations/soft_deletions/purge.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module SoftDeletions
+  # @see SoftDeletable
+  # @see SoftDeletions::PurgeJob
+  # @see SoftDeletions::Purger
+  class Purge
+    def call(...)
+      SoftDeletions::Purger.new(...).call
+    end
+  end
+end

api/app/services/soft_deletions/current.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SoftDeletions
+  # Current attributes for tracking the status of the soft-deletion process.
+  #
+  # @see SoftDeletionSupport
+  class Current < ActiveSupport::CurrentAttributes
+    attribute :active
+
+    class << self
+      alias active? active
+
+      # @return [void]
+      def active!
+        set(active: true) do
+          yield
+        end
+      end
+    end
+  end
+end

api/app/services/soft_deletions/purger.rb

@@ -0,0 +1,150 @@
+# frozen_string_literal: true
+
+module SoftDeletions
+  # We use this service to delete large objects in the background in order to avoid
+  # long-running requests, and specifically to avoid massive table locks happening
+  # within a single transaction during a soft-deletion.
+  #
+  # Normally we would want to keep a transaction active around processes like this
+  # in order to ensure data integrity, but if a model has reached this object, it
+  # is already marked for deletion and we don't need to maintain the ability to
+  # roll things back.
+  #
+  # @see SoftDeletable
+  # @see SoftDeletions::PurgeJob
+  # @see SoftDeletions::Purge
+  class Purger
+    extend ActiveModel::Callbacks
+
+    include Dry::Monads[:result]
+    include Dry::Initializer[undefined: false].define -> do
+      param :original_record, SoftDeletions::Types::SoftDeletable
+    end
+
+    define_model_callbacks :perform
+
+    around_perform :activate_soft_deletion!
+
+    around_perform :disable_acts_as_list!
+
+    # @raise [SoftDeletions::Unpurgeable] if the record could not be purged
+    # @return [Dry::Monads::Success(void)]
+    def call
+      # :nocov:
+      return Success() unless original_record.marked_for_purge?
+      # :nocov:
+
+      handle! original_record
+    rescue ActiveRecord::RecordNotDestroyed => e
+      raise SoftDeletions::Unpurgeable, "Could not soft delete #{original_record.class.name}(#{original_record.id.inspect}): #{e.message}"
+    else
+      Success()
+    end
+
+    private
+
+    # @param [ApplicationRecord] record
+    # @return [void]
+    def handle!(record)
+      case record
+      when Annotation
+        on_annotation! record
+      when Comment
+        on_comment! record
+      when Project
+        on_project! record
+      when ReadingGroup
+        on_reading_group! record
+      when Text
+        on_text! record
+      when TextSection
+        on_text_section! record
+      when User
+        on_user! record
+      end
+
+      record.destroy!
+    end
+
+    # @return [void]
+    def activate_soft_deletion!
+      SoftDeletions::Current.active! do
+        yield
+      end
+    end
+
+    def disable_acts_as_list!
+      TextSection.acts_as_list_no_update do
+        yield
+      end
+    end
+
+    # @param [Annotation] record
+    # @return [void]
+    def on_annotation!(record)
+      record.comments.where(parent_id: nil).find_each do |comment|
+        handle! comment
+      end
+    end
+
+    # @param [Comment] record
+    # @return [void]
+    def on_comment!(record)
+      record.children.find_each do |child_comment|
+        handle! child_comment
+      end
+    end
+
+    # @param [Project] record
+    # @return [void]
+    def on_project!(record)
+      record.texts.find_each do |text|
+        handle!(text)
+      end
+    end
+
+    # @param [ReadingGroup] record
+    # @return [void]
+    def on_reading_group!(record)
+      # We perform this outside of the transaction even though it's part of
+      # the callback.
+      record.update_annotations_privacy
+      record.reading_group_memberships.reorder(nil).delete_all
+      record.reading_group_categories.reorder(nil).delete_all
+    end
+
+    # @param [Text] record
+    # @return [void]
+    def on_text!(record)
+      # These are the biggest offender. Some texts can have tens of thousands of nodes,
+      # and we want to delete them outside of any transactions that lock other updates.
+      TextSectionNode.where(id: record.text_section_nodes.select(:id)).delete_all
+
+      TextSectionStylesheet.where(id: record.text_section_stylesheets.select(:id)).delete_all
+
+      record.action_callouts.destroy_all
+
+      record.text_sections.find_each do |text_section|
+        handle!(text_section)
+      end
+
+      record.stylesheets.delete_all
+    end
+
+    # @param [TextSection] record
+    # @return [void]
+    def on_text_section!(record)
+      record.text_section_nodes.delete_all
+      record.text_section_stylesheets.delete_all
+      record.annotations.update_all(text_section_id: nil)
+    end
+
+    # @param [User] record
+    # @return [void]
+    def on_user!(record)
+      record.annotations.find_each do |annotation|
+        handle! annotation
+      end
+    end
+  end
+end

api/app/services/soft_deletions/types.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module SoftDeletions
+  module Types
+    include Dry.Types
+
+    SoftDeletable = Types.Instance(::SoftDeletable)
+  end
+end