bulk_dependency_eraser 1.0.1 → 1.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 97a8415296925a84d544fa6a4deddcd0d5f2162116ed9c7bb210bcc16c2e74e6
-  data.tar.gz: f3dca162d1a357c87a305151f087a007005cff8f70656d0e4e514a0c6b419079
+  metadata.gz: cc034a38ab80a2e277860a5a69f6a654e1e461f691f54d6a510814b55279cebd
+  data.tar.gz: 88055bcbcb73bc260ef4718006f3149d95ea216badb4bd4ac142506e756c1882
 SHA512:
-  metadata.gz: 8a8fdc09856d111bbcf8a27057515e637b3e29866d9e5963b1851d0678f71c585331aab6cf63e9d8534cf7ad47e624f71035a5a09ba26dd168b10c0cf030f956
-  data.tar.gz: 8b3ce6e5e3391f639f9007a1990e21011a5173bc092f7e0eab234751130a3b6d5594f238609014b7e4ddff49b937af7c3773b0c79cbda1e4e4d191060e7fa5f2
+  metadata.gz: 0c9d1bc7851eaa2f51a853a99b24ff3842940f792938b2eac86ebfcc6471653c0d14de735d837f108ca59118a6661c086566b48475b87f1c98870cd80544dd79
+  data.tar.gz: 7e09f55e2baf0db2eefd7f2dfc028fda58b7f9ec2469a6bdbcfa56855bd4cf1ddc0b1502468554f56726fcbd08135daecc5e20940d18b2d9a2f49dc2558c5971

data/lib/bulk_dependency_eraser/base.rb

@@ -30,7 +30,9 @@ module BulkDependencyEraser
     end
 
     def report_error msg
-      @errors << msg
+      # remove new lines, surrounding white space, replace with semicolon delimiters
+      n = msg.strip.gsub(/\s*\n\s*/, ' ')
+      @errors << n
     end
 
     def merge_errors errors, prefix = nil

data/lib/bulk_dependency_eraser/builder.rb

@@ -13,6 +13,7 @@ module BulkDependencyEraser
       # Won't parse any table in this list
       ignore_tables_and_dependencies: [],
       ignore_klass_names_and_dependencies: [],
+      batching_size_limit: 500,
     }.freeze
 
     DEFAULT_DB_WRAPPER = ->(block) do
@@ -106,11 +107,18 @@ module BulkDependencyEraser
               #{e.message}
           "
         )
+        raise e
 
         return false
       end
     end
 
+    protected
+
+    attr_reader :ignore_klass_and_dependencies
+    attr_reader :table_names_to_parsed_klass_names
+    attr_reader :ignore_table_name_and_dependencies, :ignore_klass_name_and_dependencies
+
     def deletion_query_parser query, association_parent = nil
       # necessary for "ActiveRecord::Reflection::ThroughReflection" use-case
       # force_through_destroy_chains = options[:force_destroy_chain] || {}
@@ -145,7 +153,7 @@ module BulkDependencyEraser
         if association_parent
           puts "Building #{klass_name}"
         else
-          puts "Building #{association_parent} => #{klass_name}"
+          puts "Building #{association_parent}, assocation of #{klass_name}"
         end
       end
 
@@ -184,19 +192,12 @@ module BulkDependencyEraser
       # 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
+        DEPENDENCY_DESTROY.include?(assoc_dependent_type) && !DEPENDENCY_RESTRICT.include?(assoc_dependent_type)
+      end
+
+      restricted_associations = query.reflect_on_all_associations.select do |reflection|
+        assoc_dependent_type = reflection.options&.dig(:dependent)&.to_sym
+        DEPENDENCY_RESTRICT.include?(assoc_dependent_type)
       end
 
       nullify_associations = query.reflect_on_all_associations.select do |reflection|
@@ -204,16 +205,28 @@ module BulkDependencyEraser
         DEPENDENCY_NULLIFY.include?(assoc_dependent_type)
       end
 
