temporalio 1.5.0 → 1.6.0

data/rbi/temporalio/internal/worker/workflow_instance.rbi

@@ -0,0 +1,231 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowInstance
+  extend T::Sig
+
+  sig do
+    params(
+      run_id: String,
+      error: Exception,
+      failure_converter: Temporalio::Converters::FailureConverter,
+      payload_converter: Temporalio::Converters::PayloadConverter
+    ).returns(Object)
+  end
+  def self.new_completion_with_failure(run_id:, error:, failure_converter:, payload_converter:); end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::Context) }
+  attr_reader :context
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ReplaySafeLogger) }
+  attr_reader :logger
+
+  sig { returns(Temporalio::Workflow::Info) }
+  attr_reader :info
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::Scheduler) }
+  attr_reader :scheduler
+
+  sig { returns(T::Boolean) }
+  attr_reader :disable_eager_activity_execution
+
+  sig { returns(T::Hash[Integer, Fiber]) }
+  attr_reader :pending_activities
+
+  sig { returns(T::Hash[Integer, Fiber]) }
+  attr_reader :pending_timers
+
+  sig { returns(T::Hash[Integer, Fiber]) }
+  attr_reader :pending_child_workflow_starts
+
+  sig { returns(T::Hash[Integer, Temporalio::Internal::Worker::WorkflowInstance::ChildWorkflowHandle]) }
+  attr_reader :pending_child_workflows
+
+  sig { returns(T::Hash[Integer, Fiber]) }
+  attr_reader :pending_nexus_operation_starts
+
+  sig { returns(T::Hash[Integer, Temporalio::Internal::Worker::WorkflowInstance::NexusOperationHandle]) }
+  attr_reader :pending_nexus_operations
+
+  sig { returns(T::Hash[Integer, Fiber]) }
+  attr_reader :pending_external_signals
+
+  sig { returns(T::Hash[Integer, Fiber]) }
+  attr_reader :pending_external_cancels
+
+  sig { returns(T::Array[Temporalio::Internal::Worker::WorkflowInstance::HandlerExecution]) }
+  attr_reader :in_progress_handlers
+
+  sig { returns(Temporalio::Converters::PayloadConverter) }
+  attr_reader :payload_converter
+
+  sig { returns(Temporalio::Converters::FailureConverter) }
+  attr_reader :failure_converter
+
+  sig { returns(Temporalio::Cancellation) }
+  attr_reader :cancellation
+
+  sig { returns(T::Boolean) }
+  attr_reader :continue_as_new_suggested
+
+  sig { returns(T::Array[Integer]) }
+  attr_reader :suggest_continue_as_new_reasons
+
+  sig { returns(T::Boolean) }
+  attr_reader :target_worker_deployment_version_changed
+
+  sig { returns(T.nilable(Temporalio::WorkerDeploymentVersion)) }
+  attr_reader :current_deployment_version
+
+  sig { returns(Integer) }
+  attr_reader :current_history_length
+
+  sig { returns(Integer) }
+  attr_reader :current_history_size
+
+  sig { returns(T::Boolean) }
+  attr_reader :replaying
+
+  sig { returns(Random) }
+  attr_reader :random
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Signal]) }
+  attr_reader :signal_handlers
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Query]) }
+  attr_reader :query_handlers
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Update]) }
+  attr_reader :update_handlers
+
+  sig { returns(T::Boolean) }
+  attr_reader :context_frozen
+
+  sig { returns(T.proc.params(arg0: String).void) }
+  attr_reader :assert_valid_local_activity
+
+  sig { returns(T::Boolean) }
+  attr_reader :in_query_or_validator
+
+  sig { returns(T::Boolean) }
+  attr_reader :random_disabled
+
+  sig { returns(T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean))) }
+  attr_reader :patch_activation_callback
+
+  sig { returns(T::Boolean) }
+  attr_accessor :io_enabled
+
+  sig { returns(T.nilable(String)) }
+  attr_accessor :current_details
+
+  sig { params(details: Temporalio::Internal::Worker::WorkflowInstance::Details).void }
+  def initialize(details); end
+
+  sig { params(activation: Object).returns(Object) }
+  def activate(activation); end
+
+  sig { params(command: Object).void }
+  def add_command(command); end
+
+  sig { returns(Temporalio::Workflow::Definition) }
+  def instance; end
+
+  sig { returns(Temporalio::SearchAttributes) }
+  def search_attributes; end
+
+  sig { returns(Temporalio::Internal::Worker::WorkflowInstance::ExternallyImmutableHash) }
+  def memo; end
+
+  sig { returns(Time) }
+  def now; end
+
+  sig { type_parameters(:T).params(block: T.proc.returns(T.type_parameter(:T))).returns(T.type_parameter(:T)) }
+  def illegal_call_tracing_disabled(&block); end
+
+  sig { params(patch_id: T.any(Symbol, String), deprecated: T::Boolean).returns(T::Boolean) }
+  def patch(patch_id:, deprecated:); end
+
+  sig { params(patch_id: String).returns(T::Boolean) }
+  def patch_activated?(patch_id); end
+
+  sig { returns(Temporalio::Metric::Meter) }
+  def metric_meter; end
+
+  private
+
+  sig { returns(Temporalio::Workflow::Definition) }
+  def create_instance; end
+
+  sig { params(job: Object).void }
+  def apply(job); end
+
+  sig { params(job: Object).void }
+  def apply_signal(job); end
+
+  sig { params(job: Object).void }
+  def apply_query(job); end
+
+  sig { params(job: Object).void }
+  def apply_update(job); end
+
+  sig { void }
+  def run_workflow; end
+
+  sig do
+    params(
+      top_level: T::Boolean,
+      handler_exec: T.nilable(Temporalio::Internal::Worker::WorkflowInstance::HandlerExecution),
+      block: T.proc.returns(Object)
+    ).returns(Fiber)
+  end
+  def schedule(top_level: T.unsafe(nil), handler_exec: T.unsafe(nil), &block); end
+
+  sig { params(err: Exception).void }
+  def on_top_level_exception(err); end
+
+  sig { params(err: Exception).returns(T::Boolean) }
+  def failure_exception?(err); end
+
+  sig do
+    type_parameters(:T)
+      .params(
+        in_query_or_validator: T::Boolean,
+        random_disabled: T::Boolean,
+        block: T.proc.returns(T.type_parameter(:T))
+      )
+      .returns(T.type_parameter(:T))
+  end
+  def with_context_frozen(in_query_or_validator:, random_disabled: T.unsafe(nil), &block); end
+
+  sig do
+    params(
+      payload_array: Object,
+      defn: T.any(
+        Temporalio::Workflow::Definition::Signal,
+        Temporalio::Workflow::Definition::Query,
+        Temporalio::Workflow::Definition::Update
+      )
+    ).returns(T::Array[T.nilable(Object)])
+  end
+  def convert_handler_args(payload_array:, defn:); end
+
+  sig do
+    params(
+      payload_array: Object,
+      method_name: T.nilable(Symbol),
+      raw_args: T::Boolean,
+      arg_hints: T.nilable(T::Array[Object]),
+      ignore_first_param: T::Boolean
+    ).returns(T::Array[T.nilable(Object)])
+  end
+  def convert_args(payload_array:, method_name:, raw_args:, arg_hints:, ignore_first_param: T.unsafe(nil)); end
+
+  sig { returns(Object) }
+  def workflow_metadata; end
+
+  sig { returns(T::Hash[Symbol, T.nilable(Object)]) }
+  def scoped_logger_info; end
+
+  sig { void }
+  def warn_on_any_unfinished_handlers; end
+end

data/rbi/temporalio/internal/worker/workflow_worker.rbi

@@ -0,0 +1,199 @@
+# typed: true
+
+class Temporalio::Internal::Worker::WorkflowWorker
+  extend T::Sig
+
+  sig do
+    params(
+      workflows: T::Array[T.any(T.class_of(Temporalio::Workflow::Definition), Temporalio::Workflow::Definition::Info)],
+      should_enforce_versioning_behavior: T::Boolean
+    ).returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info])
+  end
+  def self.workflow_definitions(workflows, should_enforce_versioning_behavior:); end
+
+  sig do
+    params(
+      workflow_failure_exception_types: T::Array[T.class_of(Exception)],
+      workflow_definitions: T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info]
+    ).returns([T::Boolean, T::Array[String]])
+  end
+  def self.bridge_workflow_failure_exception_type_options(workflow_failure_exception_types:, workflow_definitions:); end
+
+  sig do
+    params(
+      bridge_worker: Temporalio::Internal::Bridge::Worker,
+      namespace: String,
+      task_queue: String,
+      workflow_definitions: T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info],
+      workflow_executor: Temporalio::Worker::WorkflowExecutor,
+      logger: Logger,
+      data_converter: Temporalio::Converters::DataConverter,
+      metric_meter: Temporalio::Metric::Meter,
+      workflow_interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow],
+      disable_eager_activity_execution: T::Boolean,
+      illegal_workflow_calls: T.nilable(T::Hash[String, Object]),
+      workflow_failure_exception_types: T::Array[T.class_of(Exception)],
+      workflow_payload_codec_thread_pool: T.nilable(Temporalio::Worker::ThreadPool),
+      unsafe_workflow_io_enabled: T::Boolean,
+      patch_activation_callback: T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean)),
+      debug_mode: T::Boolean,
+      assert_valid_local_activity: T.proc.params(arg0: String).void,
+      on_eviction: T.nilable(T.proc.params(arg0: String, arg1: Object).void)
+    ).void
+  end
+  def initialize(
+    bridge_worker:,
+    namespace:,
+    task_queue:,
+    workflow_definitions:,
+    workflow_executor:,
+    logger:,
+    data_converter:,
+    metric_meter:,
+    workflow_interceptors:,
+    disable_eager_activity_execution:,
+    illegal_workflow_calls:,
+    workflow_failure_exception_types:,
+    workflow_payload_codec_thread_pool:,
+    unsafe_workflow_io_enabled:,
+    patch_activation_callback:,
+    debug_mode:,
+    assert_valid_local_activity:,
+    on_eviction: T.unsafe(nil)
+  ); end
+
+  sig do
+    params(
+      runner: Temporalio::Internal::Worker::MultiRunner,
+      activation: Object,
+      decoded: T::Boolean
+    ).void
+  end
+  def handle_activation(runner:, activation:, decoded:); end
+
+  sig do
+    params(
+      runner: Temporalio::Internal::Worker::MultiRunner,
+      activation_completion: Object,
+      encoded: T::Boolean,
+      completion_complete_queue: Queue
+    ).returns(T::Boolean)
+  end
+  def handle_activation_complete(runner:, activation_completion:, encoded:, completion_complete_queue:); end
+
+  sig { void }
+  def on_shutdown_complete; end
+
+  private
+
+  sig { params(runner: Temporalio::Internal::Worker::MultiRunner, activation: Object).void }
+  def decode_activation(runner, activation); end
+
+  sig { params(runner: Temporalio::Internal::Worker::MultiRunner, activation_completion: Object).void }
+  def encode_activation_completion(runner, activation_completion); end
+
+  sig { params(payload_or_payloads: Object, block: T.proc.params(arg0: Object).returns(Object)).void }
+  def apply_codec_on_payload_visit(payload_or_payloads, &block); end
+end
+
+class Temporalio::Internal::Worker::WorkflowWorker::State
+  extend T::Sig
+
+  sig { returns(T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info]) }
+  attr_reader :workflow_definitions
+
+  sig { returns(Temporalio::Internal::Bridge::Worker) }
+  attr_reader :bridge_worker
+
+  sig { returns(Logger) }
+  attr_reader :logger
+
+  sig { returns(Temporalio::Metric::Meter) }
+  attr_reader :metric_meter
+
+  sig { returns(Temporalio::Converters::DataConverter) }
+  attr_reader :data_converter
+
+  sig { returns(T.nilable(Float)) }
+  attr_reader :deadlock_timeout
+
+  sig { returns(T::Hash[String, Object]) }
+  attr_reader :illegal_calls
+
+  sig { returns(String) }
+  attr_reader :namespace
+
+  sig { returns(String) }
+  attr_reader :task_queue
+
+  sig { returns(T::Boolean) }
+  attr_reader :disable_eager_activity_execution
+
+  sig { returns(T::Array[Temporalio::Worker::Interceptor::Workflow]) }
+  attr_reader :workflow_interceptors
+
+  sig { returns(T::Array[T.class_of(Exception)]) }
+  attr_reader :workflow_failure_exception_types
+
+  sig { returns(T::Boolean) }
+  attr_reader :unsafe_workflow_io_enabled
+
+  sig { returns(T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean))) }
+  attr_reader :patch_activation_callback
+
+  sig { returns(T.proc.params(arg0: String).void) }
+  attr_reader :assert_valid_local_activity
+
+  sig { params(on_eviction: T.proc.params(arg0: String, arg1: Object).void).returns(T.proc.params(arg0: String, arg1: Object).void) }
+  attr_writer :on_eviction
+
+  sig do
+    params(
+      workflow_definitions: T::Hash[T.nilable(String), Temporalio::Workflow::Definition::Info],
+      bridge_worker: Temporalio::Internal::Bridge::Worker,
+      logger: Logger,
+      metric_meter: Temporalio::Metric::Meter,
+      data_converter: Temporalio::Converters::DataConverter,
+      deadlock_timeout: T.nilable(Float),
+      illegal_calls: T::Hash[String, Object],
+      namespace: String,
+      task_queue: String,
+      disable_eager_activity_execution: T::Boolean,
+      workflow_interceptors: T::Array[Temporalio::Worker::Interceptor::Workflow],
+      workflow_failure_exception_types: T::Array[T.class_of(Exception)],
+      unsafe_workflow_io_enabled: T::Boolean,
+      patch_activation_callback: T.nilable(T.proc.params(input: Temporalio::Worker::PatchActivationInput).returns(T::Boolean)),
+      assert_valid_local_activity: T.proc.params(arg0: String).void
+    ).void
+  end
+  def initialize(
+    workflow_definitions:,
+    bridge_worker:,
+    logger:,
+    metric_meter:,
+    data_converter:,
+    deadlock_timeout:,
+    illegal_calls:,
+    namespace:,
+    task_queue:,
+    disable_eager_activity_execution:,
+    workflow_interceptors:,
+    workflow_failure_exception_types:,
+    unsafe_workflow_io_enabled:,
+    patch_activation_callback:,
+    assert_valid_local_activity:
+  ); end
+
+  sig do
+    type_parameters(:T)
+      .params(run_id: String, block: T.proc.returns(T.type_parameter(:T)))
+      .returns(T.type_parameter(:T))
+  end
+  def get_or_create_running_workflow(run_id, &block); end
+
+  sig { params(run_id: String, cache_remove_job: Object).void }
+  def evict_running_workflow(run_id, cache_remove_job); end
+
+  sig { void }
+  def evict_all; end
+end

data/rbi/temporalio/internal/workflow_task_failure_error.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+module Temporalio::Internal::WorkflowTaskFailureError; end

data/rbi/temporalio/internal.rbi

@@ -0,0 +1,3 @@
+# typed: true
+
+module Temporalio::Internal; end

data/rbi/temporalio/metric.rbi

@@ -0,0 +1,56 @@
+# typed: true
+
+class Temporalio::Metric
+  sig do
+    params(
+      value: Numeric,
+      additional_attributes: T.nilable(T::Hash[T.any(String, Symbol), T.any(String, Integer, Float, T::Boolean)])
+    ).void
+  end
+  def record(value, additional_attributes: nil); end
+
+  sig do
+    params(
+      additional_attributes: T::Hash[T.any(String, Symbol), T.any(String, Integer, Float, T::Boolean)]
+    ).returns(Temporalio::Metric)
+  end
+  def with_additional_attributes(additional_attributes); end
+
+  sig { returns(Symbol) }
+  def metric_type; end
+
+  sig { returns(String) }
+  def name; end
+
+  sig { returns(T.nilable(String)) }
+  def description; end
+
+  sig { returns(T.nilable(String)) }
+  def unit; end
+
+  sig { returns(Symbol) }
+  def value_type; end
+end
+
+class Temporalio::Metric::Meter
+  sig { returns(Temporalio::Metric::Meter) }
+  def self.null; end
+
+  sig do
+    params(
+      metric_type: Symbol,
+      name: String,
+      description: T.nilable(String),
+      unit: T.nilable(String),
+      value_type: Symbol
+    ).returns(Temporalio::Metric)
+  end
+  def create_metric(metric_type, name, description: nil, unit: nil, value_type: :integer); end
+
+  sig do
+    params(
+      additional_attributes: T::Hash[T.any(String, Symbol), T.any(String, Integer, Float, T::Boolean)]
+    ).returns(Temporalio::Metric::Meter)
+  end
+  def with_additional_attributes(additional_attributes); end
+end

data/rbi/temporalio/priority.rbi

@@ -0,0 +1,38 @@
+# typed: true
+
+class Temporalio::Priority < ::Data
+  sig do
+    params(
+      priority_key: T.nilable(Integer),
+      fairness_key: T.nilable(String),
+      fairness_weight: T.nilable(Float)
+    ).void
+  end
+  def initialize(priority_key: nil, fairness_key: nil, fairness_weight: nil); end
+
+  sig { returns(Temporalio::Priority) }
+  def self.default; end
+
+  sig { returns(T.nilable(Integer)) }
+  def priority_key; end
+
+  sig { returns(T.nilable(String)) }
+  def fairness_key; end
+
+  sig { returns(T.nilable(Numeric)) }
+  def fairness_weight; end
+
+  sig { returns(T::Boolean) }
+  def empty?; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::Priority) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+
+    sig { params(args: T.untyped).returns(Temporalio::Priority) }
+    def new(*args); end
+  end
+end

data/rbi/temporalio/retry_policy.rbi

@@ -0,0 +1,40 @@
+# typed: true
+
+class Temporalio::RetryPolicy < ::Data
+  sig do
+    params(
+      initial_interval: T.any(Integer, Float),
+      backoff_coefficient: T.any(Integer, Float),
+      max_interval: T.nilable(T.any(Integer, Float)),
+      max_attempts: Integer,
+      non_retryable_error_types: T.nilable(T::Array[String])
+    ).void
+  end
+  def initialize(initial_interval: 1.0, backoff_coefficient: 2.0, max_interval: nil, max_attempts: 0, non_retryable_error_types: nil); end
+
+  sig { returns(T.any(Integer, Float)) }
+  def initial_interval; end
+
+  sig { returns(T.any(Integer, Float)) }
+  def backoff_coefficient; end
+
+  sig { returns(T.nilable(T.any(Integer, Float))) }
+  def max_interval; end
+
+  sig { returns(Integer) }
+  def max_attempts; end
+
+  sig { returns(T.nilable(T::Array[String])) }
+  def non_retryable_error_types; end
+
+  class << self
+    sig { params(args: T.untyped).returns(Temporalio::RetryPolicy) }
+    def [](*args); end
+
+    sig { returns(T::Array[Symbol]) }
+    def members; end
+
+    sig { params(args: T.untyped).returns(Temporalio::RetryPolicy) }
+    def new(*args); end
+  end
+end

data/rbi/temporalio/runtime/metric_buffer.rbi

@@ -0,0 +1,45 @@
+# typed: true
+
+class Temporalio::Runtime::MetricBuffer
+  extend T::Sig
+
+  sig { params(buffer_size: Integer, duration_format: Symbol).void }
+  def initialize(buffer_size, duration_format: T.unsafe(nil)); end
+
+  sig { returns(T::Array[Temporalio::Runtime::MetricBuffer::Update]) }
+  def retrieve_updates; end
+
+  module DurationFormat
+    MILLISECONDS = T.let(T.unsafe(nil), Symbol)
+    SECONDS = T.let(T.unsafe(nil), Symbol)
+  end
+end
+
+class Temporalio::Runtime::MetricBuffer::Update < ::Data
+  extend T::Sig
+
+  sig { returns(Temporalio::Runtime::MetricBuffer::Metric) }
+  def metric; end
+
+  sig { returns(T.any(Integer, Float)) }
+  def value; end
+
+  sig { returns(T::Hash[String, T.any(String, Integer, Float, T::Boolean)]) }
+  def attributes; end
+end
+
+class Temporalio::Runtime::MetricBuffer::Metric < ::Data
+  extend T::Sig
+
+  sig { returns(String) }
+  def name; end
+
+  sig { returns(T.nilable(String)) }
+  def description; end
+
+  sig { returns(T.nilable(String)) }
+  def unit; end
+
+  sig { returns(Symbol) }
+  def kind; end
+end