active_record-undo 0.1.4 → 0.2.0

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,13 +1,36 @@
-# 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
+      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
@@ -17,8 +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.4'
+    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'
@@ -22,8 +24,25 @@ 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
@@ -45,6 +64,40 @@ module ActiveRecord
         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
+
+      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.4
+  version: 0.2.0
 platform: ruby
 authors:
 - Saurabh Sharma
@@ -136,7 +136,12 @@ 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
 - lib/active_record/undo/cascade_handler.rb
 - lib/active_record/undo/cascade_handler/association_finder.rb
@@ -144,12 +149,17 @@ files:
 - 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/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