-      destroy_association_names = destroy_associations.map(&:name)
-      nullify_association_names = nullify_associations.map(&:name)
+      destroy_association_names    = destroy_associations.map(&:name)
+      nullify_association_names    = nullify_associations.map(&:name)
+      restricted_association_names = restricted_associations.map(&:name)
 
-      # Iterate through the assoc names, if there are any :through assocs, then remap 
+      # Iterate through the assoc names, if there are any :through assocs, then rename the association
+      # - Rails interpretation of any dependencies of a :through association is to apply it to
+      #   the leaf association at the end of the :through chain(s)
       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
+      restricted_association_names = restricted_association_names.collect do |assoc_name|
+        find_root_association_from_through_assocs(klass, assoc_name)
+      end
+
+      if opts_c.verbose
+        puts "Destroyable Associations: #{destroy_association_names}"
+        puts "Nullifiable Associations: #{nullify_association_names}"
+        puts " Restricted Associations: #{restricted_association_names}"
+      end
 
       destroy_association_names.each do |destroy_association_name|
         association_parser(klass, query, query_ids, destroy_association_name, :delete)
@@ -222,12 +235,49 @@ module BulkDependencyEraser
       nullify_association_names.each do |nullify_association_name|
         association_parser(klass, query, query_ids, nullify_association_name, :nullify)
       end
+
+      restricted_association_names.each do |restricted_association_name|
+        association_parser(klass, query, query_ids, restricted_association_name, :restricted)
+      end
     end
 
-    # Iterate through each destroyable association, and recursively call 'deletion_query_parser'.
-    def association_parser parent_class, query, query_ids, association_name, type
+    # Used to iterate through each destroyable association, and recursively call 'deletion_query_parser'.
+    # @param parent_class     [ApplicationRecord]
+    # @param query            [ActiveRecord_Relation] - We need the 'query' in case associations are tied to column other than 'id'
+    # @param query_ids        [Array<Int | String>]   - Array of parent's IDs (or UUIDs)
+    # @param association_name [Symbol]                - The association name from the parent_class
+    # @param type             [Symbol]                - either :delete or :nullify or :restricted
+    def association_parser(parent_class, query, query_ids, association_name, type)
       reflection = parent_class.reflect_on_association(association_name)
       reflection_type = reflection.class.name
+
+      if self.class::DEPENDENCY_DESTROY_IGNORE_REFLECTION_TYPES.include?(reflection_type)
+        report_error("Dependency detected on #{parent_class.name}'s '#{association_name}' - association doesn't support dependency")
+        return 
+      end
+
+      case reflection_type
+      when 'ActiveRecord::Reflection::HasManyReflection'
+        association_parser_has_many(parent_class, query, query_ids, association_name, type)
+      when 'ActiveRecord::Reflection::HasOneReflection'
+        association_parser_has_many(parent_class, query, query_ids, association_name, type, { limit: 1 })
+      when 'ActiveRecord::Reflection::BelongsToReflection'
+        if type == :nullify
+          report_error("#{parent_class.name}'s association '#{association_name}' - dependent 'nullify' invalid for 'belongs_to'")
+        else
+          association_parser_belongs_to(parent_class, query, query_ids, association_name, type)
+        end
+      else
+        report_message("Unsupported association type for #{parent_class.name}'s association '#{association_name}': #{reflection_type}")
+      end
+    end
+
+    # Handles the :has_many association type
+    # - handles it's polymorphic associations internally (easier on the has_many)
+    def association_parser_has_many(parent_class, query, query_ids, association_name, type, opts = {})
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+
       assoc_klass = reflection.klass
       assoc_klass_name = assoc_klass.name
 
@@ -241,9 +291,9 @@ module BulkDependencyEraser
       # 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!"
+          association_parser_has_many_instantiation(parent_class, query, query_ids, association_name, type, opts)
+          return
         else
           report_error(
             "#{parent_class.name} and '#{association_name}' - scope has instance parameters. Use :instantiate_if_assoc_scope_with_arity option?"
@@ -252,21 +302,23 @@ module BulkDependencyEraser
         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)
+        assoc_scope = parent_class.reflect_on_association(association_name).scope
+        assoc_query = assoc_query.instance_exec(&assoc_scope)
       end
 
+      # Look for manually specified keys in the assocation first
       specified_primary_key = reflection.options[:primary_key]&.to_s
       specified_foreign_key = reflection.options[:foreign_key]&.to_s
+      # For polymorphic_associations
+      specified_foreign_type = nil
 
       # 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"
+        if reflection.options[:as]
+          specified_foreign_type = "#{reflection.options[:as]}_type"
+          specified_foreign_key = "#{reflection.options[:as]}_id"
+          # Only filtering by type here, the extra work for a poly assoc. We filter by IDs later
+          assoc_query = assoc_query.where({ specified_foreign_type.to_sym => parent_class.name })
         else
           specified_foreign_key = parent_class.table_name.singularize + "_id"
         end
@@ -277,7 +329,7 @@ module BulkDependencyEraser
         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.
+          Foreign key should have been '#{specified_foreign_key}', but did not exist on the #{assoc_klass.table_name} table.
           "
         )
         return
@@ -295,9 +347,18 @@ module BulkDependencyEraser
         assoc_query = assoc_query.where(specified_foreign_key.to_sym => query_ids)
       end
 
+      # Apply limit if has_one assocation (subset of has_many)
+      if opts[:limit]
+        assoc_query = assoc_query.limit(opts[:limit])
+      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 == :restricted
+        if traverse_restricted_dependency?(parent_class, reflection, assoc_query)
+          deletion_query_parser(assoc_query, parent_class)
+        end
       elsif type == :nullify
         # No need for recursion here.
         # - we're not destroying these assocs (just nullifying foreign_key columns) so we don't need to parse their dependencies.
@@ -312,16 +373,193 @@ module BulkDependencyEraser
         nullification_list[assoc_klass_name][specified_foreign_key] ||= []
         nullification_list[assoc_klass_name][specified_foreign_key] += assoc_ids
         nullification_list[assoc_klass_name][specified_foreign_key].uniq!
+
+        nullification_list[assoc_klass_name][specified_foreign_key].sort! if Rails.env.test?
+
+        # Also nullify the 'type' field, if the association is polymorphic
+        if specified_foreign_type
+          nullification_list[assoc_klass_name][specified_foreign_type] ||= []
+          nullification_list[assoc_klass_name][specified_foreign_type] += assoc_ids
+          nullification_list[assoc_klass_name][specified_foreign_type].uniq!
+
+          nullification_list[assoc_klass_name][specified_foreign_type].sort! if Rails.env.test?
+        end
       else
         raise "invalid parsing type: #{type}"
       end
     end
 
-    protected
+    # So you've decided to attempt instantiation...
+    # This will be a lot slower than the rest of our logic here, but if needs must.
+    #
+    # This method will replicate association_parser, but instantiate and iterate in batches
+    def association_parser_has_many_instantiation(parent_class, query, query_ids, association_name, type, opts)
+      raise "Invalid State! Not ready to instantiate!"
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+      assoc_klass = reflection.klass
+      assoc_klass_name = assoc_klass.name
 
