active_record-undo 0.1.5 → 0.3.0

data/lib/active_record/undo/model_extension.rb

@@ -4,6 +4,7 @@
 require_relative 'cascade_handler'
 require_relative 'model_extension/attribution_helper'
 require_relative 'model_extension/tenant_verification'
+require_relative 'model_extension/async_methods'
 
 module ActiveRecord
   module Undo
@@ -53,6 +54,8 @@ module ActiveRecord
       module InstanceMethods
         include AttributionHelper
         include TenantVerification
+        include AsyncMethods
+        include StatusPredicates
 
         def soft_deleted?
           public_send(self.class.undoable_column).present?
@@ -69,13 +72,25 @@ module ActiveRecord
         end
 
         def undoable?
-          return false unless soft_deleted?
+          return false unless persisted? && soft_deleted?
+
+          log = undo_log
+          return false unless log
+
+          log.respond_to?(:completed?) ? log.completed? : true
+        end
+
+        def undo_log
+          return nil unless persisted? && soft_deleted?
+
+          find_latest_undo_log_item&.undo_log
+        end
+        alias latest_undo_log undo_log
 
-          ActiveRecord::Undo::UndoLogItem.joins(:undo_log).exists?(
-            item_type: self.class.name,
-            item_id: id
-          )
+        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!
@@ -113,8 +128,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/status_predicates.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    module StatusPredicates
+      def soft_delete_pending?
+        soft_delete_status == 'pending'
+      end
+
+      def soft_delete_processing?
+        soft_delete_status == 'processing'
+      end
+
+      def soft_delete_completed?
+        soft_delete_status == 'completed'
+      end
+
+      def soft_delete_failed?
+        soft_delete_status == 'failed'
+      end
+
+      def restore_pending?
+        restore_status == 'pending'
+      end
+
+      def restore_processing?
+        restore_status == 'processing'
+      end
+
+      def restore_completed?
+        restore_status == 'completed'
+      end
+
+      def restore_failed?
+        restore_status == 'failed'
+      end
+    end
+  end
+end

data/lib/active_record/undo/undo_log/token_verifier.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'active_support/message_verifier'
+
+module ActiveRecord
+  module Undo
+    class UndoLog < ActiveRecord::Base
+      module TokenVerifier
+        extend ActiveSupport::Concern
+
+        class_methods do
+          def 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 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 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
+        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
+      end
+    end
+  end
+end

data/lib/active_record/undo/undo_log.rb

@@ -1,16 +1,25 @@
-# lib/active_record/undo/undo_log.rb
 # frozen_string_literal: true
 
+require_relative 'undo_log/token_verifier'
+
 module ActiveRecord
   module Undo
     class UndoLog < ActiveRecord::Base
       self.table_name = 'undo_logs'
 
+      include ModelExtension::AttributionHelper
+      include ModelExtension::TenantVerification
+      include TokenVerifier
+      include StatusPredicates
+
       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
 
+      enum :status, { pending: 0, processing: 1, completed: 2, failed: 3 }, default: :completed
+      enum :action, { soft_delete: 0, restore: 1 }, default: :soft_delete
+
       scope :for_whodunnit, lambda { |user|
         if user.is_a?(ActiveRecord::Base)
           where(whodunnit: user)
@@ -36,10 +45,76 @@ module ActiveRecord
         end
       }
 
+      def expired?
+        period = ActiveRecord::Undo.config.retention_period
+        return false unless period && created_at
+
+        created_at < Time.current - period
+      end
+
+      def soft_delete_status
+        return status if action == 'soft_delete' || action.nil?
+
+        'completed'
+      end
+
+      def restore_status
+        return status if action == 'restore'
+
+        nil
+      end
+
+      def restore_later!(whodunnit: nil, queue: nil)
+        verify_restore_preconditions!
+        with_lock do
+          validate_restore_status_eligibility!
+          update!(action: :restore, status: :pending)
+        end
+        enqueue_restore_job!(whodunnit, queue)
+        self
+      end
+
       # Restores all records associated with this deletion batch
-      def restore!
+      def restore!(whodunnit: nil)
+        verify_restore_preconditions!
+        validate_restore_status_eligibility!
+
+        actor = resolve_whodunnit(whodunnit)
+        with_whodunnit_context(actor) do
+          execute_restore_transaction!
+        end
+      end
+
+      private
+
+      def verify_restore_preconditions!
         ActiveRecord::Undo.verify_configured_context!
+        verify_tenant_match!(self) if tenant_present?
+        raise ActiveRecord::Undo::Error, 'Undo action has expired.' if expired?
+      end
+
+      def validate_restore_status_eligibility!
+        raise ActiveRecord::Undo::Error, 'Cannot restore: UndoLog is currently processing.' if processing?
+
+        if pending? && action == 'restore'
+          raise ActiveRecord::Undo::Error, 'Cannot restore: UndoLog is already scheduled for restore.'
+        end
+        return if completed? || (action == 'restore' && failed?)
+
+        raise ActiveRecord::Undo::Error, "Cannot restore: UndoLog is not completed (current status: #{status})."
+      end
+
+      def enqueue_restore_job!(whodunnit, queue)
+        job_class = ActiveRecord::Undo::RestoreJob
+        job = queue.present? ? job_class.set(queue: queue) : job_class
+        job.perform_later(id, whodunnit: whodunnit)
+      end
+
+      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.3.0'
   end
 end

data/lib/active_record/undo/view_helpers/status_badge_helper.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module ActiveRecord
+  module Undo
+    module ViewHelpers
+      module StatusBadgeHelper
+        def undo_status_badge(target, action: :auto, **html_options)
+          return nil if target.nil?
+
+          act, status = resolve_target_action_and_status(target, action)
+          return nil unless status
+
+          classes = build_badge_classes(act, status, html_options.delete(:class))
+          label = html_options.delete(:text) || status.to_s.humanize
+          render_badge_tag(label, classes, html_options)
+        end
+
+        def soft_delete_status_badge(target, **html_options)
+          undo_status_badge(target, action: :soft_delete, **html_options)
+        end
+
+        def restore_status_badge(target, **html_options)
+          undo_status_badge(target, action: :restore, **html_options)
+        end
+
+        private
+
+        def resolve_target_action_and_status(target, action)
+          return nil if target.nil?
+
+          case action
+          when :soft_delete
+            ['soft_delete', extract_target_status(target, :soft_delete_status)]
+          when :restore
+            ['restore', extract_target_status(target, :restore_status)]
+          else
+            resolve_auto_action_and_status(target)
+          end
+        end
+
+        def extract_target_status(target, status_method)
+          if target.respond_to?(status_method)
+            target.public_send(status_method)
+          elsif target.respond_to?(:status)
+            target.status
+          end
+        end
+
+        def resolve_auto_action_and_status(target)
+          return ['restore', target.restore_status] if auto_restore_status?(target)
+          return ['soft_delete', target.soft_delete_status] if auto_soft_delete_status?(target)
+          return [log_action(target), target.status] if target.respond_to?(:status)
+
+          nil
+        end
+
+        def auto_restore_status?(target)
+          target.respond_to?(:restore_status) && target.restore_status.present?
+        end
+
+        def auto_soft_delete_status?(target)
+          target.respond_to?(:soft_delete_status) && target.soft_delete_status.present?
+        end
+
+        def log_action(target)
+          target.respond_to?(:action) ? target.action : nil
+        end
+
+        def build_badge_classes(action, status, custom_class)
+          action_class = action ? "undo-#{action.to_s.tr('_', '-')}-badge" : nil
+          ['undo-status-badge', action_class, "undo-status-#{status}", custom_class].compact.join(' ')
+        end
+
+        def render_badge_tag(label, classes, html_options)
+          if respond_to?(:content_tag)
+            content_tag(:span, label, html_options.merge(class: classes))
+          else
+            "<span class=\"#{classes}\">#{label}</span>"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/active_record/undo/view_helpers.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+require_relative 'view_helpers/status_badge_helper'
+
+module ActiveRecord
+  module Undo
+    module ViewHelpers
+      include StatusBadgeHelper
+
+      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,12 +12,14 @@ 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/status_predicates'
 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
@@ -85,6 +87,28 @@ 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
+
+      def base_job_class
+        configured = config.base_job
+        return configured if configured.is_a?(Class)
+
+        (configured.presence && configured.to_s.safe_constantize) || default_base_job
+      end
+
+      def default_base_job
+        defined?(ActiveJob::Base) ? ActiveJob::Base : Object
+      end
+
       private
 
       def eager_load_rails!
@@ -98,6 +122,18 @@ module ActiveRecord
   end
 end
 
+begin
+  require 'active_job'
+rescue LoadError
+  # ActiveJob is optional
+end
+
+if defined?(ActiveJob::Base)
+  require_relative 'undo/purge_job'
+  require_relative '../../app/jobs/active_record/undo/soft_delete_job'
+  require_relative '../../app/jobs/active_record/undo/restore_job'
+end
+
 if defined?(ActiveSupport)
   ActiveSupport.on_load(:active_record) do
     include ActiveRecord::Undo::ModelExtension

data/sig/active_record/undo.rbs

@@ -1,6 +1,55 @@
 module ActiveRecord
   module Undo
     VERSION: String
-    # See the writing guide of rbs: https://github.com/ruby/rbs#guides
+
+    class Error < StandardError
+    end
+
+    class SecurityError < Error
+    end
+
+    def self.whodunnit: () -> untyped
+    def self.whodunnit=: (untyped) -> untyped
+    def self.current_tenant: () -> untyped
+    def self.current_tenant=: (untyped) -> untyped
+    def self.config: () -> Configuration
+    def self.configure: () { (Configuration) -> void } -> void
+    def self.registered_models: () -> Set[untyped]
+    def self.undoable_models: () -> Array[untyped]
+    def self.base_controller_class: () -> untyped
+    def self.base_job_class: () -> untyped
+
+    class Configuration
+      attr_accessor retention_period: untyped
+      attr_accessor current_user_method: untyped
+      attr_accessor current_tenant_method: untyped
+      attr_accessor base_controller: untyped
+      attr_accessor base_job: untyped
+      attr_accessor default_redirect_path: untyped
+      attr_accessor token_secret_key: String?
+      attr_accessor token_expires_in: untyped
+      attr_accessor error_handling: Symbol
+
+      def initialize: () -> void
+    end
+
+    module StatusPredicates
+      def soft_delete_pending?: () -> bool
+      def soft_delete_processing?: () -> bool
+      def soft_delete_completed?: () -> bool
+      def soft_delete_failed?: () -> bool
+      def restore_pending?: () -> bool
+      def restore_processing?: () -> bool
+      def restore_completed?: () -> bool
+      def restore_failed?: () -> bool
+    end
+
+    module ViewHelpers
+      def undo_button_to: (untyped target, ?String? text, ?signed: bool, **untyped html_options) -> untyped
+      def undo_link_to: (untyped target, ?String? text, ?signed: bool, **untyped html_options) -> untyped
+      def undo_status_badge: (untyped target, ?action: Symbol, **untyped html_options) -> untyped
+      def soft_delete_status_badge: (untyped target, **untyped html_options) -> untyped
+      def restore_status_badge: (untyped target, **untyped html_options) -> untyped
+    end
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: active_record-undo
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.3.0
 platform: ruby
 authors:
 - Saurabh Sharma
@@ -9,6 +9,20 @@ bindir: exe
 cert_chain: []
 date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
+- !ruby/object:Gem::Dependency
+  name: activejob
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 7.0.0
 - !ruby/object:Gem::Dependency
   name: activerecord
   requirement: !ruby/object:Gem::Requirement
@@ -136,8 +150,16 @@ 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/logs_controller/async_handler.rb
+- app/controllers/active_record/undo/restores_controller.rb
+- app/jobs/active_record/undo/restore_job.rb
+- app/jobs/active_record/undo/soft_delete_job.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
+- db/migrate/20260920000000_add_status_and_error_message_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
@@ -145,15 +167,21 @@ 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/async_methods.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/status_predicates.rb
 - lib/active_record/undo/tasks/purge.rake
 - lib/active_record/undo/undo_log.rb
+- lib/active_record/undo/undo_log/token_verifier.rb
 - lib/active_record/undo/undo_log_item.rb
 - lib/active_record/undo/version.rb
+- lib/active_record/undo/view_helpers.rb
+- lib/active_record/undo/view_helpers/status_badge_helper.rb
 - lib/tasks/active_record_undo_tasks.rake
 - sig/active_record/undo.rbs
 homepage: https://github.com/saurabh-activecode/active_record-undo