temporalio 0.0.1

data/lib/temporal/data_converter.rb

@@ -0,0 +1,150 @@
+require 'temporal/api/common/v1/message_pb'
+require 'temporal/errors'
+
+module Temporal
+  class DataConverter
+    class MissingPayload < Temporal::Error; end
+
+    def initialize(payload_converter:, payload_codecs:, failure_converter:)
+      @payload_converter = payload_converter
+      @payload_codecs = payload_codecs
+      @failure_converter = failure_converter
+    end
+
+    def to_payloads(data)
+      return if data.nil? || Array(data).empty?
+
+      payloads = Array(data).map { |value| to_payload(value) }
+      Temporal::Api::Common::V1::Payloads.new(payloads: encode(payloads))
+    end
+
+    def to_payload_map(data)
+      data.to_h do |key, value|
+        payload = to_payload(value)
+        encoded_payload = encode([payload]).first
+        raise MissingPayload, 'Payload Codecs returned no payloads' unless encoded_payload
+
+        [key.to_s, encoded_payload]
+      end
+    end
+
+    def to_failure(error)
+      failure = failure_converter.to_failure(error, payload_converter)
+      encode_failure(failure)
+    end
+
+    def from_payloads(payloads)
+      return unless payloads
+
+      decode(payloads.payloads)
+        .map { |payload| from_payload(payload) }
+    end
+
+    def from_payload_map(payload_map)
+      return unless payload_map
+
+      # Protobuf's Hash isn't compatible with the native Hash, ignore rubocop here
+      # rubocop:disable Style/MapToHash
+      payload_map.map do |key, payload|
+        decoded_payload = decode([payload]).first
+        raise MissingPayload, 'Payload Codecs returned no payloads' unless decoded_payload
+
+        [key, from_payload(decoded_payload)]
+      end.to_h
+      # rubocop:enable Style/MapToHash
+    end
+
+    def from_failure(failure)
+      raise ArgumentError, 'missing a failure to convert from' unless failure
+
+      failure = decode_failure(failure)
+      failure_converter.from_failure(failure, payload_converter)
+    end
+
+    private
+
+    attr_reader :payload_converter, :payload_codecs, :failure_converter
+
+    def encode(payloads)
+      return [] unless payloads
+
+      payload_codecs.each do |codec|
+        payloads = codec.encode(payloads)
+      end
+
+      payloads
+    end
+
+    def decode(payloads)
+      return [] unless payloads
+
+      payload_codecs.reverse_each do |codec|
+        payloads = codec.decode(payloads)
+      end
+
+      payloads
+    end
+
+    def to_payload(data)
+      payload_converter.to_payload(data)
+    end
+
+    def from_payload(payload)
+      payload_converter.from_payload(payload)
+    end
+
+    def encode_failure(failure)
+      failure = failure.dup
+
+      failure.encoded_attributes = failure.encoded_attributes ? encode([failure.encoded_attributes])&.first : nil
+      failure.cause = failure.cause ? encode_failure(failure.cause) : nil
+
+      if failure.application_failure_info
+        failure.application_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: encode(failure.application_failure_info.details&.payloads).to_a,
+        )
+      elsif failure.timeout_failure_info
+        failure.timeout_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: encode(failure.timeout_failure_info.last_heartbeat_details&.payloads).to_a,
+        )
+      elsif failure.canceled_failure_info
+        failure.canceled_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: encode(failure.canceled_failure_info.details&.payloads).to_a,
+        )
+      elsif failure.reset_workflow_failure_info
+        failure.reset_workflow_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: encode(failure.reset_workflow_failure_info.last_heartbeat_details&.payloads).to_a,
+        )
+      end
+
+      failure
+    end
+
+    def decode_failure(failure)
+      failure = failure.dup
+
+      failure.encoded_attributes = failure.encoded_attributes ? decode([failure.encoded_attributes])&.first : nil
+      failure.cause = failure.cause ? decode_failure(failure.cause) : nil
+
+      if failure.application_failure_info
+        failure.application_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: decode(failure.application_failure_info.details&.payloads).to_a,
+        )
+      elsif failure.timeout_failure_info
+        failure.timeout_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: decode(failure.timeout_failure_info.last_heartbeat_details&.payloads).to_a,
+        )
+      elsif failure.canceled_failure_info
+        failure.canceled_failure_info.details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: decode(failure.canceled_failure_info.details&.payloads).to_a,
+        )
+      elsif failure.reset_workflow_failure_info
+        failure.reset_workflow_failure_info.last_heartbeat_details = Temporal::Api::Common::V1::Payloads.new(
+          payloads: decode(failure.reset_workflow_failure_info.last_heartbeat_details&.payloads).to_a,
+        )
+      end
+
+      failure
+    end
+  end
+end

