active_record-undo 0.1.3 → 0.1.5

data/db/migrate/20260821000000_add_tenant_and_user_attribution_to_undo_logs.rb

@@ -0,0 +1,16 @@
+# db/migrate/20260821000000_add_tenant_and_user_attribution_to_undo_logs.rb
+# frozen_string_literal: true
+
+class AddTenantAndUserAttributionToUndoLogs < ActiveRecord::Migration[7.0]
+  def change
+    change_table :undo_logs, bulk: true do |t|
+      t.string :whodunnit_type, null: true
+      t.bigint :whodunnit_id, null: true
+      t.string :tenant_type, null: true
+      t.bigint :tenant_id, null: true
+    end
+
+    add_index :undo_logs, %i[whodunnit_type whodunnit_id], name: 'index_undo_logs_on_whodunnit'
+    add_index :undo_logs, %i[tenant_type tenant_id], name: 'index_undo_logs_on_tenant'
+  end
+end

data/lib/active_record/undo/configuration.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class Configuration
+      attr_accessor :retention_period, :current_user_method, :current_tenant_method
+
+      def initialize
+        @retention_period = 30.days
+        @current_user_method = nil
+        @current_tenant_method = nil
+      end
+    end
+  end
+end

data/lib/active_record/undo/engine.rb

@@ -14,6 +14,11 @@ module ActiveRecord
           end
         end
       end
+
+      rake_tasks do
+        path = root.join('lib', 'tasks', 'active_record_undo_tasks.rake')
+        load path if File.exist?(path)
+      end
     end
   end
 end

data/lib/active_record/undo/model_extension/attribution_helper.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    module ModelExtension
+      module AttributionHelper
+        private
+
+        def resolve_whodunnit(whodunnit)
+          whodunnit || ActiveRecord::Undo.config.current_user_method&.call || ActiveRecord::Undo.whodunnit
+        end
+
+        def resolve_tenant(tenant)
+          tenant || ActiveRecord::Undo.config.current_tenant_method&.call ||
+            ActiveRecord::Undo.current_tenant || (self.tenant if respond_to?(:tenant))
+        end
+
+        def build_undo_log_attributes(whodunnit, tenant)
+          attrs = {}
+          actor = resolve_whodunnit(whodunnit)
+          assign_whodunnit_attribute!(attrs, actor) if actor
+
+          ten = resolve_tenant(tenant)
+          assign_tenant_attribute!(attrs, ten) if ten
+          attrs
+        end
+
+        def assign_whodunnit_attribute!(attrs, actor)
+          if actor.is_a?(ActiveRecord::Base)
+            attrs[:whodunnit] = actor
+          else
+            attrs[:whodunnit_id] = actor
+          end
+        end
+
+        def assign_tenant_attribute!(attrs, ten)
+          if ten.is_a?(ActiveRecord::Base)
+            attrs[:tenant] = ten
+          else
+            attrs[:tenant_id] = ten
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo/model_extension/tenant_verification.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    module ModelExtension
+      module TenantVerification
+        private
+
+        def verify_tenant_match!(undo_log)
+          ctx = current_tenant_context
+          raise_tenant_mismatch!(undo_log, 'nil') if ctx.nil?
+
+          return if tenant_matches?(undo_log, ctx)
+
+          ctx_info = ctx.is_a?(ActiveRecord::Base) ? "#{ctx.class.name}##{ctx.id}" : ctx.to_s
+          raise_tenant_mismatch!(undo_log, ctx_info)
+        end
+
+        def tenant_matches?(undo_log, ctx)
+          if ctx.is_a?(ActiveRecord::Base)
+            undo_log.tenant_type == ctx.class.name && undo_log.tenant_id.to_s == ctx.id.to_s
+          else
+            undo_log.tenant_id.to_s == ctx.to_s
+          end
+        end
+
+        def current_tenant_context
+          ActiveRecord::Undo.config.current_tenant_method&.call || ActiveRecord::Undo.current_tenant
+        end
+
+        def raise_tenant_mismatch!(undo_log, ctx_info)
+          raise ActiveRecord::Undo::SecurityError,
+                "Tenant mismatch: log belongs to tenant #{undo_log.tenant_type}##{undo_log.tenant_id}, " \
+                "but current context tenant is #{ctx_info}."
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo/model_extension.rb

@@ -2,31 +2,72 @@
 # frozen_string_literal: true
 
 require_relative 'cascade_handler'
+require_relative 'model_extension/attribution_helper'
+require_relative 'model_extension/tenant_verification'
 
 module ActiveRecord
   module Undo
     module ModelExtension
       extend ActiveSupport::Concern
 
-      class_methods do
+      module ClassMethods
         # Accept a custom column parameter, defaulting to :deleted_at
         def acts_as_undoable(column: :deleted_at)
           include InstanceMethods
 
+          define_undo_attributes!(column)
+          define_undo_scopes!
+
+          ActiveRecord::Undo.registered_models << self
+        end
+
+        private
+
+        def define_undo_attributes!(column)
           class_attribute :undoable_column
           self.undoable_column = column.to_sym
+        end
+
+        def define_undo_scopes!
+          define_basic_scopes!
+          define_expired_scope!
+        end
 
-          # Dynamic scopes using the configured column
+        def define_basic_scopes!
           scope :kept, -> { where(undoable_column => nil) }
           scope :soft_deleted, -> { where.not(undoable_column => nil) }
         end
+
+        def define_expired_scope!
+          scope :expired, lambda {
+            period = ActiveRecord::Undo.config.retention_period
+            if period
+              where("#{table_name}.#{undoable_column} < ?", Time.current - period)
+            else
+              none
+            end
+          }
+        end
       end
 
       module InstanceMethods
+        include AttributionHelper
+        include TenantVerification
+
         def soft_deleted?
           public_send(self.class.undoable_column).present?
         end
 
+        def expired?
+          return false unless soft_deleted?
+
+          period = ActiveRecord::Undo.config.retention_period
+          return false unless period
+
+          timestamp = public_send(self.class.undoable_column)
+          timestamp && timestamp < Time.current - period
+        end
+
         def undoable?
           return false unless soft_deleted?
 
@@ -36,36 +77,28 @@ module ActiveRecord
           )
         end
 
-        def soft_delete!
+        def soft_delete!(whodunnit: nil, tenant: nil)
           ensure_undoable_column_exists!
           return false if soft_deleted?
 
-          undo_log = nil
-          timestamp = Time.current
-
-          transaction do
-            undo_log = ActiveRecord::Undo::UndoLog.create!
-            soft_delete_cascade_internal!(timestamp, undo_log)
-            undo_log.save!
-          end
-
-          undo_log
+          ActiveRecord::Undo.verify_configured_context!
+          attrs = build_undo_log_attributes(whodunnit, tenant)
+          execute_soft_delete!(attrs)
         end
 
-        def restore!
+        # rubocop:disable Naming/PredicateMethod
+        def restore!(whodunnit: nil)
           ensure_undoable_column_exists!
           return false unless soft_deleted?
 
+          ActiveRecord::Undo.verify_configured_context!
           log_item = find_latest_undo_log_item
+          log_item ? restore_from_log!(log_item.undo_log, whodunnit) : direct_restore!
 
-          if log_item
-            log_item.undo_log.restore!
-          else
-            column_name = self.class.undoable_column
-            update_columns(column_name => nil, updated_at: Time.current)
-            true
-          end
+          reload
+          true
         end
+        # rubocop:enable Naming/PredicateMethod
 
         private
 
@@ -88,6 +121,41 @@ module ActiveRecord
         def soft_delete_cascade_internal!(timestamp, undo_log)
           CascadeHandler.new(self).soft_delete_with_cascade!(timestamp, undo_log)
         end
+
+        def execute_soft_delete!(attrs)
+          transaction do
+            undo_log = ActiveRecord::Undo::UndoLog.create!(attrs)
+            soft_delete_cascade_internal!(Time.current, undo_log)
+            undo_log.save!
+            undo_log
+          end
+        end
+
+        def restore_from_log!(undo_log, whodunnit)
+          verify_tenant_match!(undo_log) if undo_log_tenant_present?(undo_log)
+
+          actor = resolve_whodunnit(whodunnit)
+          with_whodunnit_context(actor) do
+            undo_log.restore!
+          end
+        end
+
+        def with_whodunnit_context(actor)
+          orig = ActiveRecord::Undo.whodunnit
+          ActiveRecord::Undo.whodunnit = actor
+          yield
+        ensure
+          ActiveRecord::Undo.whodunnit = orig
+        end
+
+        def undo_log_tenant_present?(undo_log)
+          undo_log && (undo_log.tenant_id.present? || undo_log.tenant_type.present?)
+        end
+
+        def direct_restore!
+          column_name = self.class.undoable_column
+          update_columns(column_name => nil, updated_at: Time.current)
+        end
       end
     end
   end

data/lib/active_record/undo/purge_job.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+begin
+  require 'active_job'
+rescue LoadError
+  # ActiveJob is not available
+end
+
+if defined?(ActiveJob::Base)
+  module ActiveRecord
+    module Undo
+      class PurgeJob < ActiveJob::Base
+        queue_as :default
+
+        def perform(batch_size: 1000)
+          ActiveRecord::Undo::Purger.purge_expired!(batch_size: batch_size)
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo/purger/reflection_helper.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class Purger
+      module ReflectionHelper
+        private
+
+        def nullify_reflections(model)
+          model.reflections.values.select do |ref|
+            %i[has_many has_one].include?(ref.macro) &&
+              ref.options[:dependent] == :nullify &&
+              foreign_key_nullable?(ref)
+          end
+        end
+
+        def cascade_reflections(model)
+          model.reflections.values.select do |ref|
+            next false unless %i[has_many has_one].include?(ref.macro)
+
+            dependent = ref.options[:dependent]
+            %i[destroy soft_delete delete_all].include?(dependent) ||
+              non_nullable_nullify?(ref)
+          end
+        end
+
+        def non_nullable_nullify?(ref)
+          ref.options[:dependent] == :nullify && !foreign_key_nullable?(ref)
+        end
+
+        def foreign_key_nullable?(ref)
+          column = ref.klass.columns_hash[ref.foreign_key.to_s]
+          column.nil? || column.null
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo/purger.rb

@@ -0,0 +1,127 @@
+# frozen_string_literal: true
+
+require_relative 'purger/reflection_helper'
+
+module ActiveRecord
+  module Undo
+    class Purger
+      extend ReflectionHelper
+
+      class << self
+        def purge_expired!(batch_size: 1000)
+          purge_expired_logs!(batch_size)
+          purge_expired_records!(batch_size)
+        end
+
+        private
+
+        def purge_expired_logs!(batch_size)
+          loop do
+            log_ids = current_tenant_log_scope.limit(batch_size).pluck(:id)
+            break if log_ids.empty?
+
+            UndoLogItem.where(undo_log_id: log_ids).delete_all
+            UndoLog.where(id: log_ids).delete_all
+          end
+        end
+
+        def current_tenant_log_scope
+          scope = UndoLog.expired
+          ctx = current_tenant_context
+          return scope unless ctx
+
+          if ctx.is_a?(ActiveRecord::Base)
+            scope.where(tenant_type: ctx.class.name, tenant_id: ctx.id)
+          else
+            scope.where(tenant_id: ctx)
+          end
+        end
+
+        def current_tenant_context
+          ActiveRecord::Undo.config.current_tenant_method&.call || ActiveRecord::Undo.current_tenant
+        end
+
+        def purge_expired_records!(batch_size)
+          period = ActiveRecord::Undo.config.retention_period
+          return unless period
+
+          ActiveRecord::Undo.undoable_models.each do |model|
+            purge_model_expired_records!(model, batch_size)
+          end
+        end
+
+        def purge_model_expired_records!(model, batch_size)
+          pk = model.primary_key
+          loop do
+            expired_ids = scoped_model_expired(model).limit(batch_size).pluck(pk)
+            break if expired_ids.empty?
+
+            purge_records_with_cascade!(model, expired_ids, batch_size)
+          end
+        end
+
+        def scoped_model_expired(model)
+          scope = model.expired
+          ctx = current_tenant_context
+          return scope unless ctx
+
+          apply_tenant_scope(scope, model, ctx)
+        end
+
+        def apply_tenant_scope(scope, model, ctx)
+          if model.column_names.include?('tenant_id')
+            apply_tenant_column_scope(scope, model, ctx)
+          elsif model.reflect_on_association(:tenant)
+            scope.where(tenant: ctx)
+          else
+            scope
+          end
+        end
+
+        def apply_tenant_column_scope(scope, model, ctx)
+          val = ctx.is_a?(ActiveRecord::Base) ? ctx.id : ctx
+          scope = scope.where(tenant_id: val)
+          if model.column_names.include?('tenant_type') && ctx.is_a?(ActiveRecord::Base)
+            scope = scope.where(tenant_type: ctx.class.name)
+          end
+          scope
+        end
+
+        def purge_records_with_cascade!(model, record_ids, batch_size)
+          return if record_ids.empty?
+
+          nullify_dependent_associations!(model, record_ids)
+          purge_cascading_associations!(model, record_ids, batch_size)
+          delete_records!(model, record_ids)
+        end
+
+        def nullify_dependent_associations!(model, record_ids)
+          nullify_reflections(model).each do |reflection|
+            child_query_for(model, reflection, record_ids).update_all(reflection.foreign_key => nil)
+          end
+        end
+
+        def purge_cascading_associations!(model, record_ids, batch_size)
+          cascade_reflections(model).each do |reflection|
+            query = child_query_for(model, reflection, record_ids)
+            primary_key = reflection.klass.primary_key
+
+            query.pluck(primary_key).each_slice(batch_size) do |child_ids|
+              purge_records_with_cascade!(reflection.klass, child_ids, batch_size)
+            end
+          end
+        end
+
+        def child_query_for(model, reflection, record_ids)
+          query = reflection.klass.unscoped.where(reflection.foreign_key => record_ids)
+          query = query.where(reflection.type => model.name) if reflection.type
+          query
+        end
+
+        def delete_records!(model, record_ids)
+          model.unscoped.where(model.primary_key => record_ids).delete_all
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo/tasks/purge.rake

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+namespace :active_record_undo do
+  desc 'Purge expired soft-deleted records and undo logs'
+  task purge_expired: :environment do
+    batch_size = ENV['BATCH_SIZE'] ? ENV['BATCH_SIZE'].to_i : 1000
+    ActiveRecord::Undo::Purger.purge_expired!(batch_size: batch_size)
+  end
+end

data/lib/active_record/undo/undo_log.rb

@@ -8,8 +8,38 @@ module ActiveRecord
 
       has_many :undo_log_items, class_name: 'ActiveRecord::Undo::UndoLogItem', dependent: :destroy
 
+      belongs_to :whodunnit, polymorphic: true, optional: true
+      belongs_to :tenant, polymorphic: true, optional: true
+
+      scope :for_whodunnit, lambda { |user|
+        if user.is_a?(ActiveRecord::Base)
+          where(whodunnit: user)
+        else
+          where(whodunnit_id: user)
+        end
+      }
+
+      scope :for_tenant, lambda { |tenant|
+        if tenant.is_a?(ActiveRecord::Base)
+          where(tenant: tenant)
+        else
+          where(tenant_id: tenant)
+        end
+      }
+
+      scope :expired, lambda {
+        period = ActiveRecord::Undo.config.retention_period
+        if period
+          where('created_at < ?', Time.current - period)
+        else
+          none
+        end
+      }
+
       # Restores all records associated with this deletion batch
       def restore!
+        ActiveRecord::Undo.verify_configured_context!
+
         transaction do
           # Reverse order ensures child records are restored before or after parents as needed
           undo_log_items.reverse_each(&:restore_item!)

data/lib/active_record/undo/version.rb

@@ -3,6 +3,6 @@
 
 module ActiveRecord
   module Undo
-    VERSION = '0.1.3'
+    VERSION = '0.1.5'
   end
 end

data/lib/active_record/undo.rb

@@ -9,15 +9,92 @@ rescue LoadError => e
         "Please add 'activerecord' to your Gemfile. (Original error: #{e.message})"
 end
 
+require 'set'
 require_relative 'undo/version'
 require_relative 'undo/engine' if defined?(Rails::Engine)
+require_relative 'undo/configuration'
 require_relative 'undo/model_extension'
 require_relative 'undo/undo_log'
 require_relative 'undo/undo_log_item'
+require_relative 'undo/purger'
+require_relative 'undo/purge_job'
 
 module ActiveRecord
   module Undo
     class Error < StandardError; end
+    class SecurityError < Error; end
+
+    class << self
+      def whodunnit
+        Thread.current[:active_record_undo_whodunnit]
+      end
+
+      def whodunnit=(value)
+        Thread.current[:active_record_undo_whodunnit] = value
+      end
+
+      def current_tenant
+        Thread.current[:active_record_undo_current_tenant]
+      end
+
+      def current_tenant=(value)
+        Thread.current[:active_record_undo_current_tenant] = value
+      end
+
+      def config
+        @config ||= Configuration.new
+      end
+
+      def configure
+        yield(config)
+      end
+
+      def registered_models
+        @registered_models ||= Set.new
+      end
+
+      def undoable_models
+        eager_load_rails!
+        models = registered_models.to_a
+        if defined?(ActiveRecord::Base)
+          models += ActiveRecord::Base.descendants.select { |m| m.respond_to?(:undoable_column) }
+        end
+        models.uniq
+      end
+
+      def verify_configured_context!
+        user_null = configured_method_nil?(config.current_user_method)
+        tenant_null = configured_method_nil?(config.current_tenant_method)
+        return unless user_null || tenant_null
+
+        raise_configured_context_error!(user_null, tenant_null)
+      end
+
+      def configured_method_nil?(method)
+        method.respond_to?(:call) && method.call.nil?
+      end
+
+      def raise_configured_context_error!(user_null, tenant_null)
+        msg = if user_null && tenant_null
+                'Configured current_user_method and current_tenant_method both returned nil.'
+              elsif user_null
+                'Configured current_user_method returned nil.'
+              else
+                'Configured current_tenant_method returned nil.'
+              end
+        raise ActiveRecord::Undo::SecurityError, msg
+      end
+
+      private
+
+      def eager_load_rails!
+        return unless defined?(Rails) && Rails.application
+
+        Rails.application.eager_load!
+      rescue StandardError
+        # Safe fallback if Rails eager loading fails in test environments
+      end
+    end
   end
 end
 

data/lib/tasks/active_record_undo_tasks.rake

@@ -0,0 +1,4 @@
+# frozen_string_literal: true
+
+path = File.expand_path('../active_record/undo/tasks/purge.rake', __dir__)
+load path if File.exist?(path)

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record-undo
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.5
 platform: ruby
 authors:
 - Saurabh Sharma
@@ -137,15 +137,24 @@ files:
 - README.md
 - Rakefile
 - db/migrate/20260808000000_create_active_record_undo_tables.rb
+- db/migrate/20260821000000_add_tenant_and_user_attribution_to_undo_logs.rb
 - lib/active_record/undo.rb
 - lib/active_record/undo/cascade_handler.rb
 - lib/active_record/undo/cascade_handler/association_finder.rb
 - lib/active_record/undo/cascade_handler/record_updater.rb
+- lib/active_record/undo/configuration.rb
 - lib/active_record/undo/engine.rb
 - lib/active_record/undo/model_extension.rb
+- lib/active_record/undo/model_extension/attribution_helper.rb
+- lib/active_record/undo/model_extension/tenant_verification.rb
+- lib/active_record/undo/purge_job.rb
+- lib/active_record/undo/purger.rb
+- lib/active_record/undo/purger/reflection_helper.rb
+- lib/active_record/undo/tasks/purge.rake
 - lib/active_record/undo/undo_log.rb
 - lib/active_record/undo/undo_log_item.rb
 - lib/active_record/undo/version.rb
+- lib/tasks/active_record_undo_tasks.rake
 - sig/active_record/undo.rbs
 homepage: https://github.com/saurabh-activecode/active_record-undo
 licenses: