bulk_dependency_eraser 2.1.0 → 2.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4bda32570c3319238a5ea03f6a71cbae1e20015caf5fe7bdba78cab3c7883a7
-  data.tar.gz: 9e371750cd1a05b54bfe724873daaf2c7e9aa66942f168d6417505a1427d46c1
+  metadata.gz: 73ac2c6209f874175a8a1208c184a3fdaa73f2020a411f2f41bd069668b63fbc
+  data.tar.gz: 86df357905f75f34337d30446cfc6b34b9aa55fc1947d17a008329379f2beae7
 SHA512:
-  metadata.gz: 33130d09c651a9757af826cbbd5e1363a8f136a3d6e3bf1e2a128dad776185b544fd75a493013cd28d279690094e90cc3dc0f3b23597704df9842eb80e215808
-  data.tar.gz: 27f4e6014155961a1286f2d1f490a7ca2709fd2b9594a7c8ab3fb3164c26bbdf99e8609c5494e15e8595b0db9eee94d485a20a772f5a37d58554b497eaee5154
+  metadata.gz: 69fd26f7fcbd04f158adf4bc038181818136f17d878bad544bb888b1d0f547d557153204876a91b222154f7154d0f38b143f4db08f5081242c107488832fa682
+  data.tar.gz: b31893d532b1be190f5288ddfb495008615a3c54f2e5a9fb12344a733c4322345911597822c835277f9f4632657aeefe4ee7a77fe7eecea16cf64151dd63a797

data/lib/bulk_dependency_eraser/base.rb

@@ -1,5 +1,11 @@
+require_relative 'utils'
+
 module BulkDependencyEraser
   class Base
+    POLY_KLASS_NAME = "<POLY>"
+    include BulkDependencyEraser::Utils
+    extend BulkDependencyEraser::Utils
+
     # Default Custom Scope for all classes, no effect.
     DEFAULT_SCOPE_WRAPPER = ->(query) { nil }
     # Default Custom Scope for mapped-by-name classes, no effect.
@@ -39,6 +45,32 @@ module BulkDependencyEraser
       proc_scopes_per_class_name: {},
     }.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 :errors
 
     def initialize opts: {}
@@ -53,8 +85,44 @@ module BulkDependencyEraser
       raise NotImplementedError
     end
 
+    def report_error 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
+      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
+
     protected
 
+    def constantize(klass_name)
+      # circular dependencies have suffixes, shave them off
+      klass_name.sub(/\.\d+$/, '').constantize
+    end
+
+    # A dependent assoc may be through another association. Follow the throughs to find the correct assoc to destroy.
+    # @return [Symbol] - association's name
+    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 custom_scope_for_query(query)
       klass = query.klass
       if opts_c.proc_scopes_per_class_name.key?(klass.name)
@@ -79,25 +147,6 @@ module BulkDependencyEraser
       ).freeze
     end
 
-    def report_error 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
-      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

data/lib/bulk_dependency_eraser/builder.rb

@@ -34,35 +34,12 @@ module BulkDependencyEraser
       reading_proc_scopes_per_class_name: {},
     }.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
-
     # write access so that these can be edited in-place by end-users who might need to manually adjust deletion order.
     attr_accessor :deletion_list, :nullification_list
     attr_reader :ignore_table_deletion_list, :ignore_table_nullification_list
+    attr_reader :query_schema_parser
+
+    delegate :circular_dependency_klasses, :flat_dependencies_per_klass, to: :query_schema_parser
 
     def initialize query:, opts: {}
       @query = query
@@ -79,9 +56,15 @@ module BulkDependencyEraser
 
       @ignore_table_name_and_dependencies = opts_c.ignore_tables_and_dependencies.collect { |table_name| table_name }
       @ignore_klass_name_and_dependencies = opts_c.ignore_klass_names_and_dependencies.collect { |klass_name| klass_name }
+      @query_schema_parser = BulkDependencyEraser::QuerySchemaParser.new(query:, opts:)
     end
 
     def execute
