bulk_dependency_eraser 1.0.2 → 1.0.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 84aa6beacc6783239cb7203cb6c829b041af7829d0692182475d04e00baed0c0
-  data.tar.gz: c6dc0bb1ebc2807aad0f16db6ad4f585a58b31f64ad04b178851dead99459e8e
+  metadata.gz: dc8c21921516530d646fff41d72ce0157e1d706373eefea4da7ea924bb1cb9b9
+  data.tar.gz: 9501007142223dfad5cb05e89ab38162499b564eaaf3636074e3cd54a573592f
 SHA512:
-  metadata.gz: a557bafd9cc91f7611491607e05f5f4dbccb1d059581f2716a51da9b660656d13a490c958990faea6aa655e41fa3d0ad1ed66a70b5ff19bb6c5763f45bdae376
-  data.tar.gz: 6d170e68022d2b6fe59b96880f43dafdd52cc837734905de5ca0a65ed2b19d7f01bcce934453dafb0c73a236f0c41a53945f190e386d78f4d1077dc4b6aa6bd4
+  metadata.gz: 0f461d596eb9160828f0905dde68396ade1409f8f9c17de2e4bb8677cb12695be59c75f6fa33d84d9156a2b10fdab2eed869b7f19a79c84e1526c705ac4cf58b
+  data.tar.gz: 64777768e6eb815d575d11690cb793962ab4fcb24911bc2bb209d5d7a33d3bc660b6d939fe287ca2c41dcac8524efe95032f3b6ee76272956391589193315666

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,8 +205,15 @@ 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)
+
+      if opts_c.verbose
+        puts "Destroyable Associations: #{destroy_association_names}"
+        puts "Nullifiable Associations: #{nullify_association_names}"
+        puts " Restricted Associations: #{restricted_association_names}"
+      end
 
       # Iterate through the assoc names, if there are any :through assocs, then remap 
       destroy_association_names = destroy_association_names.collect do |assoc_name|
@@ -222,12 +230,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
+
+    # 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
 
-    # Iterate through each destroyable association, and recursively call 'deletion_query_parser'.
-    def association_parser parent_class, query, query_ids, association_name, type
+    # 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 +286,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 +297,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 +324,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 +342,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 +368,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 +567,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/nullifier.rb

@@ -47,8 +47,8 @@ module BulkDependencyEraser
               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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bulk_dependency_eraser
 version: !ruby/object:Gem::Version
-  version: 1.0.2
+  version: 1.0.3
 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: []