bulk_dependency_eraser 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: e51d0383cb5b2111181c9dc48b499b046d225adad1d1f8b985216a0d395cb612
+  data.tar.gz: 02ce5200f03d7a4cec2cfa72b64fbfdf84e73ce5b3e6b43ba073173b48e5139b
+SHA512:
+  metadata.gz: 25857421c4e8cc6af0f952bacd106b39f19d34ac8d2292f74e9daa90c10ea07ab82e11fe584b7c0fcb60209fb1e4ba0d126e6e9102587b3d6ff6a69e495373e5
+  data.tar.gz: 68f2ec5423d953bf842de7c98ea778f44795a89cfa948b400c5171e08489446aba765467744175a5de69df6957fef1b04f0c017af7d63b1959d756caaac07a22

data/lib/bulk_dependency_eraser/base.rb

@@ -0,0 +1,54 @@
+module BulkDependencyEraser
+  class Base
+    DEFAULT_OPTS = {}.freeze
+
+    DEFAULT_DB_WRAPPER = ->(block) { block.call }
+
+    attr_reader :errors
+
+    def initialize opts: {}
+      filtered_opts = opts.slice(*self.class::DEFAULT_OPTS.keys)
+      @opts_c = options_container.new(
+        self.class::DEFAULT_OPTS.merge(filtered_opts)
+      )
+      @errors = []
+    end
+
+    def execute
+      raise NotImplementedError
+    end
+
+    protected
+
+    # Create options container
+    def options_container
+      Struct.new(
+        *self.class::DEFAULT_OPTS.keys,
+        keyword_init: true
+      ).freeze
+    end
+
+    def report_error msg
+      @errors << msg
+    end
+
+    def merge_errors errors, prefix = nil
+      local_errors = errors.dup
+
+      unless local_errors.any?
+        local_errors << '<NO ERRORS FOUND TO MERGE>'
+      end
+
+      if prefix
+        local_errors = errors.map { |error| prefix + error }
+      end
+      @errors += local_errors
+    end
+
+    def uniqify_errors!
+      @errors.uniq!
+    end
+
+    attr_reader :opts_c
+  end
+end

data/lib/bulk_dependency_eraser/builder.rb

