active_record-undo 0.1.5 → 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/lib/active_record/undo/configuration.rb

@@ -3,12 +3,19 @@
 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, :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

@@ -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)
 

data/lib/active_record/undo/model_extension.rb

@@ -69,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,
@@ -77,6 +77,18 @@ module ActiveRecord
           )
         end
 
+        def undo_log
+          return nil unless persisted? && soft_deleted?
+
+          find_latest_undo_log_item&.undo_log
+        end
+        alias latest_undo_log undo_log
+
+        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?
@@ -113,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
 

data/lib/active_record/undo/safe_redirect.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module ActiveRecord
+  module Undo
+    module SafeRedirect
+      private
+
+      def determine_redirect_path
+        safe_redirect_path(params[:redirect_to]) ||
+          safe_redirect_path(request.referer) ||
+          resolve_fallback_path
+      end
+
+      def safe_redirect_path(path)
+        return nil if invalid_path_string?(path)
+
+        uri = URI.parse(path)
+        return path if valid_relative_path?(path, uri)
+        return path if valid_same_host_path?(uri)
+
+        nil
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def invalid_path_string?(path)
+        path.blank? || !path.is_a?(String) || path.match?(/[\r\n]/)
+      end
+
+      def valid_relative_path?(path, uri)
+        uri.relative? && uri.scheme.nil? && path.start_with?('/') && !path.start_with?('//') && !path.start_with?('/\\')
+      end
+
+      def valid_same_host_path?(uri)
+        %w[http https].include?(uri.scheme) &&
+          uri.host == request.host &&
+          (uri.port.nil? || uri.port == request.port)
+      end
+
+      def resolve_fallback_path
+        cfg = ActiveRecord::Undo.config.default_redirect_path
+        if cfg.respond_to?(:call)
+          cfg.arity.zero? ? cfg.call : cfg.call(main_app)
+        elsif cfg.present?
+          cfg.to_s
+        else
+          default_root_path
+        end
+      rescue StandardError
+        '/'
+      end
+
+      def default_root_path
+        main_app.respond_to?(:root_path) ? main_app.root_path : '/'
+      end
+    end
+  end
+end

data/lib/active_record/undo/undo_log.rb

@@ -1,11 +1,15 @@
-# lib/active_record/undo/undo_log.rb
 # frozen_string_literal: true
 
+require 'active_support/message_verifier'
+
 module ActiveRecord
   module Undo
     class UndoLog < ActiveRecord::Base
       self.table_name = 'undo_logs'
 
+      include ModelExtension::AttributionHelper
+      include ModelExtension::TenantVerification
+
       has_many :undo_log_items, class_name: 'ActiveRecord::Undo::UndoLogItem', dependent: :destroy
 
       belongs_to :whodunnit, polymorphic: true, optional: true
@@ -36,10 +40,64 @@ module ActiveRecord
         end
       }
 
+      def self.find_by_signed_token(token, purpose: :restore)
+        return nil unless token.is_a?(String) && token.present?
+
+        verified_id = verify_signed_token(token, purpose: purpose)
+        return nil unless verified_id
+
+        find_by(id: verified_id)
+      rescue StandardError
+        nil
+      end
+
+      def self.verify_signed_token(token, purpose: :restore)
+        return nil unless token.is_a?(String) && token.present?
+
+        token_verifier.verified(token, purpose: purpose)
+      rescue StandardError
+        nil
+      end
+
+      def self.token_verifier
+        if defined?(Rails.application) && Rails.application.respond_to?(:message_verifier)
+          Rails.application.message_verifier(:active_record_undo)
+        else
+          key = ActiveRecord::Undo.config.token_secret_key || 'active_record_undo_default_secret_key_32_bytes'
+          @token_verifier ||= ActiveSupport::MessageVerifier.new(key, digest: 'SHA256')
+        end
+      end
+
+      def expired?
+        period = ActiveRecord::Undo.config.retention_period
+        return false unless period && created_at
+
+        created_at < Time.current - period
+      end
+
+      def signed_token(expires_in: ActiveRecord::Undo.config.token_expires_in, purpose: :restore)
+        self.class.token_verifier.generate(id, purpose: purpose, expires_in: expires_in)
+      end
+      alias to_signed_token signed_token
+
       # Restores all records associated with this deletion batch
-      def restore!
+      def restore!(whodunnit: nil)
         ActiveRecord::Undo.verify_configured_context!
+        verify_tenant_match!(self) if tenant_present?
+
+        actor = resolve_whodunnit(whodunnit)
+        with_whodunnit_context(actor) do
+          execute_restore_transaction!
+        end
+      end
+
+      private
+
+      def tenant_present?
+        tenant_id.present? || tenant_type.present?
+      end
 
