activejob-temporal 0.1.0

data/lib/activejob/temporal/workflows/dead_letter_workflow.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require "time"
+require "temporalio/workflow"
+
+module ActiveJob
+  module Temporal
+    module Workflows
+      class DeadLetterWorkflow < Temporalio::Workflow::Definition
+        workflow_name :ActiveJobTemporalDeadLetterWorkflow
+
+        workflow_query_attr_reader :entry
+
+        workflow_signal
+        def mark_retried(retry_workflow_id)
+          if @entry
+            mark_retried_entry(retry_workflow_id)
+          else
+            @pending_action = [:retried, retry_workflow_id]
+          end
+        end
+
+        workflow_signal
+        def discard(reason = nil)
+          if @entry
+            mark_discarded_entry(reason)
+          else
+            @pending_action = [:discarded, reason]
+          end
+        end
+
+        def execute(entry)
+          @entry = deep_stringify(entry)
+          apply_pending_action
+          wait_until_terminal_or_expired
+          @entry
+        end
+
+        private
+
+        def wait_until_terminal_or_expired
+          auto_discard_after = auto_discard_after_seconds
+          return Temporalio::Workflow.wait_condition { terminal? } unless auto_discard_after
+
+          begin
+            Temporalio::Workflow.timeout(
+              auto_discard_after,
+              Timeout::Error,
+              "dead letter auto-discard expired",
+              summary: "Dead letter auto-discard"
+            ) do
+              Temporalio::Workflow.wait_condition { terminal? }
+            end
+          rescue Timeout::Error
+            mark_discarded_entry("auto_discard_after_expired")
+          end
+        end
+
+        def auto_discard_after_seconds
+          value = @entry.dig("metadata", "auto_discard_after_seconds")
+          return if value.nil?
+
+          seconds = Float(value)
+          seconds if seconds.positive?
+        rescue ArgumentError, TypeError
+          nil
+        end
+
+        def apply_pending_action
+          action, value = @pending_action
+          @pending_action = nil
+
+          case action
+          when :retried then mark_retried_entry(value)
+          when :discarded then mark_discarded_entry(value)
+          end
+        end
+
+        def mark_retried_entry(retry_workflow_id)
+          return if terminal?
+
+          @entry["state"] = "retried"
+          @entry["retry_workflow_id"] = retry_workflow_id
+          @entry["retried_at"] = Temporalio::Workflow.now.iso8601
+        end
+
+        def mark_discarded_entry(reason)
+          return if terminal?
+
+          @entry["state"] = "discarded"
+          @entry["discard_reason"] = reason if reason
+          @entry["discarded_at"] = Temporalio::Workflow.now.iso8601
+        end
+
+        def terminal?
+          %w[retried discarded].include?(@entry&.fetch("state", nil))
+        end
+
+        def deep_stringify(value)
+          case value
+          when Hash
+            value.each_with_object({}) do |(key, entry_value), hash|
+              hash[key.to_s] = deep_stringify(entry_value)
+            end
+          when Array
+            value.map { |entry_value| deep_stringify(entry_value) }
+          else
+            value
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activejob/temporal/workflows/workflow_chaining.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+require_relative "../activities/aj_runner_activity"
+
+module ActiveJob
+  module Temporal
+    module Workflows
+      module WorkflowChaining
+        WORKFLOW_CONTROL_FIELDS = %i[
+          default_activity_options
+          retry_policy
+          temporal_options
+          dead_letter
+          rate_limits
+          activity_task_queue
+          local_activity_helpers
+        ].freeze
+
+        private
+
+        def execute_activity_sequence(payload)
+          result = execute_activity_payload(payload)
+          execute_chain_sequence(payload, result) do |chain_payload|
+            yield chain_payload if block_given?
+          end
+        end
+
+        def execute_chain_sequence(payload, result)
+          chain_payloads(payload).each_with_index do |chain_payload, index|
+            workflow_state["chain_index"] = index + 1
+            if external_operation_payload?(chain_payload)
+              yield chain_payload if block_given?
+              result = execute_external_operation(chain_payload, result)
+            else
+              raw_arguments = [result]
+              activity_payload = payload_with_raw_arguments(chain_payload, raw_arguments)
+              yield activity_payload if block_given?
+              result = execute_activity_payload(activity_payload, raw_arguments: raw_arguments)
+            end
+          end
+          result
+        ensure
+          workflow_state.delete("chain_index")
+        end
+
+        def execute_activity_payload(payload, raw_arguments: nil)
+          wait_for_rate_limit(payload)
+          wait_while_paused
+
+          workflow_state["phase"] = "running_activity"
+          Temporalio::Workflow.execute_activity(
+            *activity_arguments(payload, raw_arguments),
+            **activity_options(payload)
+          )
+        end
+
+        def activity_arguments(payload, raw_arguments)
+          arguments = [
+            ActiveJob::Temporal::Activities::AjRunnerActivity,
+            payload
+          ]
+          arguments << raw_arguments unless raw_arguments.nil?
+          arguments
+        end
+
+        def execute_external_operation(payload, input)
+          case payload_value(payload, :temporal_operation)
+          when "activity" then execute_external_activity(payload, input)
+          when "workflow" then execute_external_workflow(payload, input)
+          else raise ArgumentError, "external Temporal operation must be activity or workflow"
+          end
+        end
+
+        def execute_external_activity(payload, input)
+          wait_while_paused
+          workflow_state["phase"] = "running_activity"
+          Temporalio::Workflow.execute_activity(
+            payload_value(payload, :temporal_type),
+            input,
+            **external_operation_options(payload)
+          )
+        end
+
+        def execute_external_workflow(payload, input)
+          wait_while_paused
+          workflow_state["phase"] = "running_child_workflow"
+          Temporalio::Workflow.execute_child_workflow(
+            payload_value(payload, :temporal_type),
+            input,
+            **external_operation_options(payload)
+          )
+        end
+
+        def chain_payloads(payload)
+          Array(payload[:chain] || payload["chain"]).each_with_index.map do |chain_step, index|
+            chain_step_payload(payload, chain_step, index + 1)
+          end
+        end
+
+        def chain_step_payload(root_payload, chain_step, position)
+          return normalize_external_operation_payload(chain_step) if external_operation_payload?(chain_step)
+          return normalize_chain_step_payload(chain_step) if full_chain_step_payload?(chain_step)
+
+          options = chain_step_options(chain_step)
+          payload = base_chain_step_payload(root_payload, chain_step, options, position)
+
+          copy_workflow_control_fields(root_payload, payload)
+          payload.merge!(options)
+          payload
+        end
+
+        def full_chain_step_payload?(chain_step)
+          payload_value(chain_step, :job_id) &&
+            payload_value(chain_step, :queue_name) &&
+            !payload_value(chain_step, :arguments).nil?
+        end
+
+        def normalize_chain_step_payload(chain_step)
+          chain_step.each_with_object({}) do |(key, value), normalized|
+            normalized[key.to_s] = value
+          end
+        end
+
+        def normalize_external_operation_payload(operation_payload)
+          {
+            "temporal_operation" => payload_value(operation_payload, :temporal_operation),
+            "temporal_type" => payload_value(operation_payload, :temporal_type),
+            "options" => external_operation_options(operation_payload)
+          }
+        end
+
+        def base_chain_step_payload(root_payload, chain_step, options, position)
+          {
+            "job_class" => payload_value(chain_step, :job_class),
+            "job_id" => "#{payload_value(root_payload, :job_id)}:chain:#{position}",
+            "queue_name" => (options["queue"] || "default").to_s,
+            "arguments" => [],
+            "executions" => 0,
+            "exception_executions" => {}
+          }
+        end
+
+        def chain_step_options(chain_step)
+          options = payload_value(chain_step, :options) || {}
+          options.each_with_object({}) do |(key, value), normalized|
+            normalized[key.to_s] = value
+          end
+        end
+
+        def copy_workflow_control_fields(source_payload, target_payload)
+          WORKFLOW_CONTROL_FIELDS.each do |key|
+            value = payload_value(source_payload, key)
+            next unless value
+
+            target_payload[key.to_s] = key == :dead_letter ? chain_dead_letter_metadata(value, target_payload) : value
+          end
+        end
+
+        def chain_dead_letter_metadata(metadata, payload)
+          metadata.transform_keys(&:to_s).merge(
+            "job_class" => payload.fetch("job_class"),
+            "job_id" => payload.fetch("job_id"),
+            "queue_name" => payload.fetch("queue_name")
+          )
+        end
+
+        def payload_value(payload, key)
+          payload[key] || payload[key.to_s]
+        end
+
+        def payload_with_raw_arguments(payload, raw_arguments)
+          key = payload.key?(:arguments) ? :arguments : "arguments"
+          payload.merge(key => raw_arguments)
+        end
+
+        def external_operation_payload?(payload)
+          payload_value(payload, :temporal_operation) && payload_value(payload, :temporal_type)
+        end
+
+        def external_operation_options(payload)
+          options = payload_value(payload, :options) || {}
+          options.each_with_object({}) do |(key, value), normalized|
+            normalized_key = key.to_sym
+            normalized[normalized_key] = if normalized_key == :retry_policy && value.is_a?(Hash)
+                                           build_retry_policy(value)
+                                         else
+                                           value
+                                         end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/activejob/temporal/workflows/workflow_child_workflows.rb

