active_record-undo 0.1.4 → 0.2.0

data/app/controllers/active_record/undo/application_controller.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require 'erb'
+
+module ActiveRecord
+  module Undo
+    class ApplicationController < ActiveRecord::Undo.base_controller_class
+      include SafeRedirect
+
+      protect_from_forgery with: :exception, unless: -> { request.format.json? }
+
+      rescue_from ActiveRecord::Undo::SecurityError, with: :handle_security_error
+
+      private
+
+      def resolve_whodunnit_user
+        if respond_to?(:current_user, true) && send(:current_user).present?
+          send(:current_user)
+        elsif ActiveRecord::Undo.config.current_user_method.respond_to?(:call)
+          ActiveRecord::Undo.config.current_user_method.call
+        else
+          ActiveRecord::Undo.whodunnit
+        end
+      end
+
+      def resolve_current_tenant
+        if respond_to?(:current_tenant, true) && send(:current_tenant).present?
+          send(:current_tenant)
+        elsif ActiveRecord::Undo.config.current_tenant_method.respond_to?(:call)
+          ActiveRecord::Undo.config.current_tenant_method.call
+        else
+          ActiveRecord::Undo.current_tenant
+        end
+      end
+
+      def handle_security_error(error)
+        respond_to do |format|
+          format.html { handle_html_error(error.message, :forbidden) }
+          format.turbo_stream { render_turbo_stream_error(error.message, :forbidden) }
+          format.json { render json: { error: error.message }, status: :forbidden }
+        end
+      end
+
+      def handle_not_found
+        msg = 'Undo log not found or already restored.'
+        respond_to do |format|
+          format.html { handle_html_error(msg, :not_found) }
+          format.turbo_stream { render_turbo_stream_error(msg, :not_found) }
+          format.json { render json: { error: msg }, status: :not_found }
+        end
+      end
+
+      def handle_expired
+        msg = 'Undo action has expired.'
+        respond_to do |format|
+          format.html { handle_html_error(msg, :unprocessable_entity) }
+          format.turbo_stream { render_turbo_stream_error(msg, :unprocessable_entity) }
+          format.json { render json: { error: msg }, status: :unprocessable_entity }
+        end
+      end
+
+      def handle_html_error(message, status)
+        if should_redirect_on_error?
+          redirect_to determine_redirect_path, alert: message, status: :see_other
+        else
+          render plain: message, status: status
+        end
+      end
+
+      def should_redirect_on_error?
+        return true if ActiveRecord::Undo.config.error_handling == :redirect
+        return false if ActiveRecord::Undo.config.error_handling == :render
+
+        safe_redirect_path(params[:redirect_to]).present? || safe_redirect_path(request.referer).present?
+      end
+
+      def render_turbo_stream_error(message, status)
+        render inline: turbo_stream_template('alert', message),
+               content_type: 'text/vnd.turbo-stream.html',
+               status: status
+      end
+
+      def turbo_stream_template(type, message)
+        escaped = ERB::Util.html_escape(message)
+        '<turbo-stream action="append" target="notifications"><template>' \
+          "<div class=\"undo-notification undo-#{type}\">#{escaped}</div>" \
+          '</template></turbo-stream>'
+      end
+    end
+  end
+end

data/app/controllers/active_record/undo/logs_controller.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class LogsController < ApplicationController
+      before_action :set_undo_log
+      before_action :check_not_found
+      before_action :check_expired
+
+      def restore
+        return unless @undo_log
+
+        count = @undo_log.undo_log_items.count
+        execute_restore_action
+        respond_with_restored_log(count)
+      end
+
+      private
+
+      def set_undo_log
+        @undo_log = find_undo_log
+      end
+
+      def check_not_found
+        handle_not_found if @undo_log.nil?
+      end
+
+      def check_expired
+        handle_expired if @undo_log&.expired?
+      end
+
+      def find_undo_log
+        if params[:token].present?
+          ActiveRecord::Undo::UndoLog.find_by_signed_token(params[:token])
+        elsif params[:id].present?
+          find_by_id_or_token(params[:id])
+        end
+      end
+
+      def find_by_id_or_token(identifier)
+        str = identifier.to_s
+        return nil if str.blank?
+
+        if str.match?(/\A\d+\z/) || uuid_identifier?(str)
+          ActiveRecord::Undo::UndoLog.find_by(id: identifier)
+        else
+          ActiveRecord::Undo::UndoLog.find_by_signed_token(str)
+        end
+      end
+
+      def uuid_identifier?(str)
+        str.match?(/\A[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\z/i)
+      end
+
+      def execute_restore_action
+        tenant = resolve_current_tenant
+        with_tenant_context(tenant) do
+          @undo_log.restore!(whodunnit: resolve_whodunnit_user)
+        end
+      end
+
+      def with_tenant_context(tenant)
+        orig = ActiveRecord::Undo.current_tenant
+        ActiveRecord::Undo.current_tenant = tenant if tenant.present?
+        yield
+      ensure
+        ActiveRecord::Undo.current_tenant = orig
+      end
+
+      def respond_with_restored_log(count)
+        respond_to do |format|
+          format.html do
+            redirect_to determine_redirect_path, notice: 'Record successfully restored.', status: :see_other
+          end
+          format.turbo_stream { render_turbo_stream_success }
+          format.json { render json: { success: true, restored_items_count: count }, status: :ok }
+        end
+      end
+
+      def render_turbo_stream_success
+        render inline: turbo_stream_template('notice', 'Record successfully restored.'),
+               content_type: 'text/vnd.turbo-stream.html',
+               status: :ok
+      end
+    end
+  end
+end

data/app/controllers/active_record/undo/restores_controller.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class RestoresController < LogsController
+      def create
+        restore
+      end
+    end
+  end
+end

data/config/routes.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+ActiveRecord::Undo::Engine.routes.draw do
+  resources :logs, only: [] do
+    member do
+      post :restore
+    end
+  end
+
+  post '/restore/:token', to: 'restores#create', as: :signed_restore
+end

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

@@ -3,10 +3,19 @@
 module ActiveRecord
   module Undo
     class Configuration
-      attr_accessor :retention_period
+      attr_accessor :retention_period, :current_user_method, :current_tenant_method,
+                    :base_controller, :default_redirect_path, :token_secret_key,
+                    :token_expires_in, :error_handling
 
       def initialize
         @retention_period = 30.days
+        @current_user_method = nil
+        @current_tenant_method = nil
+        @base_controller = '::ApplicationController'
+        @default_redirect_path = ->(main_app) { main_app.respond_to?(:root_path) ? main_app.root_path : '/' }
+        @token_secret_key = nil
+        @token_expires_in = 24.hours
+        @error_handling = :auto
       end
     end
   end

data/lib/active_record/undo/engine.rb

@@ -1,6 +1,7 @@
-# lib/active_record/undo/engine.rb
 # frozen_string_literal: true
 
+require_relative 'view_helpers'
+
 module ActiveRecord
   module Undo
     class Engine < ::Rails::Engine
@@ -15,6 +16,18 @@ module ActiveRecord
         end
       end
 
+      initializer 'active_record_undo.view_helpers' do
+        ActiveSupport.on_load(:action_view) do
+          include ActiveRecord::Undo::ViewHelpers
+        end
+      end
+
+      initializer 'active_record_undo.turbo_stream_mime_type' do
+        if defined?(Mime::Type) && (!defined?(Mime[:turbo_stream]) || Mime[:turbo_stream].nil?)
+          Mime::Type.register 'text/vnd.turbo-stream.html', :turbo_stream
+        end
+      end
+
       rake_tasks do
         path = root.join('lib', 'tasks', 'active_record_undo_tasks.rake')
         load path if File.exist?(path)

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

@@ -0,0 +1,54 @@
+# 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
+
+        def with_whodunnit_context(actor)
+          orig = ActiveRecord::Undo.whodunnit
+          ActiveRecord::Undo.whodunnit = actor
+          yield
+        ensure
+          ActiveRecord::Undo.whodunnit = orig
+        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.blank?
+
+          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,6 +2,8 @@
 # frozen_string_literal: true
 
 require_relative 'cascade_handler'
+require_relative 'model_extension/attribution_helper'
+require_relative 'model_extension/tenant_verification'
 
 module ActiveRecord
   module Undo
@@ -49,6 +51,9 @@ module ActiveRecord
       end
 
       module InstanceMethods
+        include AttributionHelper
+        include TenantVerification
+
         def soft_deleted?
           public_send(self.class.undoable_column).present?
         end
@@ -64,7 +69,7 @@ module ActiveRecord
         end
 
         def undoable?
-          return false unless soft_deleted?
+          return false unless persisted? && soft_deleted?
 
           ActiveRecord::Undo::UndoLogItem.joins(:undo_log).exists?(
             item_type: self.class.name,
@@ -72,28 +77,36 @@ module ActiveRecord
           )
         end
 
-        def soft_delete!
-          ensure_undoable_column_exists!
-          return false if soft_deleted?
+        def undo_log
+          return nil unless persisted? && soft_deleted?
 
-          undo_log = nil
-          timestamp = Time.current
+          find_latest_undo_log_item&.undo_log
+        end
+        alias latest_undo_log undo_log
 
-          transaction do
-            undo_log = ActiveRecord::Undo::UndoLog.create!
-            soft_delete_cascade_internal!(timestamp, undo_log)
-            undo_log.save!
-          end
+        def signed_token(expires_in: ActiveRecord::Undo.config.token_expires_in, purpose: :restore)
+          undo_log&.signed_token(expires_in: expires_in, purpose: purpose)
+        end
+        alias to_signed_token signed_token
+
+        def soft_delete!(whodunnit: nil, tenant: nil)
+          ensure_undoable_column_exists!
+          return false if soft_deleted?
 
-          undo_log
+          ActiveRecord::Undo.verify_configured_context!
+          attrs = build_undo_log_attributes(whodunnit, tenant)
+          execute_soft_delete!(attrs)
         end
 
         # rubocop:disable Naming/PredicateMethod
-        def restore!
+        def restore!(whodunnit: nil)
           ensure_undoable_column_exists!
           return false unless soft_deleted?
 
-          restore_internally!(find_latest_undo_log_item)
+          ActiveRecord::Undo.verify_configured_context!
+          log_item = find_latest_undo_log_item
+          log_item ? restore_from_log!(log_item.undo_log, whodunnit) : direct_restore!
+
           reload
           true
         end
@@ -112,8 +125,9 @@ module ActiveRecord
 
         def find_latest_undo_log_item
           ActiveRecord::Undo::UndoLogItem
+            .joins(:undo_log)
             .where(item: self)
-            .order(created_at: :desc)
+            .order(created_at: :desc, id: :desc)
             .first
         end
 
@@ -121,14 +135,40 @@ module ActiveRecord
           CascadeHandler.new(self).soft_delete_with_cascade!(timestamp, undo_log)
         end
 
-        def restore_internally!(log_item)
-          if log_item
-            log_item.undo_log.restore!
-          else
-            column_name = self.class.undoable_column
-            update_columns(column_name => nil, updated_at: Time.current)
+        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/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

@@ -1,8 +1,12 @@
 # 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)
@@ -13,7 +17,7 @@ module ActiveRecord
 
         def purge_expired_logs!(batch_size)
           loop do
-            log_ids = UndoLog.expired.limit(batch_size).pluck(:id)
+            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
@@ -21,6 +25,22 @@ module ActiveRecord
           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
@@ -31,15 +51,42 @@ module ActiveRecord
         end
 
         def purge_model_expired_records!(model, batch_size)
-          primary_key = model.primary_key
+          pk = model.primary_key
           loop do
-            expired_ids = model.expired.limit(batch_size).pluck(primary_key)
+            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?
 
@@ -74,33 +121,6 @@ module ActiveRecord
         def delete_records!(model, record_ids)
           model.unscoped.where(model.primary_key => record_ids).delete_all
         end
-
-        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