+      def execute_restore_transaction!
         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.5'
+    VERSION = '0.2.0'
   end
 end

data/lib/active_record/undo/view_helpers.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    module ViewHelpers
+      def undo_button_to(target, text = nil, signed: false, **html_options)
+        btn_text = extract_undo_text(text, html_options)
+        url = resolve_undo_path(target, signed: signed)
+        button_to(btn_text, url, method: :post, **html_options)
+      end
+
+      def undo_link_to(target, text = nil, signed: false, **html_options)
+        link_text = extract_undo_text(text, html_options)
+        url = resolve_undo_path(target, signed: signed)
+        data = { turbo_method: :post }.merge(html_options.delete(:data) || {})
+        link_to(link_text, url, method: :post, data: data, **html_options)
+      end
+
+      private
+
+      def extract_undo_text(text, html_options)
+        text || html_options.delete(:text) || 'Undo'
+      end
+
+      def resolve_undo_path(target, signed: false)
+        router = undo_engine_router
+        if signed
+          token = extract_signed_token(target)
+          router.signed_restore_path(token: token)
+        else
+          router.restore_log_path(extract_log_target(target))
+        end
+      end
+
+      def extract_signed_token(target)
+        return target if target.is_a?(String)
+
+        token = token_from_target(target)
+        token || (raise ArgumentError, "Cannot generate signed token for #{target.inspect}")
+      end
+
+      def token_from_target(target)
+        if target.respond_to?(:signed_token)
+          target.signed_token
+        elsif target.respond_to?(:undo_log)
+          target.undo_log&.signed_token
+        else
+          find_log_for_model(target)&.signed_token
+        end
+      end
+
+      def extract_log_target(target)
+        return target if target.is_a?(ActiveRecord::Undo::UndoLog)
+
+        if model_target?(target)
+          log = log_for_target(target)
+          return log if log
+
+          raise ArgumentError, "Cannot resolve undo log for #{target.inspect}. " \
+                               'Ensure the record is soft-deleted and undoable.'
+        end
+
+        target
+      end
+
+      def model_target?(target)
+        target.respond_to?(:undoable?) || target.respond_to?(:undo_log)
+      end
+
+      def log_for_target(target)
+        if target.respond_to?(:undo_log)
+          target.undo_log
+        else
+          find_log_for_model(target)
+        end
+      end
+
+      def find_log_for_model(model)
+        return nil unless model.respond_to?(:undoable?)
+
+        ActiveRecord::Undo::UndoLogItem
+          .joins(:undo_log)
+          .where(item: model)
+          .order(created_at: :desc, id: :desc)
+          .first&.undo_log
+      end
+
+      def undo_engine_router
+        if respond_to?(:active_record_undo)
+          active_record_undo
+        elsif defined?(main_app) && main_app.respond_to?(:active_record_undo)
+          main_app.active_record_undo
+        elsif respond_to?(:restore_log_path)
+          self
+        else
+          ActiveRecord::Undo::Engine.routes.url_helpers
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo.rb

@@ -12,7 +12,9 @@ end
 require 'set'
 require_relative 'undo/version'
 require_relative 'undo/engine' if defined?(Rails::Engine)
+require_relative 'undo/view_helpers' if defined?(ActionView)
 require_relative 'undo/configuration'
+require_relative 'undo/safe_redirect'
 require_relative 'undo/model_extension'
 require_relative 'undo/undo_log'
 require_relative 'undo/undo_log_item'
@@ -85,6 +87,17 @@ module ActiveRecord
         raise ActiveRecord::Undo::SecurityError, msg
       end
 
+      def base_controller_class
+        configured = config.base_controller
+        return configured if configured.is_a?(Class)
+
+        (configured.presence && configured.to_s.safe_constantize) || default_base_controller
+      end
+
+      def default_base_controller
+        defined?(ActionController::Base) ? ActionController::Base : Object
+      end
+
       private
 
       def eager_load_rails!

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record-undo
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.2.0
 platform: ruby
 authors:
 - Saurabh Sharma
@@ -136,6 +136,10 @@ files:
 - LICENSE.txt
 - README.md
 - Rakefile
+- app/controllers/active_record/undo/application_controller.rb
+- app/controllers/active_record/undo/logs_controller.rb
+- app/controllers/active_record/undo/restores_controller.rb
+- config/routes.rb
 - 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
@@ -150,10 +154,12 @@ files:
 - 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/safe_redirect.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/active_record/undo/view_helpers.rb
 - lib/tasks/active_record_undo_tasks.rake
 - sig/active_record/undo.rbs
 homepage: https://github.com/saurabh-activecode/active_record-undo