active_record-undo 0.1.5 → 0.3.0

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

@@ -0,0 +1,100 @@
+# 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::Error, with: :handle_undo_error
+      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_undo_error(error)
+        respond_to do |format|
+          format.html { handle_html_error(error.message, :unprocessable_entity) }
+          format.turbo_stream { render_turbo_stream_error(error.message, :unprocessable_entity) }
+          format.json { render json: { error: error.message }, status: :unprocessable_entity }
+        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/async_handler.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class LogsController < ApplicationController
+      module AsyncHandler
+        private
+
+        def async_request?
+          params[:async].to_s == 'true' || request.headers['X-Undo-Async'].to_s == 'true'
+        end
+
+        def execute_async_restore_action
+          tenant = resolve_current_tenant
+          with_tenant_context(tenant) do
+            @undo_log.restore_later!(whodunnit: resolve_whodunnit_user)
+          end
+        end
+
+        def respond_with_async_restore_scheduled
+          notice = 'Restoration has been scheduled and is processing.'
+          respond_to do |format|
+            format.html { redirect_to determine_redirect_path, notice: notice, status: :see_other }
+            format.turbo_stream { render_turbo_stream_notice(notice, :accepted) }
+            format.json { render json: { success: true, status: 'pending', log_id: @undo_log.id }, status: :accepted }
+          end
+        end
+
+        def render_turbo_stream_notice(notice, status)
+          render inline: turbo_stream_template('notice', notice),
+                 content_type: 'text/vnd.turbo-stream.html',
+                 status: status
+        end
+
+        def log_status_payload
+          {
+            id: @undo_log.id,
+            action: @undo_log.action,
+            status: @undo_log.status,
+            soft_delete_status: @undo_log.soft_delete_status,
+            restore_status: @undo_log.restore_status,
+            error_message: @undo_log.error_message,
+            completed: @undo_log.completed?,
+            failed: @undo_log.failed?
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,116 @@
+# frozen_string_literal: true
+
+require_relative 'logs_controller/async_handler'
+
+module ActiveRecord
+  module Undo
+    class LogsController < ApplicationController
+      include AsyncHandler
+
+      before_action :set_undo_log
+      before_action :check_not_found
+      before_action :check_expired
+      before_action :check_tenant_access
+
+      def restore
+        return unless @undo_log
+
+        if async_request?
+          execute_async_restore_action
+          respond_with_async_restore_scheduled
+        else
+          count = @undo_log.undo_log_items.count
+          execute_restore_action
+          respond_with_restored_log(count)
+        end
+      end
+
+      def status
+        return unless @undo_log
+
+        respond_to do |format|
+          format.json { render json: log_status_payload, status: :ok }
+          format.html { render plain: @undo_log.status, status: :ok }
+        end
+      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 check_tenant_access
+        tenant = resolve_current_tenant
+        with_tenant_context(tenant) do
+          ActiveRecord::Undo.verify_configured_context!
+          return unless @undo_log && (@undo_log.tenant_id.present? || @undo_log.tenant_type.present?)
+
+          @undo_log.send(:verify_tenant_match!, @undo_log)
+        end
+      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/app/jobs/active_record/undo/restore_job.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class RestoreJob < ActiveRecord::Undo.base_job_class
+      queue_as :default
+
+      def perform(undo_log_id, whodunnit: nil)
+        undo_log = find_undo_log(undo_log_id)
+        return unless undo_log
+
+        acquired = lock_and_start_processing!(undo_log)
+        return unless acquired
+
+        execute_restore_batches(undo_log, whodunnit)
+      rescue StandardError => e
+        handle_failure(undo_log, e)
+        raise e
+      end
+
+      private
+
+      def find_undo_log(undo_log_id)
+        ActiveRecord::Undo::UndoLog.find_by(id: undo_log_id)
+      end
+
+      def lock_and_start_processing!(undo_log)
+        undo_log.with_lock do
+          return false if undo_log.processing?
+          return false if undo_log.completed?
+
+          undo_log.update!(status: :processing)
+          true
+        end
+      end
+
+      def execute_restore_batches(undo_log, whodunnit)
+        actor = undo_log.send(:resolve_whodunnit, whodunnit)
+        undo_log.send(:with_whodunnit_context, actor) do
+          with_tenant_context(undo_log) do
+            restore_all_items_in_batches(undo_log)
+            cleanup_log!(undo_log)
+          end
+        end
+      end
+
+      def with_tenant_context(undo_log)
+        ten = undo_log.tenant || undo_log.tenant_id
+        orig = ActiveRecord::Undo.current_tenant
+        ActiveRecord::Undo.current_tenant = ten if ten.present?
+        yield
+      ensure
+        ActiveRecord::Undo.current_tenant = orig
+      end
+
+      def restore_all_items_in_batches(undo_log)
+        undo_log.undo_log_items.find_each(batch_size: 1000, order: :desc, &:restore_item!)
+      end
+
+      def cleanup_log!(undo_log)
+        undo_log.undo_log_items.in_batches(of: 1000).delete_all
+        undo_log.destroy!
+      end
+
+      def handle_failure(undo_log, exception)
+        return unless undo_log && ActiveRecord::Undo::UndoLog.exists?(undo_log.id)
+
+        undo_log.update!(status: :failed, error_message: exception.message)
+      end
+    end
+  end
+end

data/app/jobs/active_record/undo/soft_delete_job.rb

@@ -0,0 +1,75 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    class SoftDeleteJob < ActiveRecord::Undo.base_job_class
+      queue_as :default
+
+      def perform(record_class_name, record_id, undo_log_id, whodunnit: nil, tenant: nil)
+        undo_log = find_undo_log(undo_log_id)
+        return unless undo_log
+
+        acquired = lock_and_start_processing!(undo_log)
+        return unless acquired
+
+        execute_soft_delete_cascade(record_class_name, record_id, undo_log, whodunnit, tenant)
+      rescue StandardError => e
+        handle_failure(undo_log, e)
+        raise e
+      end
+
+      private
+
+      def find_undo_log(undo_log_id)
+        ActiveRecord::Undo::UndoLog.find_by(id: undo_log_id)
+      end
+
+      def lock_and_start_processing!(undo_log)
+        undo_log.with_lock do
+          return false if undo_log.processing?
+          return false if undo_log.completed?
+
+          undo_log.update!(status: :processing)
+          true
+        end
+      end
+
+      def execute_soft_delete_cascade(class_name, record_id, undo_log, whodunnit, tenant)
+        record = class_name.constantize.unscoped.find(record_id)
+        timestamp = record_timestamp(record, undo_log)
+
+        run_cascade_with_context(record, timestamp, undo_log, whodunnit, tenant)
+        undo_log.update!(status: :completed)
+      end
+
+      def record_timestamp(record, undo_log)
+        col = record.class.respond_to?(:undoable_column) ? record.class.undoable_column : :deleted_at
+        record.public_send(col) || undo_log.created_at || Time.current
+      end
+
+      def run_cascade_with_context(record, timestamp, undo_log, whodunnit, tenant)
+        with_execution_context(record, whodunnit, tenant) do
+          CascadeHandler.new(record).soft_delete_associations_batched!(timestamp, undo_log)
+        end
+      end
+
+      def with_execution_context(record, whodunnit, tenant)
+        actor = whodunnit || record.send(:resolve_whodunnit, nil)
+        ten = tenant || record.send(:resolve_tenant, nil)
+        record.send(:with_whodunnit_context, actor) do
+          orig = ActiveRecord::Undo.current_tenant
+          ActiveRecord::Undo.current_tenant = ten if ten.present?
+          yield
+        ensure
+          ActiveRecord::Undo.current_tenant = orig
+        end
+      end
+
+      def handle_failure(undo_log, exception)
+        return unless undo_log && ActiveRecord::Undo::UndoLog.exists?(undo_log.id)
+
+        undo_log.update!(status: :failed, error_message: exception.message)
+      end
+    end
+  end
+end

data/config/routes.rb

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

data/db/migrate/20260920000000_add_status_and_error_message_to_undo_logs.rb

@@ -0,0 +1,15 @@
+# db/migrate/20260920000000_add_status_and_error_message_to_undo_logs.rb
+# frozen_string_literal: true
+
+class AddStatusAndErrorMessageToUndoLogs < ActiveRecord::Migration[7.0]
+  def change
+    change_table :undo_logs, bulk: true do |t|
+      t.integer :status, default: 2, null: false unless column_exists?(:undo_logs, :status)
+      t.integer :action, default: 0, null: false unless column_exists?(:undo_logs, :action)
+      t.text :error_message unless column_exists?(:undo_logs, :error_message)
+    end
+
+    add_index :undo_logs, :status unless index_exists?(:undo_logs, :status)
+    add_index :undo_logs, :action unless index_exists?(:undo_logs, :action)
+  end
+end

data/lib/active_record/undo/cascade_handler.rb

@@ -20,8 +20,74 @@ module ActiveRecord
         undo_log.undo_log_items.build(item: @record)
       end
 
+      def soft_delete_associations_batched!(timestamp, undo_log, batch_size: 1000)
+        associations_to_cascade.each do |reflection|
+          cascade_association_batched!(reflection, timestamp, undo_log, batch_size)
+        end
+      end
+
       private
 
+      def cascade_association_batched!(reflection, timestamp, undo_log, batch_size)
+        target = @record.public_send(reflection.name)
+        return if target.nil?
+
+        if reflection.collection? || target.is_a?(ActiveRecord::Relation)
+          cascade_collection_batched!(target, reflection, timestamp, undo_log, batch_size)
+        else
+          cascade_record_batched!(target, reflection, timestamp, undo_log, batch_size)
+        end
+      end
+
+      def cascade_collection_batched!(target, reflection, timestamp, undo_log, batch_size)
+        each_collection_batch(target, batch_size) do |batch|
+          batch.each do |associated|
+            cascade_record_batched!(associated, reflection, timestamp, undo_log, batch_size)
+          end
+        end
+      end
+
+      def each_collection_batch(target, batch_size, &)
+        if target.respond_to?(:in_batches)
+          target.in_batches(of: batch_size, &)
+        else
+          target.each_slice(batch_size, &)
+        end
+      end
+
+      def cascade_record_batched!(associated, reflection, timestamp, undo_log, batch_size)
+        return if skip_cascade?(associated)
+
+        if undoable_record?(associated)
+          process_undoable_child!(associated, timestamp, undo_log, batch_size)
+        elsif reflection.options[:dependent] == :destroy
+          associated.destroy!
+        end
+      end
+
+      def skip_cascade?(associated)
+        return true if associated.nil?
+        return true if associated.respond_to?(:soft_deleted?) && associated.soft_deleted?
+
+        if associated.respond_to?(:soft_deleted?) && associated.persisted?
+          associated.reload
+          return true if associated.soft_deleted?
+        end
+
+        false
+      end
+
+      def undoable_record?(associated)
+        associated.respond_to?(:acts_as_undoable) || associated.class.respond_to?(:undoable_column)
+      end
+
+      def process_undoable_child!(associated, timestamp, undo_log, batch_size)
+        self.class.new(associated).soft_delete_associations_batched!(timestamp, undo_log, batch_size: batch_size)
+        column_name = associated.class.respond_to?(:undoable_column) ? associated.class.undoable_column : :deleted_at
+        associated.update_columns(column_name => timestamp, updated_at: timestamp)
+        ActiveRecord::Undo::UndoLogItem.create!(undo_log_id: undo_log.id, item: associated)
+      end
+
       def cascade_to_associations!(timestamp, undo_log)
         associations_to_cascade.each do |reflection|
           associated_records_for(reflection).each do |associated|

data/lib/active_record/undo/configuration.rb

@@ -3,12 +3,20 @@
 module ActiveRecord
   module Undo
     class Configuration
-      attr_accessor :retention_period, :current_user_method, :current_tenant_method
+      attr_accessor :retention_period, :current_user_method, :current_tenant_method,
+                    :base_controller, :base_job, :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'
+        @base_job = '::ActiveJob::Base'
+        @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/async_methods.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    module ModelExtension
+      module AsyncMethods
+        def soft_delete_status
+          return nil unless soft_deleted?
+          return 'completed' unless undo_log
+
+          undo_log.soft_delete_status
+        end
+
+        def restore_status
+          return nil unless undo_log
+
+          undo_log.restore_status
+        end
+
+        def soft_delete_later!(whodunnit: nil, tenant: nil, queue: nil)
+          ensure_undoable_column_exists!
+          return false if soft_deleted?
+
+          ActiveRecord::Undo.verify_configured_context!
+          attrs = build_undo_log_attributes(whodunnit, tenant)
+          undo_log = execute_initial_soft_delete_later!(attrs)
+          enqueue_soft_delete_job!(undo_log, whodunnit, tenant, queue)
+          undo_log
+        end
+
+        def restore_later!(whodunnit: nil, queue: nil)
+          ensure_undoable_column_exists!
+          return false unless soft_deleted?
+
+          ActiveRecord::Undo.verify_configured_context!
+          log = undo_log
+          raise ActiveRecord::Undo::Error, 'No undo log found to restore.' unless log
+
+          log.restore_later!(whodunnit: whodunnit, queue: queue)
+          log
+        end
+
+        private
+
+        def execute_initial_soft_delete_later!(attrs)
+          transaction do
+            timestamp = Time.current
+            undo_log = ActiveRecord::Undo::UndoLog.create!(attrs.merge(action: :soft_delete, status: :pending))
+            update_soft_delete_timestamps!(timestamp)
+            ActiveRecord::Undo::UndoLogItem.create!(undo_log_id: undo_log.id, item: self)
+            undo_log
+          end
+        end
+
+        def update_soft_delete_timestamps!(timestamp)
+          column_name = self.class.undoable_column
+          update_columns(column_name => timestamp, updated_at: timestamp)
+        end
+
+        def enqueue_soft_delete_job!(undo_log, whodunnit, tenant, queue)
+          job_class = ActiveRecord::Undo::SoftDeleteJob
+          job = queue.present? ? job_class.set(queue: queue) : job_class
+          job.perform_later(self.class.name, id, undo_log.id, whodunnit: whodunnit, tenant: tenant)
+        end
+      end
+    end
+  end
+end

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

@@ -40,6 +40,14 @@ module ActiveRecord
             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

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

@@ -8,7 +8,7 @@ module ActiveRecord
 
         def verify_tenant_match!(undo_log)
           ctx = current_tenant_context
-          raise_tenant_mismatch!(undo_log, 'nil') if ctx.nil?
+          raise_tenant_mismatch!(undo_log, 'nil') if ctx.blank?
 
           return if tenant_matches?(undo_log, ctx)