@@ -0,0 +1,140 @@
+# frozen_string_literal: true
+
+require "time"
+require "temporalio/search_attributes"
+require "temporalio/workflow"
+
+require_relative "../search_attributes"
+
+module ActiveJob
+  module Temporal
+    module Workflows
+      module WorkflowChildWorkflows
+        private
+
+        def execute_child_workflow_sequence(payload, parent_result)
+          child_payloads = child_workflow_payloads(payload)
+          return parent_result if child_payloads.empty?
+
+          workflow_state["phase"] = "running_child_workflows"
+          handles = start_child_job_workflows(child_payloads, parent_result)
+          child_results = collect_child_workflow_results(child_payloads, handles)
+
+          {
+            "parent_result" => parent_result,
+            "child_results" => child_results
+          }
+        ensure
+          workflow_state.delete("child_index")
+        end
+
+        def child_workflow_payloads(payload)
+          Array(payload[:child_workflows] || payload["child_workflows"])
+        end
+
+        def start_child_job_workflows(child_payloads, parent_result)
+          child_payloads.each_with_index.map do |child_payload, index|
+            workflow_state["child_index"] = index + 1
+            start_child_job_workflow(child_payload, parent_result)
+          end
+        end
+
+        def collect_child_workflow_results(child_payloads, handles)
+          handles.each_with_index.map do |handle, index|
+            workflow_state["child_index"] = index + 1
+            child_workflow_result(child_payloads.fetch(index), handle.result)
+          end
+        end
+
+        def start_child_job_workflow(child_payload, parent_result)
+          if external_operation_payload?(child_payload)
+            return start_external_child_workflow(child_payload, parent_result)
+          end
+
+          workflow_payload = child_payload_with_parent_result(child_payload, parent_result)
+          Temporalio::Workflow.start_child_workflow(
+            ActiveJob::Temporal::Workflows::AjWorkflow,
+            workflow_payload,
+            **child_workflow_options(workflow_payload)
+          )
+        end
+
+        def start_external_child_workflow(child_payload, parent_result)
+          Temporalio::Workflow.start_child_workflow(
+            payload_value(child_payload, :temporal_type),
+            parent_result,
+            **external_child_workflow_options(child_payload)
+          )
+        end
+
+        def child_workflow_options(child_payload)
+          task_queue = payload_value(child_payload, :workflow_task_queue) ||
+                       payload_value(child_payload, :activity_task_queue)
+          options = {
+            id: payload_value(child_payload, :workflow_id),
+            task_queue: task_queue,
+            parent_close_policy: Temporalio::Workflow::ParentClosePolicy::REQUEST_CANCEL,
+            cancellation_type: Temporalio::Workflow::ChildWorkflowCancellationType::WAIT_CANCELLATION_COMPLETED
+          }.compact
+          search_attributes = child_search_attributes(payload_value(child_payload, :search_attributes))
+          options[:search_attributes] = search_attributes if search_attributes
+          options
+        end
+
+        def external_child_workflow_options(child_payload)
+          external_operation_options(child_payload).merge(
+            parent_close_policy: Temporalio::Workflow::ParentClosePolicy::REQUEST_CANCEL,
+            cancellation_type: Temporalio::Workflow::ChildWorkflowCancellationType::WAIT_CANCELLATION_COMPLETED
+          )
+        end
+
+        def child_payload_with_parent_result(child_payload, parent_result)
+          key = child_payload.key?(:arguments) ? :arguments : "arguments"
+          child_payload.merge(key => [parent_result])
+        end
+
+        def child_workflow_result(child_payload, result)
+          return external_child_workflow_result(child_payload, result) if external_operation_payload?(child_payload)
+
+          {
+            "job_class" => payload_value(child_payload, :job_class),
+            "job_id" => payload_value(child_payload, :job_id),
+            "workflow_id" => payload_value(child_payload, :workflow_id),
+            "result" => result
+          }
+        end
+
+        def external_child_workflow_result(child_payload, result)
+          options = payload_value(child_payload, :options) || {}
+          {
+            "temporal_operation" => "workflow",
+            "temporal_type" => payload_value(child_payload, :temporal_type),
+            "workflow_id" => payload_value(options, :id),
+            "task_queue" => payload_value(options, :task_queue),
+            "result" => result
+          }.compact
+        end
+
+        def child_search_attributes(metadata)
+          return unless metadata
+
+          attributes = Temporalio::SearchAttributes.new
+          attributes[search_attribute_key(:aj_class)] = payload_value(metadata, :job_class)
+          attributes[search_attribute_key(:aj_queue)] = payload_value(metadata, :queue_name) || "default"
+          attributes[search_attribute_key(:aj_job_id)] = payload_value(metadata, :job_id)
+          attributes[search_attribute_key(:aj_enqueued_at)] = Time.iso8601(payload_value(metadata, :enqueued_at))
+
+          tags = Array(payload_value(metadata, :tags))
+          attributes[search_attribute_key(:aj_tags)] = tags if tags.any?
+          attributes
+        end
+
+        def search_attribute_key(key)
+          name, type = ActiveJob::Temporal::SearchAttributes::SEARCH_ATTRIBUTE_KEY_DEFINITIONS.fetch(key)
+          type_constant = Temporalio::SearchAttributes::IndexedValueType.const_get(type)
+          Temporalio::SearchAttributes::Key.new(name, type_constant)
+        end
+      end
+    end
+  end
+end

data/lib/activejob/temporal/workflows/workflow_continue_as_new.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Temporal
+    module Workflows
+      module WorkflowContinueAsNew
+        private
+
+        def continue_as_new_if_needed(payload)
+          return unless workflow_patch_enabled?(:continue_as_new)
+
+          continue_as_new_options = payload[:continue_as_new] || payload["continue_as_new"]
+          return unless continue_as_new_options
+          return unless continue_as_new_threshold_reached?(continue_as_new_options)
+
+          wait_for_continue_as_new_handlers
+          workflow_state["phase"] = "continuing_as_new"
+          raise Temporalio::Workflow::ContinueAsNewError.new(
+            continue_as_new_payload(payload),
+            search_attributes: Temporalio::Workflow.search_attributes
+          )
+        end
+
+        def continue_as_new_threshold_reached?(continue_as_new_options)
+          threshold = continue_as_new_options[:history_event_threshold] ||
+                      continue_as_new_options["history_event_threshold"]
+          return false unless threshold.to_i.positive?
+
+          Temporalio::Workflow.current_history_length >= threshold.to_i
+        end
+
+        def continue_as_new_payload(payload)
+          deep_copy(payload).merge("workflow_state" => deep_copy(workflow_state))
+        end
+
+        def wait_for_continue_as_new_handlers
+          return if Temporalio::Workflow.all_handlers_finished?
+
+          Temporalio::Workflow.wait_condition { Temporalio::Workflow.all_handlers_finished? }
+        end
+      end
+    end
+  end
+end

data/lib/activejob/temporal/workflows/workflow_dependencies.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+require "temporalio/error"
+
+require_relative "../activities/dependency_status_activity"
+
+module ActiveJob
+  module Temporal
+    module Workflows
+      module WorkflowDependencies
+        DEPENDENCY_CHECK_ACTIVITY_TIMEOUT = 30.0
+        DEPENDENCY_CHECK_RETRY_POLICY = Temporalio::RetryPolicy.new(max_attempts: 1)
+        DEPENDENCY_WAIT_INTERVAL = 10.0
+        DEPENDENCY_NOT_FOUND_MAX_CHECKS = 6
+        COMPLETED_DEPENDENCY_STATES = %w[completed].freeze
+        FAILED_DEPENDENCY_STATES = %w[failed canceled terminated timed_out unknown].freeze
+        NOT_FOUND_DEPENDENCY_STATES = %w[not_found].freeze
+
+        private
+
+        def wait_for_dependencies(payload)
+          dependencies = dependency_metadata(payload)
+          return if dependencies.empty?
+
+          workflow_state["phase"] = "waiting_dependencies"
+          not_found_counts = Hash.new(0)
+          loop do
+            wait_while_paused
+            statuses = check_dependency_statuses(dependencies)
+            expired_not_found_statuses = expired_not_found_statuses(statuses, not_found_counts)
+            failed_statuses = failed_dependency_statuses(statuses) + expired_not_found_statuses
+            fail_for_dependencies!(failed_statuses) if fail_on_dependency_failure?(payload) && failed_statuses.any?
+            break if dependencies_satisfied?(statuses, expired_not_found_statuses)
+
+            Temporalio::Workflow.sleep(DEPENDENCY_WAIT_INTERVAL)
+          end
+        end
+
+        def dependency_metadata(payload)
+          Array(payload[:dependencies] || payload["dependencies"])
+        end
+
+        def check_dependency_statuses(dependencies)
+          Temporalio::Workflow.execute_activity(
+            ActiveJob::Temporal::Activities::DependencyStatusActivity,
+            dependencies,
+            schedule_to_close_timeout: DEPENDENCY_CHECK_ACTIVITY_TIMEOUT,
+            start_to_close_timeout: DEPENDENCY_CHECK_ACTIVITY_TIMEOUT,
+            retry_policy: DEPENDENCY_CHECK_RETRY_POLICY
+          )
+        end
+
+        def dependencies_satisfied?(statuses, expired_not_found_statuses)
+          expired_not_found_keys = expired_not_found_statuses.map { |status| dependency_status_key(status) }
+          statuses.all? do |status|
+            state = dependency_state(status)
+            COMPLETED_DEPENDENCY_STATES.include?(state) ||
+              FAILED_DEPENDENCY_STATES.include?(state) ||
+              expired_not_found_keys.include?(dependency_status_key(status))
+          end
+        end
+
+        def expired_not_found_statuses(statuses, not_found_counts)
+          statuses.each_with_object([]) do |status, expired_statuses|
+            key = dependency_status_key(status)
+            if NOT_FOUND_DEPENDENCY_STATES.include?(dependency_state(status))
+              not_found_counts[key] += 1
+              expired_statuses << status if not_found_counts[key] >= DEPENDENCY_NOT_FOUND_MAX_CHECKS
+            else
+              not_found_counts.delete(key)
+            end
+          end
+        end
+
+        def failed_dependency_statuses(statuses)
+          statuses.select do |status|
+            FAILED_DEPENDENCY_STATES.include?(dependency_state(status))
+          end
+        end
+
+        def dependency_state(status)
+          status["state"] || status[:state]
+        end
+
+        def dependency_status_key(status)
+          job_class = status["job_class"] || status[:job_class]
+          job_id = status["job_id"] || status[:job_id]
+          return "#{job_class}:#{job_id}" if job_class && job_id
+          return job_id if job_id
+
+          status["workflow_id"] || status[:workflow_id] || status.hash
+        end
+
+        def fail_on_dependency_failure?(payload)
+          policy = payload[:dependency_failure_policy] || payload["dependency_failure_policy"] || "fail"
+          policy.to_s == "fail"
+        end
+
+        def fail_for_dependencies!(statuses)
+          descriptions = statuses.map do |status|
+            identifier = status["workflow_id"] || status[:workflow_id] || status["job_id"] || status[:job_id]
+            state = status["state"] || status[:state]
+            "#{identifier}: #{state}"
+          end
+
+          raise Temporalio::Error::ApplicationError.new(
+            "Job dependency failed: #{descriptions.join(', ')}",
+            type: "ActiveJob::Temporal::DependencyFailed",
+            non_retryable: true
+          )
+        end
+      end
+    end
+  end
+end

data/lib/activejob/temporal/workflows/workflow_execution_steps.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module ActiveJob
+  module Temporal
+    module Workflows
+      module WorkflowExecutionSteps
+        private
+
+        def execute_workflow_steps(payload, &)
+          continue_as_new_if_needed(payload)
+          wait_until_scheduled(payload)
+          continue_as_new_if_needed(payload)
+          wait_for_dependencies(payload)
+          continue_as_new_if_needed(payload)
+          result = execute_activity_payload(payload)
+          result = execute_child_workflow_sequence(payload, result)
+          execute_chain_sequence(payload, result, &)
+        end
+      end
+    end
+  end
+end