@@ -0,0 +1,286 @@
+module BulkDependencyEraser
+  class Builder < Base
+    DEFAULT_OPTS = {
+      force_destroy_restricted: false,
+      verbose: false,
+      # Some associations scopes take parameters.
+      # - We would have to instantiate if we wanted to apply that scope filter.
+      instantiate_if_assoc_scope_with_arity: false,
+      db_read_wrapper: self::DEFAULT_DB_WRAPPER,
+    }.freeze
+
+    DEPENDENCY_NULLIFY = %i[
+      nullify
+    ].freeze
+
+    # Abort deletion if assoc dependency value is any of these.
+    # - exception if the :force_destroy_restricted option set true
+    DEPENDENCY_RESTRICT = %i[
+      restrict_with_error
+      restrict_with_exception
+    ].freeze
+
+    DEPENDENCY_DESTROY = (
+      %i[
+        destroy
+        delete_all
+        destroy_async
+      ] + self::DEPENDENCY_RESTRICT
+    ).freeze
+
+    DEPENDENCY_DESTROY_IGNORE_REFLECTION_TYPES = [
+      # Rails 6.1, when a has_and_delongs_to_many <assoc>, dependent: :destroy,
+      # will ignore the destroy. Will neither destroy the join table record nor the association record
+      # We will do the same, mirror the fuctionality, by ignoring any :dependent options on these types.
+      'ActiveRecord::Reflection::HasAndBelongsToManyReflection'
+    ].freeze
+
+    attr_reader :deletion_list, :nullification_list
+
+    def initialize query:, opts: {}
+      @query = query
+      @deletion_list  = {}
+      @nullification_list = {}
+      super(opts:)
+    end
+
+    def execute
+      begin
+        build_result = deletion_query_parser(@query)
+
+        uniqify_errors!
+
+        return errors.none?
+      rescue StandardError => e
+        if @query.is_a?(ActiveRecord::Relation)
+          klass      = @query.klass
+          klass_name = @query.klass.name
+        else
+          # current_query is a normal rails class
+          klass      = @query
+          klass_name = @query.name
+        end
+        report_error(
+          "
+            Error Encountered in 'execute' for '#{klass_name}':
+              #{e.class.name}
+              #{e.message}
+          "
+        )
+
+        return false
+      end
+    end
+
+    def deletion_query_parser query, association_parent = nil
+      # necessary for "ActiveRecord::Reflection::ThroughReflection" use-case
+      # force_through_destroy_chains = options[:force_destroy_chain] || {}
+      # do_not_destroy_self = options[:do_not_destroy] || {}
+
+      if query.is_a?(ActiveRecord::Relation)
+        klass      = query.klass
+        klass_name = query.klass.name
+        table_klass_name = query.klass.table_name.classify
+      else
+        # current_query is a normal rails class
+        klass      = query
+        klass_name = query.name
+        table_klass_name = query.table_name.classify
+      end
+
+      if opts_c.verbose
+        if association_parent
+          puts "Building #{klass_name}"
+        else
+          puts "Building #{association_parent} => #{klass_name}"
+        end
+      end
+
+      if klass.primary_key != 'id'
+        report_error(
+          "#{klass_name} - does not use primary_key 'id'. Cannot use this tool to bulk delete."
+        )
+        return
+      end
+
+      # Pluck IDs of the current query
+      query_ids = read_from_db do
+        query.pluck(:id)
+      end
+
+      deletion_list[table_klass_name] ||= []
+
+      # prevent infinite recursion here.
+      # - Remove any IDs that have been processed before
+      query_ids = query_ids - deletion_list[table_klass_name]
+      # If ids are nil, let's find that error
+      if query_ids.none? #|| query_ids.nil?
+        # quick cleanup, if turns out was an empty class
+        deletion_list.delete(table_klass_name) if deletion_list[table_klass_name].none?
+        return
+      end
+
+      # Use-case: We have more IDs to process
+      # - can now safely add to the list, since we've prevented infinite recursion
+      deletion_list[table_klass_name] += query_ids
+
+      # Hard to test if not sorted
+      # - if we had more advanced rspec matches, we could do away with this.
+      deletion_list[table_klass_name].sort! if Rails.env.test?
+
+      # ignore associations that aren't a dependent destroyable type
+      destroy_associations = query.reflect_on_all_associations.select do |reflection|
+        assoc_dependent_type = reflection.options&.dig(:dependent)&.to_sym
+        if DEPENDENCY_DESTROY_IGNORE_REFLECTION_TYPES.include?(reflection.class.name)
+          # Ignore those types of associations.
+          false
+        elsif DEPENDENCY_RESTRICT.include?(assoc_dependent_type) && opts_c.force_destroy_restricted != true
+          # If the dependency_type is restricted_with_..., and we're not supposed to destroy those, report errork
+          report_error(
+            "#{klass_name}'s assoc '#{reflection.name}' has a 'dependent: :#{assoc_dependent_type}' set. " \
+            "If you still wish to destroy, use the 'force_destroy_restricted: true' option"
+          )
+          false
+        else
+          DEPENDENCY_DESTROY.include?(assoc_dependent_type)
+        end
+      end
+
+      nullify_associations = query.reflect_on_all_associations.select do |reflection|
+        assoc_dependent_type = reflection.options&.dig(:dependent)&.to_sym
+        DEPENDENCY_NULLIFY.include?(assoc_dependent_type)
+      end
+
+      destroy_association_names = destroy_associations.map(&:name)
+      nullify_association_names = nullify_associations.map(&:name)
+
+      # Iterate through the assoc names, if there are any :through assocs, then remap 
+      destroy_association_names = destroy_association_names.collect do |assoc_name|
+        find_root_association_from_through_assocs(klass, assoc_name)
+      end
+      nullify_association_names = nullify_association_names.collect do |assoc_name|
+        find_root_association_from_through_assocs(klass, assoc_name)
+      end
+
+      destroy_association_names.each do |destroy_association_name|
+        association_parser(klass, query, query_ids, destroy_association_name, :delete)
+      end
+
+      nullify_association_names.each do |nullify_association_name|
+        association_parser(klass, query, query_ids, nullify_association_name, :nullify)
+      end
+    end
+
+    # Iterate through each destroyable association, and recursively call 'deletion_query_parser'.
+    def association_parser parent_class, query, query_ids, association_name, type
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+      assoc_klass = reflection.klass
+      assoc_table_klass_name = assoc_klass.table_name.classify
+
+      assoc_query = assoc_klass.unscoped
+
+      unless assoc_klass.primary_key == 'id'
+        report_error("#{parent_class.name}'s association '#{association_name}' - assoc class does not use 'id' as a primary_key")
+        return
+      end
+
+      # If there is an association scope present, check to see how many parameters it's using
+      # - if there's any parameter, we have to either skip it or instantiate it to find it's dependencies.
+      if reflection.scope&.arity&.nonzero?
+        # TODO!
+        if opts_c.instantiate_if_assoc_scope_with_arity
+          raise "TODO: instantiate and apply scope!"
+        else
+          report_error(
+            "#{parent_class.name} and '#{association_name}' - scope has instance parameters. Use :instantiate_if_assoc_scope_with_arity option?"
+          )
+          return
+        end
+      elsif reflection.scope
+        # I saw this used somewhere, too bad I didn't save the source for it.
+        s = parent_class.reflect_on_association(association_name).scope
+        assoc_query = assoc_query.instance_exec(&s)
+      end
+
+      specified_primary_key = reflection.options[:primary_key]&.to_s
+      specified_foreign_key = reflection.options[:foreign_key]&.to_s
+
+      # handle foreign_key edge cases
+      if specified_foreign_key.nil?
+        if reflection.options[:polymorphic]
+          assoc_query = assoc_query.where({(association_name.singularize + '_type').to_sym => parent_class.table_name.classify})
+          specified_foreign_key = association_name.singularize + "_id"
+        elsif reflection.options[:as]
+          assoc_query = assoc_query.where({(reflection.options[:as].to_s + '_type').to_sym => parent_class.table_name.classify})
+          specified_foreign_key = reflection.options[:as].to_s + "_id"
+        else
+          specified_foreign_key = parent_class.table_name.singularize + "_id"
+        end
+      end
+
+      # Check to see if foreign_key exists in association class's table
+      unless assoc_klass.column_names.include?(specified_foreign_key)
+        report_error(
+          "
+          For #{parent_class.name}'s assoc '#{assoc_klass.name}': Could not determine the assoc's foreign key.
+          Generated '#{specified_foreign_key}', but did not exist on the association table.
+          "
+        )
+        return
+      end
+
+      # Build association query, based on parent class's primary key and the assoc's foreign key
+      # - handle primary key edge cases
+      # - The associations might not be using the primary_key of the klass table, but we can support that here.
+      if specified_primary_key && specified_primary_key&.to_s != 'id'
+        alt_primary_ids = read_from_db do
+          query.pluck(specified_primary_key)
+        end
+        assoc_query = assoc_query.where(specified_foreign_key.to_sym => alt_primary_ids)
+      else
+        assoc_query = assoc_query.where(specified_foreign_key.to_sym => query_ids)
+      end
+
+      if type == :delete
+        # Recursively call 'deletion_query_parser' on association query, to delete any if the assoc's dependencies
+        deletion_query_parser(assoc_query, parent_class)
+      elsif type == :nullify
+        # No need for recursion here.
+        # - we're not destroying these assocs so we don't need to parse their dependencies.
+        assoc_ids = read_from_db do
+          assoc_query.pluck(:id)
+        end
+
+        # No assoc_ids, no need to add it to the nullification list
+        return if assoc_ids.none?
+
+        # puts "FOUND IDS: #{assoc_ids.insect}"
+        nullification_list[assoc_table_klass_name] ||= {}
+        nullification_list[assoc_table_klass_name][specified_foreign_key] ||= []
+        nullification_list[assoc_table_klass_name][specified_foreign_key] += assoc_ids
+        nullification_list[assoc_table_klass_name][specified_foreign_key].uniq!
+      else
+        raise "invalid parsing type: #{type}"
+      end
+    end
+
+    protected
+
+    # A dependent assoc may be through another association. Follow the throughs to find the correct assoc to destroy.
+    def find_root_association_from_through_assocs klass, association_name
+      reflection = klass.reflect_on_association(association_name)
+      options = reflection.options
+      if options.key?(:through)
+        return find_root_association_from_through_assocs(klass, options[:through])
+      else
+        association_name
+      end
+    end
+
+    def read_from_db(&block)
+      puts "Reading from DB..." if opts_c.verbose
+      opts_c.db_read_wrapper.call(block)
+    end
+  end
+end

data/lib/bulk_dependency_eraser/deleter.rb

@@ -0,0 +1,50 @@
+module BulkDependencyEraser
+  class Deleter < Base
+    DEFAULT_OPTS = {
+      verbose: false,
+      db_delete_wrapper: self::DEFAULT_DB_WRAPPER,
+    }.freeze
+
+    def initialize class_names_and_ids: {}, opts: {}
+      @class_names_and_ids = class_names_and_ids
+      super(opts:)
+    end
+
+    def execute
+      ActiveRecord::Base.transaction do
+        current_class_name = 'N/A'
+        begin
+          class_names_and_ids.keys.reverse.each do |class_name|
+            current_class_name = class_name
+            ids = class_names_and_ids[class_name]
+            klass = class_name.constantize
+
+            # Disable any ActiveRecord::InvalidForeignKey raised errors.
+            # src https://stackoverflow.com/questions/41005849/rails-migrations-temporarily-ignore-foreign-key-constraint
+            #     https://apidock.com/rails/ActiveRecord/ConnectionAdapters/AbstractAdapter/disable_referential_integrity
+            ActiveRecord::Base.connection.disable_referential_integrity do
+              delete_in_db do
+                klass.unscoped.where(id: ids).delete_all
+              end
+            end
+          end
+        rescue Exception => e
+          report_error("Issue attempting to delete '#{current_class_name}': #{e.name} - #{e.message}")
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      return errors.none?
+    end
+
+    protected
+
+    attr_reader :class_names_and_ids
+
+    def delete_in_db(&block)
+      puts "Deleting from DB..." if opts_c.verbose
+      opts_c.db_delete_wrapper.call(block)
+    end
+
+  end
+end

