temporalio 1.5.0 → 1.6.0

data/sig/temporalio/internal/worker/workflow_instance/context.rbs

@@ -0,0 +1,172 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class Context
+          def initialize: (WorkflowInstance `instance`) -> void
+
+          def all_handlers_finished?: -> bool
+
+          def cancellation: -> Cancellation
+
+          def continue_as_new_suggested: -> bool
+
+          def create_nexus_client: (endpoint: Symbol | String, service: Symbol | String) -> Workflow::NexusClient
+
+          def suggest_continue_as_new_reasons: -> Array[SuggestContinueAsNewReason::enum]
+
+          def target_worker_deployment_version_changed?: -> bool
+
+          def current_details: -> String
+          def current_details=: (String? details) -> void
+
+          def current_history_length: -> Integer
+
+          def current_history_size: -> Integer
+
+          def current_deployment_version: -> WorkerDeploymentVersion?
+
+          def current_update_info: -> Workflow::UpdateInfo?
+
+          def deprecate_patch: (Symbol | String patch_id) -> void
+
+          def durable_scheduler_disabled: [T] { -> T } -> T
+
+          def execute_activity: (
+            singleton(Activity::Definition) | Symbol | String activity,
+            *Object? args,
+            task_queue: String,
+            summary: String?,
+            schedule_to_close_timeout: duration?,
+            schedule_to_start_timeout: duration?,
+            start_to_close_timeout: duration?,
+            heartbeat_timeout: duration?,
+            retry_policy: RetryPolicy?,
+            cancellation: Cancellation,
+            cancellation_type: Workflow::ActivityCancellationType::enum,
+            activity_id: String?,
+            disable_eager_execution: bool,
+            priority: Priority,
+            arg_hints: Array[Object]?,
+            result_hint: Object?
+          ) -> Object?
+
+          def execute_local_activity: (
+            singleton(Activity::Definition) | Symbol | String activity,
+            *Object? args,
+            summary: String?,
+            schedule_to_close_timeout: duration?,
+            schedule_to_start_timeout: duration?,
+            start_to_close_timeout: duration?,
+            retry_policy: RetryPolicy?,
+            local_retry_threshold: duration?,
+            cancellation: Cancellation,
+            cancellation_type: Workflow::ActivityCancellationType::enum,
+            activity_id: String?,
+            arg_hints: Array[Object]?,
+            result_hint: Object?
+          ) -> Object?
+
+          def external_workflow_handle: (String workflow_id, ?run_id: String?) -> ExternalWorkflowHandle
+
+          def illegal_call_tracing_disabled: [T] { -> T } -> T
+
+          def info: -> Workflow::Info
+
+          def instance: -> Temporalio::Workflow::Definition?
+
+          def initialize_continue_as_new_error: (Workflow::ContinueAsNewError error) -> void
+
+          def io_enabled: [T] { -> T } -> T
+
+          def logger: -> ReplaySafeLogger
+
+          def memo: -> ExternallyImmutableHash[String, Object?]
+
+          def metric_meter: -> Temporalio::Metric::Meter
+
+          def now: -> Time
+
+          def patched: (Symbol | String patch_id) -> bool
+
+          def payload_converter: -> Converters::PayloadConverter
+
+          def query_handlers: -> HandlerHash[Workflow::Definition::Query]
+
+          def random: -> Random
+
+          def replaying?: -> bool
+
+          def replaying_history_events?: -> bool
+
+          def search_attributes: -> SearchAttributes
+
+          def signal_handlers: -> HandlerHash[Workflow::Definition::Signal]
+
+          def sleep: (duration? duration, summary: String?, cancellation: Cancellation) -> void
+
+          def start_child_workflow: (
+            singleton(Workflow::Definition) | Workflow::Definition::Info | Symbol | String workflow,
+            *Object? args,
+            id: String,
+            task_queue: String,
+            static_summary: String?,
+            static_details: String?,
+            cancellation: Cancellation,
+            cancellation_type: Workflow::ChildWorkflowCancellationType::enum,
+            parent_close_policy: Workflow::ParentClosePolicy::enum,
+            execution_timeout: duration?,
+            run_timeout: duration?,
+            task_timeout: duration?,
+            id_reuse_policy: WorkflowIDReusePolicy::enum,
+            retry_policy: RetryPolicy?,
+            cron_schedule: String?,
+            memo: Hash[String | Symbol, Object?]?,
+            search_attributes: SearchAttributes?,
+            priority: Priority,
+            arg_hints: Array[Object]?,
+            result_hint: Object?
+          ) -> ChildWorkflowHandle
+
+          def storage: -> Hash[Object, Object]
+
+          def timeout: [T] (
+            duration? duration,
+            singleton(Exception) exception_class,
+            *Object? exception_args,
+            summary: String?
+          ) { -> T } -> T
+
+          def update_handlers: -> HandlerHash[Workflow::Definition::Update]
+
+          def upsert_memo: (Hash[Symbol | String, Object?] hash) -> void
+
+          def upsert_search_attributes: (*SearchAttributes::Update updates) -> void
+
+          def wait_condition: [T] (cancellation: Cancellation?) { -> T } -> T
+
+          def _cancel_external_workflow: (id: String, run_id: String?) -> void
+
+          def _outbound=: (Temporalio::Worker::Interceptor::Workflow::Outbound outbound) -> void
+
+          def _signal_child_workflow: (
+            id: String,
+            signal: Workflow::Definition::Signal | Symbol | String,
+            args: Array[Object?],
+            cancellation: Cancellation,
+            arg_hints: Array[Object]?
+          ) -> void
+
+          def _signal_external_workflow: (
+            id: String,
+            run_id: String?,
+            signal: Workflow::Definition::Signal | Symbol | String,
+            args: Array[Object?],
+            cancellation: Cancellation,
+            arg_hints: Array[Object]?
+          ) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/details.rbs

@@ -0,0 +1,43 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class Details
+          attr_reader namespace: String
+          attr_reader task_queue: String
+          attr_reader definition: Workflow::Definition::Info
+          attr_reader initial_activation: untyped
+          attr_reader logger: Logger
+          attr_reader metric_meter: Temporalio::Metric::Meter
+          attr_reader payload_converter: Converters::PayloadConverter
+          attr_reader failure_converter: Converters::FailureConverter
+          attr_reader interceptors: Array[Temporalio::Worker::Interceptor::Workflow]
+          attr_reader disable_eager_activity_execution: bool
+          attr_reader illegal_calls: Hash[String, :all | Hash[Symbol, TrueClass | Temporalio::Worker::IllegalWorkflowCallValidator] | Temporalio::Worker::IllegalWorkflowCallValidator]
+          attr_reader workflow_failure_exception_types: Array[singleton(Exception)]
+          attr_reader unsafe_workflow_io_enabled: bool
+          attr_reader patch_activation_callback: Proc?
+          attr_reader assert_valid_local_activity: ^(String) -> void
+
+          def initialize: (
+            namespace: String,
+            task_queue: String,
+            definition: Workflow::Definition::Info,
+            initial_activation: untyped,
+            logger: Logger,
+            metric_meter: Temporalio::Metric::Meter,
+            payload_converter: Converters::PayloadConverter,
+            failure_converter: Converters::FailureConverter,
+            interceptors: Array[Temporalio::Worker::Interceptor::Workflow],
+            disable_eager_activity_execution: bool,
+            illegal_calls: Hash[String, :all | Hash[Symbol, TrueClass | Temporalio::Worker::IllegalWorkflowCallValidator] | Temporalio::Worker::IllegalWorkflowCallValidator],
+            workflow_failure_exception_types: Array[singleton(Exception)],
+            unsafe_workflow_io_enabled: bool,
+            patch_activation_callback: Proc?,
+            assert_valid_local_activity: ^(String) -> void
+          ) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/external_workflow_handle.rbs

@@ -0,0 +1,15 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class ExternalWorkflowHandle < Workflow::ExternalWorkflowHandle
+          def initialize: (
+            id: String,
+            run_id: String?,
+            instance: Object
+          ) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/externally_immutable_hash.rbs

@@ -0,0 +1,16 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class ExternallyImmutableHash[K, V] < Hash[K, V]
+          def initialize: (Hash[K, V] initial_hash) -> void
+
+          def _update: { (Hash[K, V]) -> void } -> void
+
+          def __getobj__: -> Hash[K, V]
+          def __setobj__: (Hash[K, V] value) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/handler_execution.rbs

@@ -0,0 +1,19 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class HandlerExecution
+          attr_reader name: String
+          attr_reader update_id: String?
+          attr_reader unfinished_policy: Workflow::HandlerUnfinishedPolicy::enum
+
+          def initialize: (
+            name: String,
+            update_id: String?,
+            unfinished_policy: Workflow::HandlerUnfinishedPolicy::enum
+          ) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/handler_hash.rbs

@@ -0,0 +1,14 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class HandlerHash[D] < Hash[String?, D]
+          def initialize: (
+            Hash[String?, D] initial_frozen_hash,
+            singleton(Workflow::Definition::Signal) | singleton(Workflow::Definition::Query) | singleton(Workflow::Definition::Update) definition_class,
+          ) ?{ (D) -> void } -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/illegal_call_tracer.rbs

@@ -0,0 +1,20 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class IllegalCallTracer
+          def self.frozen_validated_illegal_calls: (
+            Hash[String, :all | Array[Symbol | Temporalio::Worker::IllegalWorkflowCallValidator] | Temporalio::Worker::IllegalWorkflowCallValidator] illegal_calls
+          ) -> Hash[String, :all | Hash[Symbol, TrueClass | Temporalio::Worker::IllegalWorkflowCallValidator] | Temporalio::Worker::IllegalWorkflowCallValidator]
+
+          def initialize: (
+            Hash[String, :all | Hash[Symbol, TrueClass | Temporalio::Worker::IllegalWorkflowCallValidator] | Temporalio::Worker::IllegalWorkflowCallValidator] illegal_calls
+          ) -> void
+
+          def enable: [T] { -> T } -> T
+          def disable_temporarily: [T] { -> T } -> T
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/inbound_implementation.rbs

@@ -0,0 +1,19 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class InboundImplementation < Temporalio::Worker::Interceptor::Workflow::Inbound
+          def initialize: (WorkflowInstance instance) -> void
+
+          def invoke_handler: (
+            String name,
+            Temporalio::Worker::Interceptor::Workflow::HandleSignalInput | 
+              Temporalio::Worker::Interceptor::Workflow::HandleQueryInput |
+              Temporalio::Worker::Interceptor::Workflow::HandleUpdateInput input,
+            ?to_invoke: Symbol | Proc | nil
+          ) -> Object?
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/nexus_client.rbs

@@ -0,0 +1,25 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class NexusClient < Workflow::NexusClient
+          attr_reader endpoint: String
+          attr_reader service: String
+
+          def initialize: (endpoint: Symbol | String, service: Symbol | String, outbound: untyped) -> void
+
+          def start_operation: (
+            Symbol | String operation,
+            Object? arg,
+            ?schedule_to_close_timeout: duration?,
+            ?cancellation_type: Workflow::NexusOperationCancellationType::enum,
+            ?summary: String?,
+            ?cancellation: Cancellation,
+            ?arg_hint: Object?,
+            ?result_hint: Object?
+          ) -> Workflow::NexusOperationHandle
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/nexus_operation_handle.rbs

@@ -0,0 +1,19 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class NexusOperationHandle < Workflow::NexusOperationHandle
+          def initialize: (
+            operation_token: String?,
+            instance: WorkflowInstance,
+            cancellation: Cancellation,
+            cancel_callback_key: Object,
+            result_hint: Object?
+          ) -> void
+
+          def _resolve: (untyped resolution) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/outbound_implementation.rbs

@@ -0,0 +1,35 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class OutboundImplementation < Temporalio::Worker::Interceptor::Workflow::Outbound
+          def initialize: (WorkflowInstance instance) -> void
+
+          def execute_activity_with_local_backoffs: (
+            local: bool,
+            cancellation: Cancellation,
+            result_hint: Object?
+          ) { (untyped?) -> Integer } -> Object?
+
+          def execute_activity_once: (
+            local: bool,
+            cancellation: Cancellation,
+            last_local_backoff: untyped?,
+            result_hint: Object?
+          ) { (untyped?) -> Integer } -> Object?
+
+          def _signal_external_workflow: (
+            id: String,
+            run_id: String?,
+            child: bool,
+            signal: Workflow::Definition::Signal | Symbol | String,
+            args: Array[Object?],
+            cancellation: Cancellation,
+            arg_hints: Array[Object]?,
+            headers: Hash[String, Object?]
+          ) -> void
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/replay_safe_logger.rbs

@@ -0,0 +1,16 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class ReplaySafeLogger < ScopedLogger
+          def initialize: (
+            logger: Logger,
+            instance: WorkflowInstance
+          ) -> void
+
+          def replay_safety_disabled: [T] { -> T } -> T
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/replay_safe_metric.rbs

@@ -0,0 +1,15 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class ReplaySafeMetric < Temporalio::Metric
+          def initialize: (Temporalio::Metric) -> void
+
+          class Meter < Temporalio::Metric::Meter
+            def initialize: (Temporalio::Metric::Meter) -> void
+          end
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance/scheduler.rbs

@@ -0,0 +1,52 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        class Scheduler
+          def initialize: (WorkflowInstance instance) -> void
+
+          def context: -> Context
+
+          def run_until_all_yielded: -> void
+
+          def wait_condition: [T] (cancellation: Cancellation?) { -> T } -> T
+
+          def stack_trace: -> String
+
+          def block: (untyped blocker, ?duration? timeout) -> bool
+
+          def close: -> void
+
+          def fiber: { -> untyped } -> Fiber
+
+          def fiber_interrupt: (Fiber fiber, Exception exception) -> void
+
+          def io_wait: (IO io, Integer events, duration? timeout) -> Integer
+
+          def kernel_sleep: (?duration? duration) -> untyped
+
+          def process_wait: (Integer pid, Integer flags) -> bot
+
+          # Only needed to say block is required
+          def timeout_after: [T] (
+            duration? duration,
+            singleton(Exception) exception_class,
+            *Object? exception_args
+          ) { -> T } -> T
+
+          def unblock: (untyped blocker, Fiber fiber) -> void
+
+          private
+
+          def thread_blocking_protobuf_mutex_wait?: (untyped blocker) -> bool
+
+          def wait_for_thread_blocking_fiber: -> bool
+
+          def synchronize_thread_blocking_fibers: [T] () { -> T } -> T
+
+          def with_workflow_scheduler_disabled: [T] () { -> T } -> T
+        end
+      end
+    end
+  end
+end

data/sig/temporalio/internal/worker/workflow_instance.rbs

@@ -0,0 +1,111 @@
+module Temporalio
+  module Internal
+    module Worker
+      class WorkflowInstance
+        def self.new_completion_with_failure: (
+          run_id: String,
+          error: Exception,
+          failure_converter: Converters::FailureConverter,
+          payload_converter: Converters::PayloadConverter
+        ) -> untyped
+
+        attr_reader context: Context
+        attr_reader logger: ReplaySafeLogger
+        attr_reader info: Workflow::Info
+        attr_reader scheduler: Scheduler
+        attr_reader disable_eager_activity_execution: bool
+        attr_reader pending_activities: Hash[Integer, Fiber]
+        attr_reader pending_timers: Hash[Integer, Fiber]
+        attr_reader pending_child_workflow_starts: Hash[Integer, Fiber]
+        attr_reader pending_child_workflows: Hash[Integer, ChildWorkflowHandle]
+        attr_reader pending_nexus_operation_starts: Hash[Integer, Fiber]
+        attr_reader pending_nexus_operations: Hash[Integer, NexusOperationHandle]
+        attr_reader pending_external_signals: Hash[Integer, Fiber]
+        attr_reader pending_external_cancels: Hash[Integer, Fiber]
+        attr_reader in_progress_handlers: Array[HandlerExecution]
+        attr_reader payload_converter: Converters::PayloadConverter
+        attr_reader failure_converter: Converters::FailureConverter
+        attr_reader cancellation: Cancellation
+        attr_reader continue_as_new_suggested: bool
+        attr_reader suggest_continue_as_new_reasons: Array[SuggestContinueAsNewReason::enum]
+        attr_reader target_worker_deployment_version_changed: bool
+        attr_reader current_history_length: Integer
+        attr_reader current_history_size: Integer
+        attr_reader replaying: bool
+        attr_reader random: Random
+        attr_reader signal_handlers: Hash[String?, Workflow::Definition::Signal]
+        attr_reader query_handlers: Hash[String?, Workflow::Definition::Query]
+        attr_reader update_handlers: Hash[String?, Workflow::Definition::Update]
+        attr_reader context_frozen: bool
+        attr_reader assert_valid_local_activity: ^(String) -> void
+        attr_reader in_query_or_validator: bool
+        attr_reader random_disabled: bool
+        attr_reader patch_activation_callback: Proc?
+
+        attr_accessor io_enabled: bool
+        attr_accessor current_details: String?
+
+        def initialize: (Details details) -> void
+
+        def activate: (untyped activation) -> untyped
+
+        def add_command: (untyped command) -> void
+
+        def instance: -> Temporalio::Workflow::Definition
+
+        def search_attributes: -> SearchAttributes
+
+        def memo: -> ExternallyImmutableHash[String, Object?]
+
+        def now: -> Time
+
+        def illegal_call_tracing_disabled: [T] { -> T } -> T
+
+        def patch: (patch_id: Symbol | String, deprecated: bool) -> bool
+
+        def patch_activated?: (String patch_id) -> bool
+
+        def metric_meter: -> Temporalio::Metric::Meter
+
+        def create_instance: -> Temporalio::Workflow::Definition
+
+        def apply: (untyped job) -> void
+
+        def apply_signal: (untyped job) -> void
+
+        def apply_query: (untyped job) -> void
+
+        def apply_update: (untyped job) -> void
+
+        def run_workflow: -> void
+
+        def schedule: (?top_level: bool, ?handler_exec: HandlerExecution?) { -> untyped } -> Fiber
+
+        def on_top_level_exception: (Exception err) -> void
+
+        def failure_exception?: (Exception err) -> bool
+
+        def with_context_frozen: [T] (in_query_or_validator: bool, ?random_disabled: bool) { -> T } -> T
+
+        def convert_handler_args: (
+          payload_array: Array[untyped],
+          defn: Workflow::Definition::Signal | Workflow::Definition::Query | Workflow::Definition::Update
+        ) -> Array[Object?]
+
+        def convert_args: (
+          payload_array: Array[untyped],
+          method_name: Symbol?,
+          raw_args: bool,
+          arg_hints: Array[Object]?,
+          ?ignore_first_param: bool
+        ) -> Array[Object?]
+
+        def workflow_metadata: -> untyped
+
+        def scoped_logger_info: -> Hash[Symbol, Object?]
+
+        def warn_on_any_unfinished_handlers: -> void
+      end
+    end
+  end
+end