tasker-engine 1.0.0

data/app/models/tasker/workflow_step.rb

@@ -0,0 +1,461 @@
+# typed: false
+# frozen_string_literal: true
+
+require_relative '../../../lib/tasker/state_machine/step_state_machine'
+
+module Tasker
+  class WorkflowStep < ApplicationRecord
+    PROVIDES_EDGE_NAME = 'provides'
+
+    self.primary_key = :workflow_step_id
+    belongs_to :task
+    belongs_to :named_step
+    # belongs_to :depends_on_step, class_name: 'WorkflowStep', optional: true
+    has_many  :incoming_edges,
+              class_name: 'WorkflowStepEdge',
+              foreign_key: :to_step_id,
+              dependent: :destroy,
+              inverse_of: :to_step
+    has_many  :outgoing_edges,
+              class_name: 'WorkflowStepEdge',
+              foreign_key:
+              :from_step_id,
+              dependent: :destroy,
+              inverse_of: :from_step
+    has_many :parents, through: :incoming_edges, source: :from_step
+    has_many :children, through: :outgoing_edges, source: :to_step
+    has_many :siblings, through: :outgoing_edges, source: :from_step
+    has_many :workflow_step_transitions, inverse_of: :workflow_step, dependent: :destroy
+
+    validates :named_step_id, uniqueness: { scope: :task_id, message: 'must be unique within the same task' }
+    validate :name_uniqueness_within_task
+
+    delegate :name, to: :named_step
+
+    has_one :step_dag_relationship, class_name: 'Tasker::StepDagRelationship', primary_key: :workflow_step_id
+    # NOTE: step_readiness_status is now accessed via function-based approach, not ActiveRecord association
+
+    # Optimized scopes for efficient querying using state machine transitions
+    scope :completed, lambda {
+      joins(:workflow_step_transitions)
+        .where(
+          workflow_step_transitions: {
+            most_recent: true,
+            to_state: [
+              Constants::WorkflowStepStatuses::COMPLETE,
+              Constants::WorkflowStepStatuses::RESOLVED_MANUALLY
+            ]
+          }
+        )
+    }
+
+    scope :failed, lambda {
+      joins(:workflow_step_transitions)
+        .where(
+          workflow_step_transitions: {
+            most_recent: true,
+            to_state: Constants::WorkflowStepStatuses::ERROR
+          }
+        )
+    }
+
+    scope :pending, lambda {
+      # Include steps with no transitions (initial state) AND steps with pending/in_progress transitions
+      where.missing(:workflow_step_transitions)
+           .or(
+             joins(:workflow_step_transitions)
+               .where(
+                 workflow_step_transitions: {
+                   most_recent: true,
+                   to_state: [
+                     Constants::WorkflowStepStatuses::PENDING,
+                     Constants::WorkflowStepStatuses::IN_PROGRESS
+                   ]
+                 }
+               )
+           )
+    }
+
+    scope :for_task, lambda { |task|
+      where(task_id: task.task_id)
+    }
+
+    # Scopes workflow steps by their current state using state machine transitions
+    #
+    # @scope class
+    # @param state [String, nil] The state to filter by. If nil, returns all steps with current state information
+    # @return [ActiveRecord::Relation] Steps with current state, optionally filtered by specific state
+    scope :by_current_state, lambda { |state = nil|
+      relation = joins(<<-SQL.squish)
+        INNER JOIN (
+          SELECT DISTINCT ON (workflow_step_id) workflow_step_id, to_state
+          FROM tasker_workflow_step_transitions
+          WHERE most_recent = true
+          ORDER BY workflow_step_id, sort_key DESC
+        ) current_transitions ON current_transitions.workflow_step_id = tasker_workflow_steps.workflow_step_id
+      SQL
+
+      if state.present?
+        relation.where(current_transitions: { to_state: state })
+      else
+        relation
+      end
+    }
+
+    # Scopes workflow steps completed since a specific time
+    #
+    # @scope class
+    # @param since_time [Time] The earliest completion time to include
+    # @return [ActiveRecord::Relation] Steps completed since the specified time
+    scope :completed_since, lambda { |since_time|
+      joins(:workflow_step_transitions)
+        .where('tasker_workflow_step_transitions.most_recent = ? AND tasker_workflow_step_transitions.to_state = ?', true, 'complete')
+        .where('tasker_workflow_step_transitions.created_at > ?', since_time)
+    }
+
+    # Scopes workflow steps that failed since a specific time
+    #
+    # @scope class
+    # @param since_time [Time] The earliest failure time to include
+    # @return [ActiveRecord::Relation] Steps that failed since the specified time
+    scope :failed_since, lambda { |since_time|
+      joins(:workflow_step_transitions)
+        .where('tasker_workflow_step_transitions.most_recent = ? AND tasker_workflow_step_transitions.to_state = ?', true, 'error')
+        .where('tasker_workflow_step_transitions.created_at > ?', since_time)
+    }
+
+    # Scopes workflow steps for tasks created since a specific time
+    #
+    # @scope class
+    # @param since_time [Time] The earliest task creation time to include
+    # @return [ActiveRecord::Relation] Steps for tasks created since the specified time
+    scope :for_tasks_since, lambda { |since_time|
+      joins(:task).where('tasker_tasks.created_at > ?', since_time)
+    }
+
+    # Efficient method to get task completion statistics using ActiveRecord scopes
+    # This avoids the N+1 query problem while working with the state machine system
+    #
+    # @param task [Task] The task to analyze
+    # @return [Hash] Hash with completion statistics and latest completion time
+    def self.task_completion_stats(task)
+      # Use efficient ActiveRecord queries with the state machine
+      task_steps = for_task(task)
+
+      # Get completion statistics with optimized queries
+      total_steps = task_steps.count
+      completed_steps = task_steps.completed
+      failed_steps = task_steps.failed
+
+      # Calculate counts
+      completed_count = completed_steps.count
+      failed_count = failed_steps.count
+
+      # For pending count, calculate as total minus completed and failed
+      # This handles the case where new steps don't have transitions yet
+      pending_count = total_steps - completed_count - failed_count
+
+      # Get latest completion time from completed steps
+      latest_completion_time = completed_steps.maximum(:processed_at)
+
+      {
+        total_steps: total_steps,
+        completed_steps: completed_count,
+        failed_steps: failed_count,
+        pending_steps: pending_count,
+        latest_completion_time: latest_completion_time,
+        all_complete: completed_count == total_steps && total_steps.positive?
+      }
+    end
+
+    # State machine integration
+    def state_machine
+      @state_machine ||= Tasker::StateMachine::StepStateMachine.new(
+        self,
+        transition_class: Tasker::WorkflowStepTransition,
+        association_name: :workflow_step_transitions
+      )
+    end
+
+    # Status is now entirely managed by the state machine
+    def status
+      if new_record?
+        # For new records, return the initial state
+        Tasker::Constants::WorkflowStepStatuses::PENDING
+      else
+        # For persisted records, use state machine
+        state_machine.current_state
+      end
+    end
+
+    # Finds a WorkflowStep with the given name by traversing the DAG efficiently
+    # @param steps [Array<WorkflowStep>] Collection of steps to search through
+    # @param name [String] Name of the step to find
+    # @return [WorkflowStep, nil] The first matching step found or nil if none exists
+    def self.find_step_by_name(steps, name)
+      StepFinder.find_by_name(steps, name)
+    end
+
+    # Service class to find steps by name
+    # Reduces complexity by organizing step search logic
+    class StepFinder
+      class << self
+        # Find step by name in provided collection or task hierarchy
+        #
+        # @param steps [Array<WorkflowStep>] Collection of steps to search through
+        # @param name [String] Name of the step to find
+        # @return [WorkflowStep, nil] The first matching step found or nil if none exists
+        def find_by_name(steps, name)
+          return nil if steps.empty? || name.nil?
+
+          # First check direct match in provided steps
+          direct_match = find_direct_match(steps, name)
+          return direct_match if direct_match
+
+          # Fall back to task-wide search using DAG relationships
+          find_in_task_hierarchy(steps, name)
+        end
+
+        private
+
+        # Find direct match in provided steps
+        #
+        # @param steps [Array<WorkflowStep>] Collection of steps
+        # @param name [String] Name to search for
+        # @return [WorkflowStep, nil] Matching step or nil
+        def find_direct_match(steps, name)
+          steps.find { |step| step.name == name }
+        end
+
+        # Find step in task hierarchy using efficient DAG traversal
+        #
+        # @param steps [Array<WorkflowStep>] Collection of steps to get task context
+        # @param name [String] Name to search for
+        # @return [WorkflowStep, nil] Matching step or nil
+        def find_in_task_hierarchy(steps, name)
+          task_ids = extract_task_ids(steps)
+
+          task_ids.each do |task_id|
+            found_step = find_in_single_task(task_id, name)
+            return found_step if found_step
+          end
+
+          nil
+        end
+
+        # Extract unique task IDs from steps
+        #
+        # @param steps [Array<WorkflowStep>] Collection of steps
+        # @return [Array<Integer>] Unique task IDs
+        def extract_task_ids(steps)
+          steps.map(&:task_id).uniq
+        end
+
+        # Find step by name in a single task
+        #
+        # @param task_id [Integer] Task ID to search in
+        # @param name [String] Name to search for
+        # @return [WorkflowStep, nil] Matching step or nil
+        def find_in_single_task(task_id, name)
+          # Get all workflow steps for this task with their DAG relationships
+          all_task_steps = WorkflowStep.joins(:named_step)
+                                       .includes(:step_dag_relationship)
+                                       .where(task_id: task_id)
+
+          # Find step by name using simple lookup instead of recursive traversal
+          all_task_steps.joins(:named_step)
+                        .find_by(named_steps: { name: name })
+        end
+      end
+    end
+
+    def self.get_steps_for_task(task, templates)
+      named_steps = NamedStep.create_named_steps_from_templates(templates)
+      steps =
+        templates.map do |template|
+          named_step = named_steps.find { |ns| template.name == ns.name }
+          NamedTasksNamedStep.associate_named_step_with_named_task(task.named_task, template, named_step)
+          step = where(task_id: task.task_id, named_step_id: named_step.named_step_id).first
+          step ||= build_default_step!(task, template, named_step)
+          step
+        end
+      set_up_dependent_steps(steps, templates)
+    end
+
+    def self.set_up_dependent_steps(steps, templates)
+      templates.each do |template|
+        next if template.all_dependencies.empty?
+
+        dependent_step = steps.find { |step| step.name == template.name }
+        template.all_dependencies.each do |dependency|
+          provider_step = steps.find { |step| step.name == dependency }
+          unless provider_step.outgoing_edges.exists?(to_step: dependent_step)
+            provider_step.add_provides_edge!(dependent_step)
+          end
+        end
+      end
+      steps
+    end
+
+    def self.build_default_step!(task, template, named_step)
+      # Create the step first without status
+      step_attributes = {
+        task_id: task.task_id,
+        named_step_id: named_step.named_step_id,
+        retryable: template.default_retryable,
+        retry_limit: template.default_retry_limit,
+        skippable: template.skippable,
+        in_process: false,
+        inputs: task.context,
+        processed: false,
+        attempts: 0,
+        results: {}
+      }
+
+      step = new(step_attributes)
+      step.save!
+
+      # REMOVED: Automatic state machine initialization to prevent duplicate key violations
+      # The state machine will initialize naturally when accessed, and factories may
+      # have already created transitions through their own setup
+      # step.state_machine.initialize_state_machine!
+
+      step
+    end
+
+    def self.get_viable_steps(task, sequence)
+      # Get step IDs from sequence
+      step_ids = sequence.steps.map(&:workflow_step_id)
+
+      # Use function-based approach for high-performance readiness checking
+      ready_statuses = StepReadinessStatus.for_task(task.task_id, step_ids)
+      ready_step_ids = ready_statuses.select(&:ready_for_execution).map(&:workflow_step_id)
+
+      # Return WorkflowStep objects for ready steps
+      WorkflowStep.where(workflow_step_id: ready_step_ids)
+                  .includes(:named_step)
+    end
+
+    def add_provides_edge!(to_step)
+      outgoing_edges.create!(to_step: to_step, name: PROVIDES_EDGE_NAME)
+    end
+
+    # Helper method to get step readiness status using function-based approach
+    def step_readiness_status
+      @step_readiness_status ||= StepReadinessStatus.for_task(task_id, [workflow_step_id]).first
+    end
+
+    def complete?
+      # Use function-based approach for consistent state checking
+      step_readiness_status&.current_state&.in?([
+                                                  Constants::WorkflowStepStatuses::COMPLETE,
+                                                  Constants::WorkflowStepStatuses::RESOLVED_MANUALLY
+                                                ]) || false
+    end
+
+    def in_progress?
+      # Use function-based approach for consistent state checking
+      step_readiness_status&.current_state == Constants::WorkflowStepStatuses::IN_PROGRESS
+    end
+
+    def pending?
+      # Use function-based approach for consistent state checking
+      step_readiness_status&.current_state == Constants::WorkflowStepStatuses::PENDING
+    end
+
+    def in_error?
+      # Use function-based approach for consistent state checking
+      step_readiness_status&.current_state == Constants::WorkflowStepStatuses::ERROR
+    end
+
+    def cancelled?
+      # Use function-based approach for consistent state checking
+      step_readiness_status&.current_state == Constants::WorkflowStepStatuses::CANCELLED
+    end
+
+    def ready_status?
+      # Use function-based approach for efficient ready status checking
+      Constants::UNREADY_WORKFLOW_STEP_STATUSES.exclude?(
+        step_readiness_status&.current_state || Constants::WorkflowStepStatuses::PENDING
+      )
+    end
+
+    def ready?
+      # Use function-based approach's comprehensive readiness calculation
+      step_readiness_status&.ready_for_execution || false
+    end
+
+    # Function-based predicate methods
+    def dependencies_satisfied?
+      # Use function-based approach's pre-calculated dependency analysis
+      step_readiness_status&.dependencies_satisfied || false
+    end
+
+    def retry_eligible?
+      # Use function-based approach's retry/backoff calculation
+      step_readiness_status&.retry_eligible || false
+    end
+
+    def has_retry_attempts?
+      # Check if step has made retry attempts
+      (step_readiness_status&.attempts || 0).positive?
+    end
+
+    def retry_exhausted?
+      # Check if step has exhausted retry attempts
+      return false unless step_readiness_status
+
+      attempts = step_readiness_status.attempts || 0
+      retry_limit = step_readiness_status.retry_limit || 3
+      attempts >= retry_limit
+    end
+
+    def waiting_for_backoff?
+      # Check if step is waiting for backoff period to expire
+      return false unless step_readiness_status&.next_retry_at
+
+      step_readiness_status.next_retry_at > Time.current
+    end
+
+    def can_retry_now?
+      # Comprehensive check if step can be retried right now
+      return false unless in_error?
+      return false unless retry_eligible?
+      return false if waiting_for_backoff?
+
+      true
+    end
+
+    def root_step?
+      # Check if this is a root step (no dependencies)
+      (step_readiness_status&.total_parents || 0).zero?
+    end
+
+    def leaf_step?
+      # Check if this is a leaf step using DAG relationship view
+      step_dag_relationship&.child_count&.zero?
+    end
+
+    def reload
+      # Override reload to ensure step readiness status is refreshed
+      super.tap do
+        @step_readiness_status = nil # Reset cached readiness status
+      end
+    end
+
+    private
+
+    # Custom validation to ensure step names are unique within a task
+    def name_uniqueness_within_task
+      return unless named_step && task
+
+      # Find all steps within the same task that have the same name
+      matching_steps = self.class.where(task_id: task_id)
+                           .joins(:named_step)
+                           .where(named_step: { name: name })
+                           .where.not(workflow_step_id: workflow_step_id) # Exclude self when updating
+
+      errors.add(:base, "Step name '#{name}' must be unique within the same task") if matching_steps.exists?
+    end
+  end
+end

data/app/models/tasker/workflow_step_edge.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Tasker
+  class WorkflowStepEdge < ApplicationRecord
+    belongs_to :from_step, class_name: 'WorkflowStep'
+    belongs_to :to_step, class_name: 'WorkflowStep'
+
+    validates :name, presence: true
+
+    before_create :ensure_no_cycles!
+
+    scope :children_of, ->(step) { where(from_step: step) }
+    scope :parents_of, ->(step) { where(to_step: step) }
+    scope :siblings_of, ->(step) { find_by_sql(sibling_sql(step.id)) }
+    scope :provides_edges, -> { where(name: WorkflowStep::PROVIDES_EDGE_NAME) }
+    scope :provides_to_children, -> { where(name: WorkflowStep::PROVIDES_EDGE_NAME, to_step: children_of(from_step)) }
+
+    def self.create_edge!(from_step, to_step, name)
+      create!(from_step: from_step, to_step: to_step, name: name)
+    end
+
+    def self.sibling_sql(step_id)
+      <<~SQL.squish
+        WITH step_parents AS (
+          SELECT from_step_id
+          FROM tasker_workflow_step_edges
+          WHERE to_step_id = #{step_id}
+        ),
+        potential_siblings AS (
+          SELECT to_step_id
+          FROM tasker_workflow_step_edges
+          WHERE from_step_id IN (SELECT from_step_id FROM step_parents)
+          AND to_step_id != #{step_id}
+        ),
+        siblings AS (
+          SELECT to_step_id
+          FROM tasker_workflow_step_edges
+          WHERE to_step_id IN (SELECT to_step_id FROM potential_siblings)
+          GROUP BY to_step_id
+          HAVING ARRAY_AGG(from_step_id ORDER BY from_step_id) =
+                (SELECT ARRAY_AGG(from_step_id ORDER BY from_step_id) FROM step_parents)
+        )
+        SELECT e.*
+        FROM tasker_workflow_step_edges e
+        JOIN siblings ON e.to_step_id = siblings.to_step_id
+      SQL
+    end
+
+    private
+
+    def ensure_no_cycles!
+      return unless from_step && to_step
+
+      # Check for direct cycles first (A->B, B->A)
+      if self.class.exists?(from_step: to_step, to_step: from_step)
+        raise ActiveRecord::RecordInvalid.new(self), 'Adding this edge would create a cycle in the workflow'
+      end
+
+      # Check for indirect cycles (A->B->C->A)
+      # Use a recursive CTE that includes our new edge
+      cycle_sql = <<~SQL
+        WITH RECURSIVE all_edges AS (
+          -- Combine existing edges with our new edge
+          SELECT from_step_id, to_step_id
+          FROM tasker_workflow_step_edges
+          UNION ALL
+          SELECT #{from_step.id}::bigint, #{to_step.id}::bigint
+        ),
+        path AS (
+          -- Start with edges from to_step
+          SELECT from_step_id, to_step_id, ARRAY[from_step_id] as path
+          FROM all_edges
+          WHERE from_step_id = #{to_step.id}::bigint
+
+          UNION ALL
+
+          -- Follow edges recursively
+          SELECT e.from_step_id, e.to_step_id, p.path || e.from_step_id
+          FROM all_edges e
+          JOIN path p ON e.from_step_id = p.to_step_id
+          WHERE NOT e.from_step_id = ANY(p.path) -- Avoid cycles in traversal
+        )
+        SELECT COUNT(*) as cycle_count
+        FROM path
+        WHERE to_step_id = #{from_step.id}::bigint
+      SQL
+
+      result = self.class.connection.execute(cycle_sql).first
+      if result['cycle_count'].to_i > 0 # rubocop:disable Style/NumericPredicate,Style/GuardClause
+        raise ActiveRecord::RecordInvalid.new(self), 'Adding this edge would create a cycle in the workflow'
+      end
+    end
+  end
+end