tasker-engine 1.0.0

data/lib/tasker/functions/function_based_step_readiness_status.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Function-based implementation of StepReadinessStatus
+    # Maintains the same interface as the view-based model but uses SQL functions for performance
+    class FunctionBasedStepReadinessStatus < FunctionWrapper
+      # Define attributes to match the SQL function output
+      attribute :workflow_step_id, :integer
+      attribute :task_id, :integer
+      attribute :named_step_id, :integer
+      attribute :name, :string
+      attribute :current_state, :string
+      attribute :dependencies_satisfied, :boolean
+      attribute :retry_eligible, :boolean
+      attribute :ready_for_execution, :boolean
+      attribute :last_failure_at, :datetime
+      attribute :next_retry_at, :datetime
+      attribute :total_parents, :integer
+      attribute :completed_parents, :integer
+      attribute :attempts, :integer
+      attribute :retry_limit, :integer
+      attribute :backoff_request_seconds, :integer
+      attribute :last_attempted_at, :datetime
+
+      # Class methods that use SQL functions
+      def self.for_task(task_id, step_ids = nil)
+        sql = 'SELECT * FROM get_step_readiness_status($1::BIGINT, $2::BIGINT[])'
+        binds = [task_id, step_ids]
+        from_sql_function(sql, binds, 'StepReadinessStatus Load')
+      end
+
+      def self.for_steps(task_id, step_ids)
+        for_task(task_id, step_ids)
+      end
+
+      def self.for_tasks(task_ids)
+        return [] if task_ids.empty?
+
+        # Use the batch function to get steps for multiple tasks efficiently
+        sql = 'SELECT * FROM get_step_readiness_status_batch($1::BIGINT[])'
+        binds = [task_ids]
+        from_sql_function(sql, binds, 'StepReadinessStatus Batch Load')
+      end
+
+      def self.ready_for_task(task_id)
+        for_task(task_id).select(&:ready_for_execution)
+      end
+
+      def self.blocked_by_dependencies_for_task(task_id)
+        for_task(task_id).reject(&:dependencies_satisfied)
+      end
+
+      def self.blocked_by_retry_for_task(task_id)
+        for_task(task_id).reject(&:retry_eligible)
+      end
+
+      def self.pending_for_task(task_id)
+        for_task(task_id).select { |s| s.current_state == 'pending' }
+      end
+
+      def self.failed_for_task(task_id)
+        for_task(task_id).select { |s| s.current_state == 'error' }
+      end
+
+      def self.in_progress_for_task(task_id)
+        for_task(task_id).select { |s| s.current_state == 'in_progress' }
+      end
+
+      def self.complete_for_task(task_id)
+        for_task(task_id).select { |s| s.current_state.in?(%w[complete resolved_manually]) }
+      end
+
+      # Instance methods (same as original model)
+      def can_execute_now?
+        ready_for_execution
+      end
+
+      def blocking_reason
+        return nil if ready_for_execution
+        return 'dependencies_not_satisfied' unless dependencies_satisfied
+        return 'retry_not_eligible' unless retry_eligible
+        return 'invalid_state' unless %w[pending error].include?(current_state)
+
+        'unknown'
+      end
+
+      def time_until_ready
+        return 0 if ready_for_execution
+        return nil unless next_retry_at
+
+        [(next_retry_at - Time.current).to_i, 0].max
+      end
+
+      def dependency_status
+        if total_parents.zero?
+          'no_dependencies'
+        elsif dependencies_satisfied
+          'all_satisfied'
+        else
+          "#{completed_parents || 0}/#{total_parents || 0}_satisfied"
+        end
+      end
+
+      def retry_status
+        if attempts >= retry_limit
+          'max_retries_reached'
+        elsif retry_eligible
+          'retry_eligible'
+        else
+          'waiting_for_backoff'
+        end
+      end
+
+      def backoff_type
+        if backoff_request_seconds.present? && last_attempted_at.present?
+          'explicit_backoff'
+        elsif last_failure_at.present?
+          'exponential_backoff'
+        else
+          'no_backoff'
+        end
+      end
+
+      def effective_backoff_seconds
+        if backoff_request_seconds.present?
+          backoff_request_seconds
+        elsif attempts.present? && attempts.positive?
+          # Calculate default exponential backoff (base_delay * 2^attempts, capped at 30)
+          [2**attempts, 30].min
+        else
+          0
+        end
+      end
+
+      def to_h
+        {
+          workflow_step_id: workflow_step_id,
+          task_id: task_id,
+          named_step_id: named_step_id,
+          name: name,
+          current_state: current_state,
+          dependencies_satisfied: dependencies_satisfied,
+          retry_eligible: retry_eligible,
+          ready_for_execution: ready_for_execution,
+          last_failure_at: last_failure_at,
+          next_retry_at: next_retry_at,
+          total_parents: total_parents,
+          completed_parents: completed_parents,
+          attempts: attempts,
+          retry_limit: retry_limit,
+          backoff_request_seconds: backoff_request_seconds,
+          last_attempted_at: last_attempted_at,
+          detailed_status: detailed_status
+        }
+      end
+
+      def detailed_status
+        {
+          ready: ready_for_execution,
+          current_state: current_state,
+          dependencies: dependency_status,
+          retry: retry_status,
+          blocking_reason: blocking_reason,
+          time_until_ready: time_until_ready,
+          backoff_type: backoff_type,
+          effective_backoff_seconds: effective_backoff_seconds
+        }
+      end
+
+      # Associations (lazy-loaded)
+      def workflow_step
+        @workflow_step ||= Tasker::WorkflowStep.find(workflow_step_id)
+      end
+
+      def task
+        @task ||= Tasker::Task.find(task_id)
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_based_system_health_counts.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Wrapper for the get_system_health_counts_v01 SQL function
+    #
+    # This function provides comprehensive system health metrics in a single query,
+    # returning counts for tasks, steps, retry states, and database connections.
+    #
+    # @example Basic usage
+    #   health_data = Tasker::Functions::FunctionBasedSystemHealthCounts.call
+    #   puts health_data.total_tasks
+    #   puts health_data.active_connections
+    #
+    # @example Error handling
+    #   begin
+    #     health_data = Tasker::Functions::FunctionBasedSystemHealthCounts.call
+    #   rescue ActiveRecord::StatementInvalid => e
+    #     Rails.logger.error "Health check failed: #{e.message}"
+    #   end
+    class FunctionBasedSystemHealthCounts < FunctionWrapper
+      # Health metrics result structure
+      class HealthMetrics < Dry::Struct
+        # Task counts
+        attribute :total_tasks, Types::Integer
+        attribute :pending_tasks, Types::Integer
+        attribute :in_progress_tasks, Types::Integer
+        attribute :complete_tasks, Types::Integer
+        attribute :error_tasks, Types::Integer
+        attribute :cancelled_tasks, Types::Integer
+
+        # Step counts
+        attribute :total_steps, Types::Integer
+        attribute :pending_steps, Types::Integer
+        attribute :in_progress_steps, Types::Integer
+        attribute :complete_steps, Types::Integer
+        attribute :error_steps, Types::Integer
+
+        # Retry-specific counts
+        attribute :retryable_error_steps, Types::Integer
+        attribute :exhausted_retry_steps, Types::Integer
+        attribute :in_backoff_steps, Types::Integer
+
+        # Database metrics
+        attribute :active_connections, Types::Integer
+        attribute :max_connections, Types::Integer
+      end
+
+      # Call the get_system_health_counts_v01 SQL function
+      #
+      # @return [HealthMetrics] Health metrics with all system counts
+      # @raise [ActiveRecord::StatementInvalid] If the SQL function fails
+      def self.call
+        sql = 'SELECT * FROM get_system_health_counts_v01()'
+        result = connection.select_all(sql, 'SystemHealthCounts Load')
+
+        if result.empty?
+          # Return zero values if no data (shouldn't happen but defensive)
+          HealthMetrics.new(
+            total_tasks: 0, pending_tasks: 0, in_progress_tasks: 0,
+            complete_tasks: 0, error_tasks: 0, cancelled_tasks: 0,
+            total_steps: 0, pending_steps: 0, in_progress_steps: 0,
+            complete_steps: 0, error_steps: 0, retryable_error_steps: 0,
+            exhausted_retry_steps: 0, in_backoff_steps: 0,
+            active_connections: 0, max_connections: 0
+          )
+        else
+          # Convert the result to a structured HealthMetrics object
+          row = result.first
+          HealthMetrics.new(
+            total_tasks: row['total_tasks'].to_i,
+            pending_tasks: row['pending_tasks'].to_i,
+            in_progress_tasks: row['in_progress_tasks'].to_i,
+            complete_tasks: row['complete_tasks'].to_i,
+            error_tasks: row['error_tasks'].to_i,
+            cancelled_tasks: row['cancelled_tasks'].to_i,
+            total_steps: row['total_steps'].to_i,
+            pending_steps: row['pending_steps'].to_i,
+            in_progress_steps: row['in_progress_steps'].to_i,
+            complete_steps: row['complete_steps'].to_i,
+            error_steps: row['error_steps'].to_i,
+            retryable_error_steps: row['retryable_error_steps'].to_i,
+            exhausted_retry_steps: row['exhausted_retry_steps'].to_i,
+            in_backoff_steps: row['in_backoff_steps'].to_i,
+            active_connections: row['active_connections'].to_i,
+            max_connections: row['max_connections'].to_i
+          )
+        end
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_based_task_execution_context.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require_relative 'function_wrapper'
+
+module Tasker
+  module Functions
+    # Function-based implementation of TaskExecutionContext
+    # Maintains the same interface as the view-based model but uses SQL functions for performance
+    class FunctionBasedTaskExecutionContext < FunctionWrapper
+      # Define attributes to match the SQL function output
+      attribute :task_id, :integer
+      attribute :named_task_id, :integer
+      attribute :status, :string
+      attribute :total_steps, :integer
+      attribute :pending_steps, :integer
+      attribute :in_progress_steps, :integer
+      attribute :completed_steps, :integer
+      attribute :failed_steps, :integer
+      attribute :ready_steps, :integer
+      attribute :execution_status, :string
+      attribute :recommended_action, :string
+      attribute :completion_percentage, :decimal
+      attribute :health_status, :string
+
+      # Class methods that use SQL functions
+      def self.find(task_id)
+        sql = 'SELECT * FROM get_task_execution_context($1::BIGINT)'
+        binds = [task_id]
+        single_from_sql_function(sql, binds, 'TaskExecutionContext Load')
+      end
+
+      def self.for_tasks(task_ids)
+        return [] if task_ids.empty?
+
+        # Use the batch function to avoid N+1 queries
+        sql = 'SELECT * FROM get_task_execution_contexts_batch($1::BIGINT[])'
+        binds = [task_ids]
+        from_sql_function(sql, binds, 'TaskExecutionContext Batch Load')
+      end
+
+      # Helper methods for workflow decision making (same as original model)
+      def has_work_to_do?
+        Constants::ACTIONABLE_TASK_EXECUTION_STATUSES.include?(execution_status) ||
+          execution_status == Constants::TaskExecution::ExecutionStatus::PROCESSING
+      end
+
+      def is_blocked?
+        execution_status == Constants::TaskExecution::ExecutionStatus::BLOCKED_BY_FAILURES
+      end
+
+      def is_complete?
+        execution_status == Constants::TaskExecution::ExecutionStatus::ALL_COMPLETE
+      end
+
+      def is_healthy?
+        health_status == Constants::TaskExecution::HealthStatus::HEALTHY
+      end
+
+      def needs_intervention?
+        health_status == Constants::TaskExecution::HealthStatus::BLOCKED
+      end
+
+      def can_make_progress?
+        ready_steps.positive?
+      end
+
+      def should_reenqueue?
+        Constants::REENQUEUE_TASK_EXECUTION_STATUSES.include?(execution_status)
+      end
+
+      def needs_immediate_action?
+        Constants::ACTIONABLE_TASK_EXECUTION_STATUSES.include?(execution_status)
+      end
+
+      # Status summary methods (same as original model)
+      def workflow_summary
+        {
+          total_steps: total_steps,
+          completed: completed_steps,
+          pending: pending_steps,
+          in_progress: in_progress_steps,
+          failed: failed_steps,
+          ready: ready_steps,
+          completion_percentage: completion_percentage,
+          status: execution_status,
+          health: health_status,
+          recommended_action: recommended_action,
+          progress_details: progress_details
+        }
+      end
+
+      def progress_details
+        {
+          completed_ratio: "#{completed_steps}/#{total_steps}",
+          completion_percentage: "#{completion_percentage}%",
+          remaining_steps: total_steps - completed_steps,
+          failed_steps: failed_steps,
+          ready_steps: ready_steps
+        }
+      end
+
+      def next_action_details
+        case recommended_action
+        when Constants::TaskExecution::RecommendedAction::EXECUTE_READY_STEPS
+          {
+            action: Constants::TaskExecution::RecommendedAction::EXECUTE_READY_STEPS,
+            description: "#{ready_steps} steps ready for execution",
+            urgency: 'high',
+            can_proceed: true
+          }
+        when Constants::TaskExecution::RecommendedAction::WAIT_FOR_COMPLETION
+          {
+            action: Constants::TaskExecution::RecommendedAction::WAIT_FOR_COMPLETION,
+            description: "#{in_progress_steps} steps currently processing",
+            urgency: 'low',
+            can_proceed: false
+          }
+        when Constants::TaskExecution::RecommendedAction::HANDLE_FAILURES
+          {
+            action: Constants::TaskExecution::RecommendedAction::HANDLE_FAILURES,
+            description: "#{failed_steps} failed steps blocking progress",
+            urgency: 'critical',
+            can_proceed: false
+          }
+        when Constants::TaskExecution::RecommendedAction::FINALIZE_TASK
+          {
+            action: Constants::TaskExecution::RecommendedAction::FINALIZE_TASK,
+            description: 'All steps completed successfully',
+            urgency: 'medium',
+            can_proceed: true
+          }
+        else
+          {
+            action: Constants::TaskExecution::RecommendedAction::WAIT_FOR_DEPENDENCIES,
+            description: 'Waiting for dependencies to be satisfied',
+            urgency: 'low',
+            can_proceed: false
+          }
+        end
+      end
+
+      # Association (lazy-loaded)
+      def task
+        @task ||= Tasker::Task.find(task_id)
+      end
+    end
+  end
+end

data/lib/tasker/functions/function_wrapper.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Tasker
+  module Functions
+    # Utility class for wrapping SQL function results in ActiveRecord-like objects
+    class FunctionWrapper
+      include ActiveModel::Model
+      include ActiveModel::Attributes
+
+      def self.from_sql_function(sql, binds = [], name = nil)
+        # Convert Ruby arrays to PostgreSQL array format for bind parameters
+        processed_binds = binds.map { |bind| convert_array_bind(bind) }
+        results = connection.select_all(sql, name, processed_binds)
+        results.map { |row| new(row) }
+      end
+
+      def self.single_from_sql_function(sql, binds = [], name = nil)
+        # Convert Ruby arrays to PostgreSQL array format for bind parameters
+        processed_binds = binds.map { |bind| convert_array_bind(bind) }
+        result = connection.select_one(sql, name, processed_binds)
+        result ? new(result) : nil
+      end
+
+      def self.convert_array_bind(bind)
+        if bind.is_a?(Array)
+          # Convert Ruby array to PostgreSQL array format
+          "{#{bind.join(',')}}"
+        else
+          bind
+        end
+      end
+
+      def readonly?
+        true
+      end
+
+      def self.connection
+        ::Tasker::ApplicationRecord.connection
+      end
+    end
+  end
+end

data/lib/tasker/functions.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative 'functions/function_wrapper'
+require_relative 'functions/function_based_step_readiness_status'
+require_relative 'functions/function_based_task_execution_context'
+require_relative 'functions/function_based_system_health_counts'
+
+module Tasker
+  module Functions
+    # base module for functions
+  end
+end