bulk_dependency_eraser 0.0.1 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e51d0383cb5b2111181c9dc48b499b046d225adad1d1f8b985216a0d395cb612
-  data.tar.gz: 02ce5200f03d7a4cec2cfa72b64fbfdf84e73ce5b3e6b43ba073173b48e5139b
+  metadata.gz: 3cafe34b586a54a169d2d728ba0a39d9403c90796db9f40c9050620eaa4ef156
+  data.tar.gz: a1a7001243a75db7740e2fbcbdfbf43dad5253f83de8c757bb7b2d0ab2f57763
 SHA512:
-  metadata.gz: 25857421c4e8cc6af0f952bacd106b39f19d34ac8d2292f74e9daa90c10ea07ab82e11fe584b7c0fcb60209fb1e4ba0d126e6e9102587b3d6ff6a69e495373e5
-  data.tar.gz: 68f2ec5423d953bf842de7c98ea778f44795a89cfa948b400c5171e08489446aba765467744175a5de69df6957fef1b04f0c017af7d63b1959d756caaac07a22
+  metadata.gz: 9fc46dd24138b1be6c2ff436e9afdaa4f4f877c37fe23bec00ffec8ce142ffda71c6cccefd7a5d8354986757f9df02f0c64918419d270471eea866226cce87a6
+  data.tar.gz: ecfa3aca0fdae9d2de444f8fb8427758420c8ffa7ae8370daff95b5ef975db83ec9fc573e91d83e93f84acfd11e117171a1a276b45841954526cba6c481d2b21

data/lib/bulk_dependency_eraser/builder.rb

@@ -6,7 +6,13 @@ module BulkDependencyEraser
       # 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,
+      # wraps around the DB reading
       db_read_wrapper: self::DEFAULT_DB_WRAPPER,
+      # Will parse these tables and their dependencies, but will remove the tables from the lists after parsing.
+      ignore_tables: [],
+      # Won't parse any table in this list
+      ignore_tables_and_dependencies: [],
+      ignore_klass_names_and_dependencies: [],
     }.freeze
 
     DEPENDENCY_NULLIFY = %i[
@@ -36,17 +42,44 @@ module BulkDependencyEraser
     ].freeze
 
     attr_reader :deletion_list, :nullification_list
+    attr_reader :ignore_table_deletion_list, :ignore_table_nullification_list
 
     def initialize query:, opts: {}
       @query = query
       @deletion_list  = {}
       @nullification_list = {}
+
+      # For any ignored table results, they will be stored here
+      @ignore_table_deletion_list = {}
+      @ignore_table_nullification_list = {}
+
+      @table_names_to_parsed_klass_names = {}
+
       super(opts:)
+
+      @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 }
     end
 
     def execute
+      # go through deletion/nullification lists and remove any tables from 'ignore_tables' option
+      build_result = build
+
+      # move any klass names if told to ignore them into their respective new lists
+      # - 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)
+        end
+      end
+
+      return build_result
+    end
+
+    def build
       begin
-        build_result = deletion_query_parser(@query)
+        deletion_query_parser(@query)
 
         uniqify_errors!
 
@@ -80,12 +113,26 @@ module BulkDependencyEraser
       if query.is_a?(ActiveRecord::Relation)
         klass      = query.klass
         klass_name = query.klass.name
-        table_klass_name = query.klass.table_name.classify
       else
         # current_query is a normal rails class
         klass      = query
         klass_name = query.name
-        table_klass_name = query.table_name.classify
+      end
+
+      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
+      end
+
+      if ignore_table_name_and_dependencies.include?(klass.table_name)
+        # Not parsing, table and dependencies ignorable
+        return
+      end
+
+      if ignore_klass_name_and_dependencies.include?(klass_name)
+        # Not parsing, table and dependencies ignorable
+        return
       end
 
       if opts_c.verbose
@@ -108,25 +155,25 @@ module BulkDependencyEraser
         query.pluck(:id)
       end
 
-      deletion_list[table_klass_name] ||= []
+      deletion_list[klass_name] ||= []
 
       # prevent infinite recursion here.
       # - Remove any IDs that have been processed before
-      query_ids = query_ids - deletion_list[table_klass_name]
+      query_ids = query_ids - deletion_list[klass_name]
       # If ids are nil, let's find that error
       if query_ids.none? #|| query_ids.nil?
         # quick cleanup, if turns out was an empty class
-        deletion_list.delete(table_klass_name) if deletion_list[table_klass_name].none?
+        deletion_list.delete(klass_name) if deletion_list[klass_name].none?
         return
       end
 
       # Use-case: We have more IDs to process
       # - can now safely add to the list, since we've prevented infinite recursion
-      deletion_list[table_klass_name] += query_ids
+      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[table_klass_name].sort! if Rails.env.test?
+      deletion_list[klass_name].sort! if Rails.env.test?
 
       # ignore associations that aren't a dependent destroyable type
       destroy_associations = query.reflect_on_all_associations.select do |reflection|
@@ -176,7 +223,7 @@ module BulkDependencyEraser
       reflection = parent_class.reflect_on_association(association_name)
       reflection_type = reflection.class.name
       assoc_klass = reflection.klass
-      assoc_table_klass_name = assoc_klass.table_name.classify
+      assoc_klass_name = assoc_klass.name
 
       assoc_query = assoc_klass.unscoped
 
@@ -247,7 +294,7 @@ module BulkDependencyEraser
         deletion_query_parser(assoc_query, parent_class)
       elsif type == :nullify
         # No need for recursion here.
-        # - we're not destroying these assocs so we don't need to parse their dependencies.
+        # - we're not destroying these assocs (just nullifying foreign_key columns) so we don't need to parse their dependencies.
         assoc_ids = read_from_db do
           assoc_query.pluck(:id)
         end
@@ -255,11 +302,10 @@ module BulkDependencyEraser
         # No assoc_ids, no need to add it to the nullification list
         return if assoc_ids.none?
 
-        # puts "FOUND IDS: #{assoc_ids.insect}"
-        nullification_list[assoc_table_klass_name] ||= {}
-        nullification_list[assoc_table_klass_name][specified_foreign_key] ||= []
-        nullification_list[assoc_table_klass_name][specified_foreign_key] += assoc_ids
-        nullification_list[assoc_table_klass_name][specified_foreign_key].uniq!
+        nullification_list[assoc_klass_name] ||= {}
+        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!
       else
         raise "invalid parsing type: #{type}"
       end
@@ -267,6 +313,10 @@ module BulkDependencyEraser
 
     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
+
     # 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)

data/lib/bulk_dependency_eraser/deleter.rb

@@ -3,6 +3,8 @@ module BulkDependencyEraser
     DEFAULT_OPTS = {
       verbose: false,
       db_delete_wrapper: self::DEFAULT_DB_WRAPPER,
+      # Set to true if you want 'ActiveRecord::InvalidForeignKey' errors raised during deletions
+      enable_invalid_foreign_key_detection: false
     }.freeze
 
     def initialize class_names_and_ids: {}, opts: {}
@@ -11,6 +13,10 @@ module BulkDependencyEraser
     end
 
     def execute
+      if opts_c.verbose && opts_c.enable_invalid_foreign_key_detection
+        puts "ActiveRecord::Base.connection.disable_referential_integrity - disabled!"
+      end
+
       ActiveRecord::Base.transaction do
         current_class_name = 'N/A'
         begin
@@ -19,12 +25,16 @@ module BulkDependencyEraser
             ids = class_names_and_ids[class_name]
             klass = class_name.constantize
 
-            # Disable any ActiveRecord::InvalidForeignKey raised errors.
-            # src https://stackoverflow.com/questions/41005849/rails-migrations-temporarily-ignore-foreign-key-constraint
-            #     https://apidock.com/rails/ActiveRecord/ConnectionAdapters/AbstractAdapter/disable_referential_integrity
-            ActiveRecord::Base.connection.disable_referential_integrity do
-              delete_in_db do
-                klass.unscoped.where(id: ids).delete_all
+            if opts_c.enable_invalid_foreign_key_detection
+              # delete with referential integrity
+              delete_by_klass_and_ids(klass, ids)
+            else
+              # delete 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
+                delete_by_klass_and_ids(klass, ids)
               end
             end
           end
@@ -39,6 +49,13 @@ module BulkDependencyEraser
 
     protected
 
+    def delete_by_klass_and_ids klass, ids
+      puts "Deleting #{klass.name}'s IDs: #{ids}" if opts_c.verbose
+      delete_in_db do
+        klass.unscoped.where(id: ids).delete_all
+      end
+    end
+
     attr_reader :class_names_and_ids
 
     def delete_in_db(&block)

data/lib/bulk_dependency_eraser/manager.rb

@@ -5,6 +5,7 @@ module BulkDependencyEraser
     }.freeze
 
     delegate :nullification_list, :deletion_list, to: :dependency_builder
+    delegate :ignore_table_deletion_list, :ignore_table_nullification_list, to: :dependency_builder
 
     # @param query [ActiveRecord::Base | ActiveRecord::Relation]
     def initialize query:, opts: {}
@@ -62,7 +63,6 @@ module BulkDependencyEraser
       unless nullifier_execution
         puts "Nullifier execution FAILED" if opts_c.verbose
         merge_errors(nullifier.errors, 'Nullifier: ')
-        @errors += nullifier.errors
       else
         puts "Nullifier execution SUCCESSFUL" if opts_c.verbose
       end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: bulk_dependency_eraser
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 1.0.0
 platform: ruby
 authors:
 - benjamin.dana.software.dev@gmail.com