data/lib/bulk_dependency_eraser/manager.rb

@@ -0,0 +1,77 @@
+module BulkDependencyEraser
+  class Manager < Base
+    DEFAULT_OPTS = {
+      verbose: false,
+    }.freeze
+
+    delegate :nullification_list, :deletion_list, to: :dependency_builder
+
+    # @param query [ActiveRecord::Base | ActiveRecord::Relation]
+    def initialize query:, opts: {}
+      @opts = opts
+      @dependency_builder = BulkDependencyEraser::Builder.new(query:, opts:)
+      @deleter   = nil
+      @nullifier = nil
+
+      @built = false
+      super(opts:)
+    end
+
+    def execute
+      unless built
+        # return early if build fails
+        return false unless build
+      end
+
+      delete!
+      nullify!
+
+      return errors.none?
+    end
+
+    def build
+      builder_execution = @dependency_builder.execute
+
+      unless builder_execution
+        puts "Builder execution FAILED" if opts_c.verbose
+        merge_errors(dependency_builder.errors, 'Builder: ')
+      else
+        puts "Builder execution SUCCESSFUL" if opts_c.verbose
+      end
+
+      return builder_execution
+    end
+
+    def delete!
+      @deleter  = BulkDependencyEraser::Deleter.new(class_names_and_ids: deletion_list, opts:)
+      deleter_execution = deleter.execute
+      unless deleter_execution
+        puts "Deleter execution FAILED" if opts_c.verbose
+        merge_errors(deleter.errors, 'Deleter: ')
+      else
+        puts "Deleter execution SUCCESSFUL" if opts_c.verbose
+      end
+
+      return deleter_execution
+    end
+
+    def nullify!
+      @nullifier = BulkDependencyEraser::Nullifier.new(class_names_columns_and_ids: nullification_list, opts:)
+      nullifier_execution = nullifier.execute
+
+      unless nullifier_execution
+        puts "Nullifier execution FAILED" if opts_c.verbose
+        merge_errors(nullifier.errors, 'Nullifier: ')
+        @errors += nullifier.errors
+      else
+        puts "Nullifier execution SUCCESSFUL" if opts_c.verbose
+      end
+
+      return nullifier_execution
+    end
+
+    protected
+
+    attr_reader :dependency_builder, :deleter, :nullifier, :opts, :built
+  end
+end

data/lib/bulk_dependency_eraser/nullifier.rb

@@ -0,0 +1,63 @@
+module BulkDependencyEraser
+  class Nullifier < Base
+    DEFAULT_OPTS = {
+      verbose: false,
+      db_nullify_wrapper: self::DEFAULT_DB_WRAPPER
+    }.freeze
+
+    # @param class_names_columns_and_ids [Hash] - model names with columns to nullify pointing towards the record IDs that require the nullification.
+    # - structure:
+    #    {
+    #      <model_name>: {
+    #        column_name: <array_of_ids>
+    #      }
+    #    }
+    # @param opts [Hash] - hash of options, allowlisted in DEFAULT_OPTS
+    def initialize class_names_columns_and_ids:, opts: {}
+      @class_names_columns_and_ids = class_names_columns_and_ids
+      super(opts:)
+    end
+
+    def execute
+      ActiveRecord::Base.transaction do
+        current_class_name = 'N/A'
+        current_column = 'N/A'
+        begin
+          class_names_columns_and_ids.keys.reverse.each do |class_name|
+            current_class_name = class_name
+            klass = class_name.constantize
+
+            columns_and_ids = class_names_columns_and_ids[class_name]
+
+            columns_and_ids.each do |column, ids|
+              current_column = column
+              # Disable any ActiveRecord::InvalidForeignKey raised errors.
+              # src https://stackoverflow.com/questions/41005849/rails-migrations-temporarily-ignore-foreign-key-constraint
+              #     https://apidock.com/rails/ActiveRecord/ConnectionAdapters/AbstractAdapter/disable_referential_integrity
+              ActiveRecord::Base.connection.disable_referential_integrity do
+                nullify_in_db do
+                  klass.unscoped.where(id: ids).update_all(column => nil)
+                end
+              end
+            end
+          end
+        rescue Exception => e
+          report_error("Issue attempting to nullify '#{current_class_name}' column '#{current_column}': #{e.name} - #{e.message}")
+          raise ActiveRecord::Rollback
+        end
+      end
+
+      return errors.none?
+    end
+
+    protected
+
+    attr_reader :class_names_columns_and_ids
+
+    def nullify_in_db(&block)
+      puts "Nullifying from DB..." if opts_c.verbose
+      opts_c.db_nullify_wrapper.call(block)
+    end
+
+  end
+end

data/lib/bulk_dependency_eraser.rb

@@ -0,0 +1,5 @@
+require_relative 'bulk_dependency_eraser/base'
+require_relative 'bulk_dependency_eraser/builder'
+require_relative 'bulk_dependency_eraser/deleter'
+require_relative 'bulk_dependency_eraser/nullifier'
+require_relative 'bulk_dependency_eraser/manager'

metadata

@@ -0,0 +1,147 @@
+--- !ruby/object:Gem::Specification
+name: bulk_dependency_eraser
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- benjamin.dana.software.dev@gmail.com
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2024-08-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.9'
+- !ruby/object:Gem::Dependency
+  name: listen
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.2'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+- !ruby/object:Gem::Dependency
+  name: database_cleaner
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.8'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.4'
+description:
+email:
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/bulk_dependency_eraser.rb
+- lib/bulk_dependency_eraser/base.rb
+- lib/bulk_dependency_eraser/builder.rb
+- lib/bulk_dependency_eraser/deleter.rb
+- lib/bulk_dependency_eraser/manager.rb
+- lib/bulk_dependency_eraser/nullifier.rb
+homepage: https://github.com/danabr75/bulk_dependency_eraser
+licenses:
+- LGPL-3.0-only
+metadata: {}
+post_install_message:
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.4.6
+signing_key:
+specification_version: 4
+summary: A bulk deletion tool that deletes records and their dependencies without
+  instantiation
+test_files: []