data/lib/temporal/error/failure.rb

@@ -0,0 +1,194 @@
+# TODO: Figure out the hierarchy
+require 'temporal/errors'
+
+module Temporal
+  class Error
+    # Base for runtime failures during workflow/activity execution.
+    class Failure < Error
+      # @return [Temporal::Api::Failure::V1::Failure, nil] Original proto failure
+      attr_reader :raw
+
+      def initialize(message, raw: nil, cause: nil)
+        super(message)
+
+        @raw = raw
+        @cause = cause
+      end
+
+      def cause
+        @cause || super
+      end
+    end
+
+    # Error raised during workflow/activity execution.
+    class ApplicationError < Failure
+      # @return [String] General error type.
+      attr_reader :type
+
+      # @return [Array<any>] User-defined details on the error.
+      attr_reader :details
+
+      # @return [Bool] Whether the error is non-retryable.
+      attr_reader :non_retryable
+
+      def initialize(message, type:, details: [], non_retryable: false, raw: nil, cause: nil)
+        super(message, raw: raw, cause: cause)
+
+        @type = type
+        @details = details
+        @non_retryable = non_retryable
+      end
+
+      def retryable?
+        !non_retryable
+      end
+    end
+
+    # Error raised on workflow/activity timeout.
+    class TimeoutError < Failure
+      # @return [Symbol] Type of timeout error. Refer to {Temporal::TimeoutType}.
+      attr_reader :type
+
+      # @return [Array<any>] Last heartbeat details if this is for an activity heartbeat.
+      attr_reader :last_heartbeat_details
+
+      def initialize(message, type:, last_heartbeat_details: [], raw: nil, cause: nil)
+        super(message, raw: raw, cause: cause)
+
+        @type = type
+        @last_heartbeat_details = last_heartbeat_details
+      end
+    end
+
+    # Error raised on workflow/activity cancellation.
+    class CancelledError < Failure
+      # @return [Array<any>] User-defined details on the error.
+      attr_reader :details
+
+      def initialize(message, details: [], raw: nil, cause: nil)
+        super(message, raw: raw, cause: cause)
+
+        @details = details
+      end
+    end
+
+    # Error raised on workflow cancellation.
+    class TerminatedError < Failure; end
+
+    # Error originating in the Temporal server.
+    class ServerError < Failure
+      # @return [Bool] Whether the error is non-retryable.
+      attr_reader :non_retryable
+
+      def initialize(message, non_retryable:, raw: nil, cause: nil)
+        super(message, raw: raw, cause: cause)
+
+        @non_retryable = non_retryable
+      end
+
+      def retryable?
+        !non_retryable
+      end
+    end
+
+    class ResetWorkflowError < Failure
+      # @return [Array<any>] Last heartbeat details if this is for an activity heartbeat.
+      attr_reader :last_heartbeat_details
+
+      def initialize(message, last_heartbeat_details: [], raw: nil, cause: nil)
+        super(message, raw: raw, cause: cause)
+
+        @last_heartbeat_details = last_heartbeat_details
+      end
+    end
+
+    # Error raised on activity failure.
+    class ActivityError < Failure
+      # @return [Integer] Scheduled event ID for this error.
+      attr_reader :scheduled_event_id
+
+      # @return [Integer] Started event ID for this error.
+      attr_reader :started_event_id
+
+      # @return [String] Identity for this error.
+      attr_reader :identity
+
+      # @return [String] Activity name for this error.
+      attr_reader :activity_name
+
+      # @return [String] Activity ID for this error.
+      attr_reader :activity_id
+
+      # @return [Symbol] Retry state for this error. Refer to {Temporal::RetryState}.
+      attr_reader :retry_state
+
+      def initialize(
+        message,
+        scheduled_event_id:,
+        started_event_id:,
+        identity:,
+        activity_name:,
+        activity_id:,
+        retry_state:,
+        raw: nil,
+        cause: nil
+      )
+        super(message, raw: raw, cause: cause)
+
+        @scheduled_event_id = scheduled_event_id
+        @started_event_id = started_event_id
+        @identity = identity
+        @activity_name = activity_name
+        @activity_id = activity_id
+        @retry_state = retry_state
+      end
+    end
+
+    # Error raised on child workflow failure.
+    class ChildWorkflowError < Failure
+      # @return [String] Namespace for this error.
+      attr_reader :namespace
+
+      # @return [String] Workflow ID for this error.
+      attr_reader :workflow_id
+
+      # @return [String] Run ID for this error.
+      attr_reader :run_id
+
+      # @return [String] Workflow name for this error.
+      attr_reader :workflow_name
+
+      # @return [Integer] Initiated event ID for this error.
+      attr_reader :initiated_event_id
+
+      # @return [Integer] Started event ID for this error.
+      attr_reader :started_event_id
+
+      # @return [Symbol] Retry state for this error. Refer to {Temporal::RetryState}.
+      attr_reader :retry_state
+
+      def initialize(
+        message,
+        namespace:,
+        workflow_id:,
+        run_id:,
+        workflow_name:,
+        initiated_event_id:,
+        started_event_id:,
+        retry_state:,
+        raw: nil,
+        cause: nil
+      )
+        super(message, raw: raw, cause: cause)
+
+        @namespace = namespace
+        @workflow_id = workflow_id
+        @run_id = run_id
+        @workflow_name = workflow_name
+        @initiated_event_id = initiated_event_id
+        @started_event_id = started_event_id
+        @retry_state = retry_state
+      end
+    end
+  end
+end

data/lib/temporal/error/workflow_failure.rb

@@ -0,0 +1,17 @@
+require 'temporal/errors'
+
+module Temporal
+  class Error
+    # Used as a wrapper to perserve failure hierarchy in nested calls
+    # i.e. WorkflowFailure(ActivityError(WorkflowFailure(CancelledError)))
+    class WorkflowFailure < Error
+      attr_reader :cause
+
+      def initialize(cause:)
+        super
+
+        @cause = cause
+      end
+    end
+  end
+end

data/lib/temporal/errors.rb

@@ -0,0 +1,22 @@
+module Temporal
+  # Superclass for all Temporal errors
+  class Error < StandardError
+    # Superclass for RPC and proto related errors
+    class RPCError < Error; end
+
+    class UnexpectedResponse < RPCError; end
+
+    class WorkflowExecutionAlreadyStarted < RPCError; end
+
+    class QueryFailed < RPCError; end
+
+    class QueryRejected < RPCError
+      attr_reader :status
+
+      def initialize(status)
+        super("Query rejected, workflow status: #{status}")
+        @status = status
+      end
+    end
+  end
+end

data/lib/temporal/failure_converter/base.rb

@@ -0,0 +1,26 @@
+module Temporal
+  module FailureConverter
+    # @abstract Use this Interface for implementing your failure converter.
+    class Base
+      # Convert an Error object to a proto Failure.
+      #
+      # @param _error [Exception] An Error to be converter.
+      # @param _payload_converter [Temporal::PayloadConverter::Base] A payload converter.
+      #
+      # @return [Temporal::Api::Failure::V1::Failure]
+      def to_failure(_error, _payload_converter)
+        raise NoMethodError, 'must implement #to_failure'
+      end
+
+      # Convert an proto Failure object to an Error.
+      #
+      # @param _failure [Temporal::Api::Failure::V1::Failure] A proto Failure to be converted.
+      # @param _payload_converter [Temporal::PayloadConverter::Base] A payload converter.
+      #
+      # @return [Exception]
+      def from_failure(_failure, _payload_converter)
+        raise NoMethodError, 'must implement #from_failure'
+      end
+    end
+  end
+end