-    attr_reader :ignore_klass_and_dependencies
-    attr_reader :table_names_to_parsed_klass_names
-    attr_reader :ignore_table_name_and_dependencies, :ignore_klass_name_and_dependencies
+
+      # specified_primary_key = reflection.options[:primary_key]&.to_s
+      # specified_foreign_key = reflection.options[:foreign_key]&.to_s
+
+      # assoc_query = assoc_klass.unscoped
+      # query.in_batches
+
+      assoc_klass.in_batches(of: opts_c.batching_size_limit) do |batch|
+        batch.each do |record|
+          record.send(association_name)
+        end
+      end
+    end
+
+    def association_parser_belongs_to(parent_class, query, query_ids, association_name, type)
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+
+      # Can't run certain checks on a polymorphic association, no definitive klass to use.
+      # - Usually, the polymorphic class is the leaf in a dependency tree.
+      # - In this case, i.e.: a `belongs_to :polymorphicable, polymorphic: true, dependent: :destroy` use-case
+      if reflection.options[:polymorphic]
+        # We'd have to pluck our various types, iterate through each, using each type as the assoc_query starting point
+        association_parser_belongs_to_polymorphic(parent_class, query, query_ids, association_name, type)
+        return
+      end
+
+      assoc_klass = reflection.klass
+      assoc_klass_name = assoc_klass.name
+
+      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: PENDING:
+        # if opts_c.instantiate_if_assoc_scope_with_arity
+        #   association_parser_belongs_to_instantiation(parent_class, query, query_ids, association_name, type)
+        #   return
+        # 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.
+        assoc_scope = parent_class.reflect_on_association(association_name).scope
+        assoc_query = assoc_query.instance_exec(&assoc_scope)
+      end
+
+      specified_primary_key = reflection.options[:primary_key] || 'id'
+      specified_foreign_key = reflection.options[:foreign_key] || "#{association_name}_id"
+
+      # Check to see if foreign_key exists in our parent table
+      unless parent_class.column_names.include?(specified_foreign_key)
+        report_error(
+          "
+          For #{parent_class.name}'s association '#{association_name}': Could not determine the assoc's foreign key.
+          Foreign key should have been '#{specified_foreign_key}', but did not exist on the #{parent_class.table_name} table.
+          "
+        )
+        return
+      end
+
+      assoc_query = read_from_db do
+        assoc_query.where(
+          specified_primary_key.to_sym => query.pluck(specified_foreign_key)
+        )
+      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 == :restricted
+        if traverse_restricted_dependency?(parent_class, reflection, assoc_query)
+          deletion_query_parser(assoc_query, parent_class)
+        end
+      else
+        raise "invalid parsing type: #{type}"
+      end
+    end
+
+    # So you've decided to attempt instantiation...
+    # This will be a lot slower than the rest of our logic here, but if needs must.
+    #
+    # This method will replicate association_parser, but instantiate and iterate in batches
+    def association_parser_belongs_to_instantiation(parent_class, query, query_ids, association_name, type)
+      # pending
+    end
+
+    # In this case, it's like a `belongs_to :polymorphicable, polymorphic: true, dependent: :destroy` use-case
+    # - it's unusual, but valid use-case
+    def association_parser_belongs_to_polymorphic(parent_class, query, query_ids, association_name, type)
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+
+      # 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?
+        raise 'PENDING'
+      elsif reflection.scope
+        # I saw this used somewhere, too bad I didn't save the source for it.
+        assoc_scope = parent_class.reflect_on_association(association_name).scope
+        assoc_query = assoc_query.instance_exec(&assoc_scope)
+      end
+
+      specified_primary_key = reflection.options[:primary_key] || 'id'
+      specified_foreign_key = reflection.options[:foreign_key] || "#{association_name}_id"
+      specified_foreign_type = specified_foreign_key.sub(/_id$/, '_type')
+
+      # Check to see if foreign_key exists in our parent table
+      unless parent_class.column_names.include?(specified_foreign_key)
+        report_error(
+          "
+          For #{parent_class.name}'s association '#{association_name}': Could not determine the class's foreign key.
+          Foreign key should have been '#{specified_foreign_key}', but did not exist on the #{parent_class.table_name} table.
+          "
+        )
+        return
+      end
+      unless parent_class.column_names.include?(specified_foreign_type)
+        report_error(
+          "
+          For #{parent_class.name}'s association '#{association_name}': Could not determine the class's polymorphic type.
+          Foreign key should have been '#{specified_foreign_type}', but did not exist on the #{parent_class.table_name} table.
+          "
+        )
+        return
+      end
+
+      foreign_ids_by_type = read_from_db do
+        query.pluck(specified_foreign_key, specified_foreign_type).each_with_object({}) do |(id, type), hash|
+          hash.key?(type) ? hash[type] << id : hash[type] = [id]
+        end
+      end
+
+      if type == :delete
+        # Recursively call 'deletion_query_parser' on association query, to delete any if the assoc's dependencies
+        foreign_ids_by_type.each do |type, ids|
+          assoc_klass = type.constantize
+          deletion_query_parser(assoc_klass.where(id: ids), assoc_klass)
+        end
+      elsif type == :restricted
+        if traverse_restricted_dependency_for_belongs_to_poly?(parent_class, reflection, foreign_ids_by_type)
+          # Recursively call 'deletion_query_parser' on association query, to delete any if the assoc's dependencies
+          foreign_ids_by_type.each do |type, ids|
+            assoc_klass = type.constantize
+            deletion_query_parser(assoc_klass.where(id: ids), assoc_klass)
+          end
+        end
+      else
+        raise "invalid parsing type: #{type}"
+      end
+    end
 
     # 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
@@ -334,6 +572,43 @@ module BulkDependencyEraser
       end
     end
 
+    # return [Boolean]
+    # - true if valid
+    # - false if not valid
+    def traverse_restricted_dependency? parent_class, reflection, association_query
+      # Return true if we're going to destroy all restricted
+      return true if opts_c.force_destroy_restricted
+
+      if association_query.any?
+        report_error(
+          "
+            #{parent_class.name}'s assoc '#{reflection.name}' has a restricted dependency type.
+            If you still wish to destroy, use the 'force_destroy_restricted: true' option
+          "
+        )
+      end
+
+      return false
+    end
+
+    # special use-case to detect restricted dependency for 'belongs_to polymorphic: true' use-case
+    def traverse_restricted_dependency_for_belongs_to_poly? parent_class, reflection, ids_by_type
+      # Return true if we're going to destroy all restricted
+      return true if opts_c.force_destroy_restricted
+
+      ids = ids_by_type.values.flatten
+      if ids.any?
+        report_error(
+          "
+            #{parent_class.name}'s assoc '#{reflection.name}' has a restricted dependency type.
+            If you still wish to destroy, use the 'force_destroy_restricted: true' option
+          "
+        )
+      end
+
+      return false
+    end
+
     def read_from_db(&block)
       puts "Reading from DB..." if opts_c.verbose
       opts_c.db_read_wrapper.call(block)

data/lib/bulk_dependency_eraser/deleter.rb

@@ -44,8 +44,8 @@ module BulkDependencyEraser
               end
             end
           end
-        rescue Exception => e
-          report_error("Issue attempting to delete '#{current_class_name}': #{e.name} - #{e.message}")
+        rescue StandardError => e
+          report_error("Issue attempting to delete '#{current_class_name}': #{e.class.name} - #{e.message}")
           raise ActiveRecord::Rollback
         end
       end

data/lib/bulk_dependency_eraser/manager.rb

@@ -24,8 +24,7 @@ module BulkDependencyEraser
         return false unless build
       end
 
-      delete!
-      nullify!
+      nullify! && delete!
 
       return errors.none?
     end

data/lib/bulk_dependency_eraser/nullifier.rb

@@ -2,7 +2,11 @@ module BulkDependencyEraser
   class Nullifier < Base
     DEFAULT_OPTS = {
       verbose: false,
-      db_nullify_wrapper: self::DEFAULT_DB_WRAPPER
+      db_nullify_wrapper: self::DEFAULT_DB_WRAPPER,
+      # Set to true if you want 'ActiveRecord::InvalidForeignKey' errors raised during nullifications
+      # - I can't think of a use-case where a nullification would generate an invalid key error
+      # - Not hurting anything to leave it in, but might remove it in the future.
+      enable_invalid_foreign_key_detection: false
     }.freeze
 
     DEFAULT_DB_WRAPPER = ->(block) do
@@ -22,6 +26,53 @@ module BulkDependencyEraser
     def initialize class_names_columns_and_ids:, opts: {}
       @class_names_columns_and_ids = class_names_columns_and_ids
       super(opts:)
+
+      if opts_c.verbose
+        puts "Combining nullification column groups (if groupable)"
+        puts "Before Combination: #{@class_names_columns_and_ids}"
+      end
+
+      @class_names_columns_and_ids = combine_matching_columns(@class_names_columns_and_ids)
+
+      if opts_c.verbose
+        puts "After Combination: #{@class_names_columns_and_ids}"
+      end
+    end
+
+    # Combine columns if the IDs are the same
+    # - will do one SQL call instead of several
+    def combine_matching_columns(nullification_hash)
+      return {} if nullification_hash.none?
+
+      merged_hash = {}
+
+      nullification_hash.each do |klass_name, columns_and_ids|
+        merged_hash[klass_name] = {}
+        columns_and_ids.each do |key, array|
+          sorted_array = array.sort
+
+          # Find any existing key in merged_hash that has the same sorted array
+          matching_key = merged_hash[klass_name].keys.find { |k| merged_hash[klass_name][k].sort == sorted_array }
+
+          if matching_key
+            # Concatenate the matching keys and update the hash
+            new_key = key.is_a?(Array) ? key : [key]
+            if matching_key.is_a?(Array)
+              new_key += matching_key
+            else
+              new_key << matching_key
+            end
+
+            merged_hash[klass_name][new_key] = sorted_array
+            merged_hash[klass_name].delete(matching_key)
+          else
+            # Otherwise, just add the current key-value pair
+            merged_hash[klass_name][key] = sorted_array
+          end
+        end
+      end
+
+      merged_hash
     end
 
     def execute
@@ -34,21 +85,25 @@ module BulkDependencyEraser
             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)
+
+              if opts_c.enable_invalid_foreign_key_detection
+                # nullify with referential integrity
+                nullify_by_klass_column_and_ids(klass, column, ids)
+              else
+                # nullify without referential integrity
+                # 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_by_klass_column_and_ids(klass, column, ids)
                 end
               end
             end
           end
-        rescue Exception => e
-          report_error("Issue attempting to nullify '#{current_class_name}' column '#{current_column}': #{e.name} - #{e.message}")
+        rescue StandardError => e
+          report_error("Issue attempting to nullify '#{current_class_name}' column '#{current_column}': #{e.class.name} - #{e.message}")
           raise ActiveRecord::Rollback
         end
       end
@@ -60,6 +115,23 @@ module BulkDependencyEraser
 
     attr_reader :class_names_columns_and_ids
 
+    def nullify_by_klass_column_and_ids klass, columns, ids
+      nullify_columns = {}
+
+      # supporting nullification of groups of columns simultaneously
+      if columns.is_a?(Array)
+        columns.each do |column|
+          nullify_columns[column] = nil
+        end
+      else
+        nullify_columns[columns] = nil
+      end
+
+      nullify_in_db do
+        klass.unscoped.where(id: ids).update_all(nullify_columns)
+      end
+    end
+
     def nullify_in_db(&block)
       puts "Nullifying from DB..." if opts_c.verbose
       opts_c.db_nullify_wrapper.call(block)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bulk_dependency_eraser
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.0.4
 platform: ruby
 authors:
 - benjamin.dana.software.dev@gmail.com
@@ -108,6 +108,34 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '1.4'
+- !ruby/object:Gem::Dependency
+  name: factory_bot
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '6.4'
+- !ruby/object:Gem::Dependency
+  name: faker
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
 description:
 email:
 executables: []
@@ -123,7 +151,8 @@ files:
 homepage: https://github.com/danabr75/bulk_dependency_eraser
 licenses:
 - LGPL-3.0-only
-metadata: {}
+metadata:
+  source_code_uri: https://github.com/danabr75/bulk_dependency_eraser
 post_install_message:
 rdoc_options: []
 require_paths: