rails_delete_all_and_assocs_without_instantiation 0.0.2 → 0.0.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 29a1a21db1dd7be9228776c4dd8c0f62fe53e626292fdc3423a60659ffe6bfbb
-  data.tar.gz: f1d447a7c617b90061ad3f836074449fed01d0bbf3fd2f98f1f6f50b027fb23b
+  metadata.gz: e9acdcdfc546fa1f49d03d2f52f785e8a012211cb2fead2ff5dad11767d125cc
+  data.tar.gz: e46db80ef699f7ad8a8ffbd4f9689f15c019826ad65acdbbd1d982cdaa423a52
 SHA512:
-  metadata.gz: 4d4ca0d71e2f5f4916dedbf510478e3cd3b431f48116ff83479fa7f3502e2e5c0878833348827eb5f873f7c617c50095281abe72c936cbb6189c28ee67a7aa0c
-  data.tar.gz: 16f5c31e7c3971094b98bf90ae3a9d40fc276a3b5abd5d29502484978143e2fdb0b05c635fe75aea604c42476ed191f1e809be3f9d2c25f289c6154cbfcb2555
+  metadata.gz: 87cdde62744d43c2567d6b55a59ccddcd0a412925c6d396294396839d12036dab633d3a3fd09d3284952bd5a351d4467c27d0426e5cf088b92b83963860f284c
+  data.tar.gz: 19ac4b45404cd36e02d1f1aac7cf8a9598a862ae272e32553258a377dbf2af8aa28ffc7047aa6e817898ab32fbb8922180b4b48bd5009d4243365fbb30187354

data/README.md

@@ -36,3 +36,22 @@ class User < ApplicationRecord
   has_many :creator_accounts, -> (user_id) { where(creator_id: user_id) }, dependent: :destroy
 end
 ```
+
+# Customization
+```
+class User
+  # This is a way you can do more advanced filtering on association dependencies, and not just wipe everything
+  def self.delete_all_and_assocs_without_instantiation_builder models_and_ids_list = {}, errors = [], options = {}
+    original_account_ids = models_and_ids_list['Account']
+    models_and_ids_list, errors = super(models_and_ids_list, errors, options)
+    # we've ignored the deletion command that may or may not have been created by your assoc definition
+    models_and_ids_list['Account'] = original_account_ids
+    
+    query = self.where({}).includes(:accounts).joins(:accounts).where(accounts: {marketable: true})
+    account_ids = query.collect{|pro| pro.accounts.map(&:id) }.flatten
+    models_and_ids_list, errors = Account.unscoped.where(id: account_ids).delete_all_and_assocs_without_instantiation_builder(models_and_ids_list, errors, options)
+
+    return models_and_ids_list, errors
+  end
+end
+```

data/lib/rails_delete_all_and_assocs_without_instantiation/delete_all_and_assocs_extension.rb

@@ -1,5 +1,13 @@
 module RailsDeleteAllAndAssocsWithoutInstantiation
   module DeleteAllAndAssocsWithoutInstantiation
+    MATCH_DEPENDENT_ASSOC_VALUE = [
+      :destroy,
+      'destroy',
+      :delete_all,
+      'delete_all',
+      :destroy_async,
+      'destroy_async',
+    ]
 
     # rails interpretation is different than expected:
     # https://makandracards.com/makandra/32175-don-t-forget-automatically-remove-join-records-on-has_many-through-associations
@@ -22,25 +30,25 @@ module RailsDeleteAllAndAssocsWithoutInstantiation
       # force_through_destroy_chains = options[:force_destroy_chain] || {}
       # do_not_destroy_self = options[:do_not_destroy] || {}
 
-      current_class = self::class
+      current_class = self.name
       current_query = self
       ids = current_query.pluck(:id)
       models_and_ids_list[name] ||= []
 
       # prevent infinite recursion here.
       ids = ids - models_and_ids_list[self.name]
-      if ids.none?
+      if ids.none? || ids.nil?
         return models_and_ids_list, errors
       end
 
-      models_and_ids_list[self.name] = ids
+      models_and_ids_list[self.name] += ids
 
       # if do_not_destroy_self != true 
       #   models_and_ids_list[name] += ids
       # end
 
       # ignore associations that aren't dependent destroyable.
-      destroy_association_names = self.reflect_on_all_associations.reject{|v| ![:destroy, 'destroy'].include?(v.options&.dig(:dependent)) }.collect{ |v| v.name }
+      destroy_association_names = self.reflect_on_all_associations.reject{|v| !MATCH_DEPENDENT_ASSOC_VALUE.include?(v.options&.dig(:dependent)) }.collect{ |v| v.name }
 
 
       # associations that we might not necessarilly need to delete, but need to go through
@@ -145,24 +153,38 @@ module RailsDeleteAllAndAssocsWithoutInstantiation
       retry_due_to_errors = []
       retry_to_capture_errors = []
 
+      if options[:verbose]
+        puts "DELETION STRUCTURE"
+        puts built_deletions.inspect
+      end
+
       ActiveRecord::Base.transaction do
         built_deletions.keys.reverse.each do |class_name|
+          ids = "N/A"
           begin
             ids = built_deletions[class_name]
-            next if ids.none?
+            next if ids.none? || ids.nil?
             klass = class_name.constantize
             klass.unscoped.where(id: ids).delete_all
           rescue Exception => e
+            puts "DEL ATTEMPT 1: #{class_name}.unscoped.where(id: #{ids}).delete_all" if options[:verbose]
             retry_due_to_errors << class_name
           end
         end
 
+        if options[:verbose]
+          puts "RETRY DUE TO ERRORS:"
+          puts retry_due_to_errors.inspect
+        end
+
         # ActiveRecord::InvalidForeignKey can cause issues in ordering.
-        retry_due_to_errors.reverse.each do |class_name|
+        retry_due_to_errors.each do |class_name|
+          ids = "N/A"
           begin
             ids = built_deletions[class_name]
-            next if ids.none?
+            next if ids.none? || ids.nil?
             klass = class_name.constantize
+            puts "DEL ATTEMPT 2: #{class_name}.unscoped.where(id: #{ids}).delete_all" if options[:verbose]
             klass.unscoped.where(id: ids).delete_all
             # if Rails.env.test? || Rails.env.development?
             #   if count = klass.unscoped.where(id: ids).count > 0
@@ -172,20 +194,27 @@ module RailsDeleteAllAndAssocsWithoutInstantiation
           rescue Exception => e
             # ActiveRecord::Base.transaction obscures the actual errors
             # - need to run again outside of block to get actual error
-            retry_to_capture_errors << [klass, ids]
+            retry_to_capture_errors << [class_name, ids]
             raise ActiveRecord::Rollback
           end
         end
       end
 
-      retry_to_capture_errors.each do |klass, ids|
+      retry_to_capture_errors.each do |class_name, ids|
+        if ids == "N/A"
+          errors << ["Internal Server Error, could not locate IDs", class_name]
+          next
+        end
         begin
+          klass = class_name.constantize
+          puts "DEL ATTEMPT 3: #{class_name}.unscoped.where(id: #{ids}).delete_all" if options[:verbose]
           klass.unscoped.where(id: ids).delete_all
           # should never get past this line, we're expecting an error!
           # - if we do, maybe was an intermittent issue. Call ourselves recursively to try again.
-          return current_query.delete_all_and_assocs_without_instantiation(options)
+          # return current_query.delete_all_and_assocs_without_instantiation(options)
+          errors << ["#{class_name} - expected error, ran into 2 errors on previous deletion attempts", ids]
         rescue Exception => e
-          errors << e.class.to_s + "; " + e.message
+          errors << [e.class.to_s + "; " + e.message, e.backtrace]
         end
 
       end

data/rails_delete_all_and_assocs_without_instantiation.gemspec

@@ -2,7 +2,7 @@
 
 Gem::Specification.new do |s|
   s.name = %q{rails_delete_all_and_assocs_without_instantiation}
-  s.version = "0.0.2"
+  s.version = "0.0.4"
   s.date = %q{2023-03-02}
   s.authors = ["benjamin.dana.software.dev@gmail.com"]
   s.summary = %q{Non-instantiated way of deleting records with dependencies quickly without instantiation.}

metadata

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