+      unless query_schema_parser.execute
+        merge_errors(full_schema_parser.errors, 'QuerySchemaParser: ')
+        return false
+      end
+
       # go through deletion/nullification lists and remove any tables from 'ignore_tables' option
       build_result = build
 
@@ -89,8 +72,9 @@ module BulkDependencyEraser
       # - prior approach was to use table_name.classify, but we can't trust that approach.
       opts_c.ignore_tables.each do |table_name|
         table_names_to_parsed_klass_names.dig(table_name)&.each do |klass_name|
-          ignore_table_deletion_list[klass_name]      = deletion_list.delete(klass_name)      if deletion_list.key?(klass_name)
-          ignore_table_nullification_list[klass_name] = nullification_list.delete(klass_name) if nullification_list.key?(klass_name)
+          klass_index = deletion_index_key(klass_name.constantize)
+          ignore_table_deletion_list[klass_index]      = deletion_list.delete(klass_index)      if deletion_list.key?(klass_index)
+          ignore_table_nullification_list[klass_index] = nullification_list.delete(klass_index) if nullification_list.key?(klass_index)
         end
       end
 
@@ -111,15 +95,13 @@ module BulkDependencyEraser
       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}':
+            Error Encountered in 'execute' for '#{klass.name}':
               #{e.class.name}
               #{e.message}
           "
@@ -190,17 +172,15 @@ module BulkDependencyEraser
 
       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
 
       table_names_to_parsed_klass_names[klass.table_name] ||= []
       # Need to populate this list here, so we can have access to it later for the :ignore_tables option
-      unless table_names_to_parsed_klass_names[klass.table_name].include?(klass_name)
-        table_names_to_parsed_klass_names[klass.table_name] << klass_name
+      unless table_names_to_parsed_klass_names[klass.table_name].include?(klass.name)
+        table_names_to_parsed_klass_names[klass.table_name] << klass.name
       end
 
       if ignore_table_name_and_dependencies.include?(klass.table_name)
@@ -208,22 +188,22 @@ module BulkDependencyEraser
         return
       end
 
-      if ignore_klass_name_and_dependencies.include?(klass_name)
+      if ignore_klass_name_and_dependencies.include?(klass.name)
         # Not parsing, table and dependencies ignorable
         return
       end
 
       if opts_c.verbose
         if association_parent
-          puts "Building #{association_parent}, association of #{klass_name}"
+          puts "Building #{association_parent}, association of #{klass.name}"
         else
-          puts "Building #{klass_name}"
+          puts "Building #{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."
+          "#{klass.name} - does not use primary_key 'id'. Cannot use this tool to bulk delete."
         )
         return
       end
@@ -231,26 +211,22 @@ module BulkDependencyEraser
       # Pluck IDs of the current query
       query_ids = pluck_from_query(query)
 
-      deletion_list[klass_name] ||= []
+      klass_index = initialize_deletion_list_for_klass(klass)
 
       # prevent infinite recursion here.
       # - Remove any IDs that have been processed before
-      query_ids = query_ids - deletion_list[klass_name]
+      query_ids = remove_already_deletion_processed_ids(klass, query_ids)
 
       # 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(klass_name) if deletion_list[klass_name].none?
+        deletion_list.delete(klass_index) if deletion_list[klass_index].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[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[klass_name].sort! if Rails.env.test?
+      deletion_list[klass_index] += query_ids
 
       # ignore associations that aren't a dependent destroyable type
       destroy_associations = query.reflect_on_all_associations.select do |reflection|
@@ -446,15 +422,12 @@ module BulkDependencyEraser
         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}"
@@ -659,17 +632,6 @@ module BulkDependencyEraser
       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
-      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
-
     # return [Boolean]
     # - true if valid
     # - false if not valid
@@ -711,5 +673,71 @@ module BulkDependencyEraser
       puts "Reading from DB..." if opts_c.verbose
       opts_c.db_read_wrapper.call(block)
     end
+
+    def remove_already_deletion_processed_ids(klass, new_ids)
+      already_processed_ids = []
+
+      if is_a_circular_dependency_klass?(klass)
+        klass_keys = find_circular_dependency_deletion_keys(klass)
+        klass_keys.each do |circular_class_key|
+          already_processed_ids += deletion_list[circular_class_key]
+        end
+      else
+        already_processed_ids = deletion_list[klass.name]
+      end
+
+      new_ids - already_processed_ids
+    end
+
+    # Initializes deletion_list index
+    # - increments the index for circular dependencies
+    def initialize_deletion_list_for_klass(klass)
+      klass_index = deletion_index_key(klass, increment_circular_index: true)
+
+      if is_a_circular_dependency_klass?(klass)
+        raise "circular_index already existed for klass: #{klass.name}" if deletion_list.key?(klass_index)
+
+        deletion_list[klass_index] = []
+      else
+        # Not a circular dependency, define as normal
+        deletion_list[klass_index] ||= []
+      end
+
+      klass_index
+    end
+
+    def is_a_circular_dependency_klass?(klass)
+      circular_dependency_klasses.values.flatten.include?(klass.name)
+    end
+
+    def find_circular_dependency_deletion_keys(klass)
+      escaped_prefix = Regexp.escape(klass.name)
+      # Define the key-matching regex: klass.name + '.' + <integer>
+      regex = /^#{escaped_prefix}\.\d+$/
+      # find the latest, indexed klass initialization
+      deletion_list.keys.select { |key| key.match?(regex) }
+    end
+
+    # If circular dependency, append a index suffix to the deletion hash key
+    # - they will be deleted in highest index to lowest index order.
+    def deletion_index_key(klass, increment_circular_index: false)
+      if is_a_circular_dependency_klass?(klass)
+        klass_keys = find_circular_dependency_deletion_keys(klass)
+        if klass_keys.none?
+          klass_index = "#{klass.name}.0" # first one, no need to consider increment
+        else
+          # Use map to extract the integers using a regular expression
+          circular_indexes = klass_keys.map { |s| s[/\.(\d+)$/, 1].to_i }
+          # Find the maximum value
+          current_circular_index = circular_indexes.max
+          current_circular_index += 1 if increment_circular_index
+          klass_index = "#{klass.name}.#{current_circular_index}"
+        end
+      else
+        klass_index = klass.name
+      end
+
+      return klass_index
+    end
   end
 end

data/lib/bulk_dependency_eraser/deleter.rb

@@ -1,6 +1,6 @@
 module BulkDependencyEraser
   class Deleter < Base
-    DEFAULT_DB_DELETE_ALL_WRAPPER = ->(block) do
+    DEFAULT_DB_DELETE_ALL_WRAPPER = ->(deleter, block) do
       begin
         block.call
       rescue StandardError => e
@@ -63,7 +63,7 @@ module BulkDependencyEraser
         class_names_and_ids.keys.reverse.each do |class_name|
           current_class_name = class_name
           ids = class_names_and_ids[class_name].reverse
-          klass = class_name.constantize
+          klass = constantize(class_name)
 
           if opts_c.enable_invalid_foreign_key_detection
             # delete with referential integrity
@@ -140,7 +140,7 @@ module BulkDependencyEraser
 
     def delete_all_in_db(&block)
       puts "Deleting all from DB..." if opts_c.verbose
-      opts_c.db_delete_all_wrapper.call(block)
+      opts_c.db_delete_all_wrapper.call(self, block)
       puts "Deleting all from DB complete." if opts_c.verbose
     end
   end

data/lib/bulk_dependency_eraser/full_schema_parser.rb

@@ -0,0 +1,179 @@
+module BulkDependencyEraser
+  # Create a flat map hash for each class that lists every dependency.
+  class FullSchemaParser < Base
+    DEFAULT_OPTS = {
+      verbose: false,
+    }
+
+    attr_reader :flat_dependencies_per_klass
+
+    @cached_flat_dependencies_per_klass = nil
+    def self.reset_cache
+      @cached_flat_dependencies_per_klass = nil
+    end
+    def self.set_cache(value)
+      @cached_flat_dependencies_per_klass = value.freeze
+    end
+    def self.get_cache
+      @cached_flat_dependencies_per_klass
+    end
+
+    def initialize(opts: {})
+      # @flat_dependencies_per_klass Structure
+      # {
+      #   <class_name> => {
+      #     has_dependencies: <Boolean>,
+      #     foreign_keys: {
+      #       <column_name>: <association_class_name>,
+      #       ...
+      #     },
+      #     nullify_dependencies: {
+      #       <association_name>: <association_class_name>,
+      #       ...
+      #     },
+      #     destroy_dependencies: {
+      #       <association_name>: <association_class_name>,
+      #       ...
+      #     }
+      #   }
+      # }
+      @flat_dependencies_per_klass = {}
+      super(opts:)
+    end
+
+    def execute
+      unless self.class.get_cache.nil?
+        @flat_dependencies_per_klass = self.class.get_cache
+        return true
+      end
+
+      Rails.application.eager_load!
+
+      ActiveRecord::Base.descendants.each do |model|
+        begin
+          next if model.abstract_class? # Skip abstract classes like ApplicationRecord
+          next unless model.connection.table_exists?(model.table_name)
+        rescue Exception => e
+          report_error("EXECPTION ON #{model.name}; #{e.class}: #{e.message}")
+          next
+        end
+
+        flat_dependencies_parser(model)
+      end
+
+      deep_freeze(@flat_dependencies_per_klass)
+      self.class.set_cache(@flat_dependencies_per_klass)
+
+      return true
+    end
+
+    def reset
+      @flat_dependencies_per_klass = {}
+      self.class.reset_cache
+    end
+
+    protected
+
+    # @param klass [ActiveRecord::Base]
+    # @param dependency_path [Array<ActiveRecord::Base>] - previously parsed klasses
+    def flat_dependencies_parser klass
+      raise "invalid klass: #{klass}" unless klass < ActiveRecord::Base
+
+      if flat_dependencies_per_klass.include?(klass.name)
+        raise "@dependencies_per_klass already contains #{klass.name}"
+      end
+
+      @flat_dependencies_per_klass[klass.name] ||= {
+        nullify_dependencies: {},
+        destroy_dependencies: {},
+        has_many: {},
+        belongs_to: {},
+      }
+
+      # We're including :restricted dependencies
+      destroy_associations = klass.reflect_on_all_associations.select do |reflection|
+        dependency_type = reflection.options&.dig(:dependent)
+        dependency_type.to_sym if dependency_type.is_a?(String)
+        DEPENDENCY_DESTROY.include?(dependency_type)
+      end
+
+      nullify_associations = klass.reflect_on_all_associations.select do |reflection|
+        dependency_type = reflection.options&.dig(:dependent)
+        dependency_type.to_sym if dependency_type.is_a?(String)
+        DEPENDENCY_NULLIFY.include?(dependency_type)
+      end
+
+      # 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_associations.map(&:name).collect do |assoc_name|
+        find_root_association_from_through_assocs(klass, assoc_name)
+      end
+      nullify_association_names = nullify_associations.map(&:name).collect do |assoc_name|
+        find_root_association_from_through_assocs(klass, assoc_name)
+      end
+
+      destroy_association_names.uniq.each do |association_name|
+        add_deletion_dependency_to_flat_map(klass, association_name)
+      end
+
+      nullify_association_names.uniq.each do |association_name|
+        add_nullification_dependency_to_flat_map(klass, association_name)
+      end
+
+      # add has_many relationships
+      (
+        klass.reflect_on_all_associations(:has_many) + 
+        klass.reflect_on_all_associations(:has_one) + 
+        klass.reflect_on_all_associations(:has_and_belongs_to_many)
+      ).each do |reflection|
+        next if reflection.options[:through].present?
+
+        add_has_many_to_flat_map(klass, reflection)
+      end
+
+      # add belongs_to relationships
+      klass.reflect_on_all_associations(:belongs_to).each do |reflection|
+        next if reflection.options[:through].present?
+
+        add_belongs_to_to_flat_map(klass, reflection)
+      end
+    end
+
+    # @param klass [ActiveRecord::Base]
+    # @param association_name [Symbol] - name of the association
+    def add_has_many_to_flat_map(klass, reflection)
+      association_name = reflection.name
+      @flat_dependencies_per_klass[klass.name][:has_many][association_name] = reflection.klass.name
+    end
+
+    # @param klass [ActiveRecord::Base]
+    # @param association_name [Symbol] - name of the association
+    def add_belongs_to_to_flat_map(klass, reflection)
+      association_name = reflection.name
+      reflection_klass_name = is_reflection_polymorphic?(reflection) ? POLY_KLASS_NAME : reflection.klass.name
+      @flat_dependencies_per_klass[klass.name][:belongs_to][association_name] = reflection_klass_name
+    end
+
+    # @param klass [ActiveRecord::Base]
+    # @param association_name [Symbol] - name of the association
+    def add_deletion_dependency_to_flat_map(klass, association_name)
+      reflection = klass.reflect_on_association(association_name)
+      reflection_klass_name = is_reflection_polymorphic?(reflection) ? POLY_KLASS_NAME : reflection.klass.name
+      @flat_dependencies_per_klass[klass.name][:destroy_dependencies][association_name] = reflection_klass_name
+    end
+
+    # @param klass [ActiveRecord::Base]
+    # @param association_name [Symbol] - name of the association
+    def add_nullification_dependency_to_flat_map(klass, association_name)
+      reflection = klass.reflect_on_association(association_name)
+      # nullifications can't be poly klass
+      @flat_dependencies_per_klass[klass.name][:nullify_dependencies][association_name] = reflection.klass.name
+    end
+
+    # @param reflection [ActiveRecord::Reflection::AssociationReflection]
+    def is_reflection_polymorphic?(reflection)
+      reflection.options&.dig(:polymorphic) == true
+    end
+  end
+end

data/lib/bulk_dependency_eraser/manager.rb

@@ -9,6 +9,7 @@ module BulkDependencyEraser
 
     delegate :nullification_list, :deletion_list, to: :dependency_builder
     delegate :ignore_table_deletion_list, :ignore_table_nullification_list, to: :dependency_builder
+    delegate :circular_dependency_klasses, :flat_dependencies_per_klass, to: :dependency_builder
 
     # @param query [ActiveRecord::Base | ActiveRecord::Relation]
     def initialize query:, opts: {}

data/lib/bulk_dependency_eraser/nullifier.rb

@@ -1,10 +1,10 @@
 module BulkDependencyEraser
   class Nullifier < Base
-    DEFAULT_DB_NULLIFY_ALL_WRAPPER = lambda do |block|
+    DEFAULT_DB_NULLIFY_ALL_WRAPPER = ->(nullifier, block) do
       begin
         block.call
       rescue StandardError => e
-        report_error("Issue attempting to nullify '#{current_class_name}' column '#{current_column}': #{e.class.name} - #{e.message}")
+        nullifier.report_error("Issue attempting to nullify: #{e.class.name} - #{e.message}")
       end
     end
 
@@ -211,7 +211,7 @@ module BulkDependencyEraser
 
     def nullify_all_in_db(&block)
       puts "Nullifying all from DB..." if opts_c.verbose
-      opts_c.db_nullify_all_wrapper.call(block)
+      opts_c.db_nullify_all_wrapper.call(self, block)
       puts "Nullifying all from DB complete." if opts_c.verbose
     end
 

data/lib/bulk_dependency_eraser/query_schema_parser.rb

@@ -0,0 +1,281 @@
+module BulkDependencyEraser
+  class QuerySchemaParser < Base
+    DEFAULT_OPTS = {
+      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,
+      force_destroy_restricted: false,
+    }
+
+    # attr_accessor :deletion_list, :nullification_list
+    attr_reader :initial_class
+    attr_reader :dependencies_per_klass
+    attr_reader :circular_dependency_klasses
+    attr_reader :full_schema_parser
+
+    delegate :flat_dependencies_per_klass, to: :full_schema_parser
+
+    def initialize query:, opts: {}
+      if query.is_a?(ActiveRecord::Relation)
+        @initial_class      = query.klass
+      else
+        # current_query is a normal rails class
+        @initial_class      = query
+      end
+      # @dependencies_per_klass Structure
+      # {
+      #   <ActiveRecord::Base> => {
+      #     <ActiveRecord::Reflection::AssociationReflection> => <ActiveRecord::Base> 
+      #   }
+      # }
+      @dependencies_per_klass = {}
+      # @circular_dependency_klasses Structure
+      # {
+      #   <ActiveRecord::Base> => [
+      #     # Path of dependencies that start and end with the key class
+      #     <ActiveRecord::Base>,
+      #     <ActiveRecord::Base>,
+      #     <ActiveRecord::Base>,
+      #   ]
+      # }
+      @circular_dependency_klasses = {}
+      @full_schema_parser = BulkDependencyEraser::FullSchemaParser.new(opts:)
+      super(opts:)
+    end
+
+    def execute
+      unless full_schema_parser.execute
+        merge_errors(full_schema_parser.errors, 'FullSchemaParser: ')
+        return false
+      end
+      klass_dependencies_parser(initial_class, klass_action: :destroy)
+
+      @dependencies_per_klass.each do |key, values|
+        @dependencies_per_klass[key] = values.uniq
+      end
+
+      return true
+    end
+
+    # @param klass [ActiveRecord::Base, Array<ActiveRecord::Base>]
+    # - if was a dependency from a polymophic class, then iterate through the klasses.
+    # @param dependency_path [Array<ActiveRecord::Base>] - previously parsed klasses
+    def klass_dependencies_parser klass, klass_action:, dependency_path: []
+      if klass.is_a?(Array)
+        klass.each do |klass_subset|
+          klass_dependencies_parser(klass_subset, klass_action:, dependency_path:)
+        end
+        return
+      end
+
+      unless DEPENDENCY_DESTROY.include?(klass_action) || DEPENDENCY_NULLIFY.include?(klass_action)
+        raise "invalid klass action: #{klass_action}"
+      end
+      raise "invalid klass: #{klass}" unless klass < ActiveRecord::Base
+
+      # Not a circular dependency if the repetitious klass has a nullify action.
+      if DEPENDENCY_DESTROY.include?(klass_action) && dependency_path.include?(klass.name)
+        index = dependency_path.index(klass.name)
+        circular_dependency = dependency_path[index..] + [klass.name]
+        circular_dependency_klasses[klass.name] = circular_dependency
+        return
+      end
+
+      # We don't need to consider dependencies for a klass that is being nullified.
+      return if DEPENDENCY_NULLIFY.include?(klass_action)
+
+      # already parsed, doesn't need to be parsed again.
+      return if dependencies_per_klass.include?(klass.name)
+
+      @dependencies_per_klass[klass.name] = []
+
+      # We're including :restricted dependencies
+      destroy_associations = klass.reflect_on_all_associations.select do |reflection|
+        dependency_type = reflection.options&.dig(:dependent)&.to_sym
+        DEPENDENCY_DESTROY.include?(dependency_type)
+      end
+
+      nullify_associations = klass.reflect_on_all_associations.select do |reflection|
+        dependency_type = reflection.options&.dig(:dependent)&.to_sym
+        DEPENDENCY_NULLIFY.include?(dependency_type)
+      end
+
+      # 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)
+      association_dependencies = {}
+      (
+        destroy_associations.map(&:name) +
+        nullify_associations.map(&:name)
+      ).collect do |assoc_name|
+        root_association_name = find_root_association_from_through_assocs(klass, assoc_name)
+        association_dependencies[root_association_name] = klass.reflect_on_association(assoc_name).options.dig(:dependent)
+      end
+
+      # Using association names as keys helps remove duplicates - from dependent options on through associations and root associations.
+      association_dependencies.each do |association_name, dependency_type|
+        association_parser(klass, association_name, dependency_type, dependency_path)
+      end
+    end
+
+    # Used to iterate through each destroyable association, and recursively call 'deletion_query_parser'.
+    # @param parent_class     [ApplicationRecord]
+    # @param association_name [Symbol]                - The association name from the parent_class
+    def association_parser(parent_class, association_name, dependency_type, dependency_path)
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+
+      raise "No dependency set for #{parent_class} and it's association: #{association_name}" unless dependency_type
+
+      case reflection_type
+      when 'ActiveRecord::Reflection::HasManyReflection'
+        association_parser_has_many(parent_class, association_name, dependency_type, dependency_path)
+      when 'ActiveRecord::Reflection::HasOneReflection'
+        association_parser_has_many(parent_class, association_name, dependency_type, dependency_path)
+      when 'ActiveRecord::Reflection::BelongsToReflection'
+        association_parser_belongs_to(parent_class, association_name, dependency_type, dependency_path)
+      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, association_name, dependency_type, dependency_path)
+      raise "parent_class missing" unless parent_class
+      raise "#{parent_class} - association_name: missing" unless association_name
+      raise "#{parent_class} - dependency_type: missing"  unless dependency_type
+      raise "#{parent_class} - dependency_path: nil"      if dependency_path.nil?
+
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+
+      assoc_klass = reflection.klass
+      assoc_klass_name = assoc_klass.name
+      @dependencies_per_klass[parent_class.name] << assoc_klass.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? && opts_c.instantiate_if_assoc_scope_with_arity == false
+        report_error(
+          "#{parent_class.name} and '#{association_name}' - scope has instance parameters. Use :instantiate_if_assoc_scope_with_arity option?"
+        )
+        return
+      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[:as]
+          specified_foreign_type = "#{reflection.options[:as]}_type"
+          specified_foreign_key = "#{reflection.options[:as]}_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 '#{assoc_klass.name}': Could not determine the assoc's foreign key.
+          Foreign key should have been '#{specified_foreign_key}', but did not exist on the #{assoc_klass.table_name} table.
+          "
+        )
+        return
+      end
+
+      unless specified_foreign_type.nil? || assoc_klass.column_names.include?(specified_foreign_type)
+        report_error(
+          "
+          For '#{assoc_klass.name}': Could not determine the assoc's foreign key type.
+          Foreign key type should have been '#{specified_foreign_type}', but did not exist on the #{assoc_klass.table_name} table.
+          "
+        )
+      end
+
+      if DEPENDENCY_RESTRICT.include?(dependency_type) && traverse_restricted_dependency?(parent_class, reflection)
+        klass_dependencies_parser(assoc_klass, klass_action: dependency_type, dependency_path: dependency_path.dup << parent_class.name)
+      else
+        klass_dependencies_parser(assoc_klass, klass_action: dependency_type, dependency_path: dependency_path.dup << parent_class.name)
+      end
+    end
+
+    def association_parser_belongs_to(parent_class, association_name, dependency_type, dependency_path)
+      raise "parent_class missing" unless parent_class
+      raise "#{parent_class} - association_name: missing" unless association_name
+      raise "#{parent_class} - dependency_type: missing"  unless dependency_type
+      raise "#{parent_class} - dependency_path: nil"      if dependency_path.nil?
+
+      reflection = parent_class.reflect_on_association(association_name)
+      reflection_type = reflection.class.name
+
+      is_polymorphic = reflection.options[:polymorphic]
+      if is_polymorphic
+        assoc_klass = find_klasses_from_polymorphic_dependency(parent_class).map(&:constantize)
+        @dependencies_per_klass[parent_class.name] += assoc_klass.map(&:name)
+      else
+        assoc_klass = reflection.klass
+        @dependencies_per_klass[parent_class.name] << assoc_klass.name
+      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
+
+      if (
+        DEPENDENCY_DESTROY.include?(dependency_type) ||
+        DEPENDENCY_NULLIFY.include?(dependency_type) && traverse_restricted_dependency?(parent_class, reflection)
+      )
+        klass_dependencies_parser(assoc_klass, klass_action: dependency_type, dependency_path: dependency_path.dup << parent_class.name)
+      end
+    end
+
+    # In this example the klass would be the polymorphic klass
+    # - i.e. Attachment belongs_to: :attachable, dependent: :destroy
+    # We're looking for klasses in the flat map that have a has_many :attachments, as: :attachable
+    def find_klasses_from_polymorphic_dependency(klass)
+      found_klasses = []
+      flat_dependencies_per_klass.each do |flat_klass_name, klass_dependencies|
+        if klass_dependencies[:has_many].values.include?(klass.name)
+          found_klasses << flat_klass_name
+        end
+      end
+      found_klasses
+    end
+
+    # return [Boolean]
+    # - true if valid
+    # - false if not valid
+    def traverse_restricted_dependency? parent_class, reflection
+      # Return true if we're going to destroy all restricted
+      return true if opts_c.force_destroy_restricted
+
+      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
+        "
+      )
+
+      return false
+    end
+
+  end
+end

data/lib/bulk_dependency_eraser/utils.rb

@@ -0,0 +1,25 @@
+module BulkDependencyEraser
+  module Utils
+    module Methods
+      # To freeze all nested structures including hashes, arrays, and strings
+      # Deep Freezing All Structures
+      def deep_freeze(obj)
+        case obj
+        when Hash
+          obj.each { |key, value| deep_freeze(key); deep_freeze(value) }
+          obj.freeze
+        when Array
+          obj.each { |value| deep_freeze(value) }
+          obj.freeze
+        when String
+          obj.freeze
+        else
+          obj.freeze if obj.respond_to?(:freeze)
+        end
+      end
+    end
+
+    include Methods
+    extend Methods
+  end
+end

data/lib/bulk_dependency_eraser/version.rb

@@ -1,3 +1,3 @@
 module BulkDependencyEraser
-  VERSION = "2.1.0".freeze
+  VERSION = "2.2.0".freeze
 end

data/lib/bulk_dependency_eraser.rb

@@ -1,6 +1,9 @@
 require_relative 'bulk_dependency_eraser/base'
 require_relative 'bulk_dependency_eraser/builder'
 require_relative 'bulk_dependency_eraser/deleter'
+require_relative 'bulk_dependency_eraser/full_schema_parser'
 require_relative 'bulk_dependency_eraser/nullifier'
+require_relative 'bulk_dependency_eraser/query_schema_parser'
 require_relative 'bulk_dependency_eraser/manager'
+require_relative 'bulk_dependency_eraser/utils'
 require_relative 'bulk_dependency_eraser/version'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bulk_dependency_eraser
 version: !ruby/object:Gem::Version
-  version: 2.1.0
+  version: 2.2.0
 platform: ruby
 authors:
 - benjamin.dana.software.dev@gmail.com
@@ -146,8 +146,11 @@ files:
 - lib/bulk_dependency_eraser/base.rb
 - lib/bulk_dependency_eraser/builder.rb
 - lib/bulk_dependency_eraser/deleter.rb
+- lib/bulk_dependency_eraser/full_schema_parser.rb
 - lib/bulk_dependency_eraser/manager.rb
 - lib/bulk_dependency_eraser/nullifier.rb
+- lib/bulk_dependency_eraser/query_schema_parser.rb
+- lib/bulk_dependency_eraser/utils.rb
 - lib/bulk_dependency_eraser/version.rb
 homepage: https://github.com/danabr75/bulk_dependency_eraser
 licenses: