active_record-undo 0.2.0 → 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?
@@ -71,10 +74,10 @@ module ActiveRecord
         def undoable?
           return false unless persisted? && soft_deleted?
 
-          ActiveRecord::Undo::UndoLogItem.joins(:undo_log).exists?(
-            item_type: self.class.name,
-            item_id: id
-          )
+          log = undo_log
+          return false unless log
+
+          log.respond_to?(:completed?) ? log.completed? : true
         end
 
         def undo_log

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,6 +1,6 @@
 # frozen_string_literal: true
 
-require 'active_support/message_verifier'
+require_relative 'undo_log/token_verifier'
 
 module ActiveRecord
   module Undo
@@ -9,12 +9,17 @@ module ActiveRecord
 
       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)
@@ -40,50 +45,39 @@ 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
+      def expired?
+        period = ActiveRecord::Undo.config.retention_period
+        return false unless period && created_at
 
-        find_by(id: verified_id)
-      rescue StandardError
-        nil
+        created_at < Time.current - period
       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 soft_delete_status
+        return status if action == 'soft_delete' || action.nil?
 
-      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
+        'completed'
       end
 
-      def expired?
-        period = ActiveRecord::Undo.config.retention_period
-        return false unless period && created_at
+      def restore_status
+        return status if action == 'restore'
 
-        created_at < Time.current - period
+        nil
       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)
+      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
-      alias to_signed_token signed_token
 
       # Restores all records associated with this deletion batch
       def restore!(whodunnit: nil)
-        ActiveRecord::Undo.verify_configured_context!
-        verify_tenant_match!(self) if tenant_present?
+        verify_restore_preconditions!
+        validate_restore_status_eligibility!
 
         actor = resolve_whodunnit(whodunnit)
         with_whodunnit_context(actor) do
@@ -93,6 +87,29 @@ module ActiveRecord
 
       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

data/lib/active_record/undo/version.rb

@@ -3,6 +3,6 @@
 
 module ActiveRecord
   module Undo
-    VERSION = '0.2.0'
+    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

@@ -1,8 +1,12 @@
 # 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)

data/lib/active_record/undo.rb

@@ -15,11 +15,11 @@ 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
@@ -98,6 +98,17 @@ module ActiveRecord
         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!
@@ -111,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.2.0
+  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
@@ -138,10 +152,14 @@ files:
 - 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
@@ -149,17 +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