restate-sdk 0.5.0-aarch64-linux → 0.5.1-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6c4926d9f1b3d398f990db7c8c1b69992d15dca6c4351b26ca2acdb544241dbb
-  data.tar.gz: fa7141828b226288c421d9fd3e7e312542996ba54f84fa3b8037b7f392143315
+  metadata.gz: a81d6c3c60667dd85535a4c6f668e7bff95ee2d52948640751458793f8389987
+  data.tar.gz: b9015e2e91776a61b23a636120aeef049857ef37f5bc17ba8c31b3a1988c2348
 SHA512:
-  metadata.gz: 97997980254554521ee6b9a24244de9a8115664bef4585b1d856ac859b8c590ae20ed938208d06f245d1d019951ec7be51f73217c359e7ceaae43da24875f21b
-  data.tar.gz: 135673211c2a556bba886aefc3ce4b3d8b20312330a985d908a08d50b4e2d1c744514b3fec5918ecfe1fc89bb916adcc353649d28371365725913cf3872fce01
+  metadata.gz: '059edf3c35921e494373a1960f65cdd6f6f33a7c1ad9308c7759be87e48b9e3e2246d831b02ef4e9d00305150c409a3bbae5a62290cb824e76b4f68f18b79fe4'
+  data.tar.gz: f772b40c32a8200b77f5dede3c4d10d5a92e226f58f52c32a769293e4d0ef14d8f5784c915945704dac3147764c204110fc2352a0d265288659dc96d095f03f6

data/Cargo.lock

@@ -569,7 +569,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.5.0"
+version = "0.5.1"
 dependencies = [
  "magnus",
  "rb-sys",

data/ext/restate_internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restate_internal"
-version = "0.5.0"
+version = "0.5.1"
 edition = "2021"
 publish = false
 

data/lib/restate/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Restate
-  VERSION = '0.5.0'
+  VERSION = '0.5.1'
 end

data/rbi/restate-sdk.rbi

@@ -0,0 +1,307 @@
+# typed: true
+
+# RBI shipped with the restate-sdk gem.
+# Tapioca merges this automatically when users run `tapioca gems`.
+
+module Restate
+  # Create an endpoint, optionally binding services.
+  sig do
+    params(
+      services: T.untyped,
+      protocol: T.nilable(String),
+      identity_keys: T.nilable(T::Array[String])
+    ).returns(Restate::Endpoint)
+  end
+  def self.endpoint(*services, protocol: nil, identity_keys: nil); end
+
+  # Returns the current context (any handler).
+  sig { returns(Restate::Context) }
+  def self.current_context; end
+
+  # Returns the current context for a VirtualObject exclusive handler.
+  sig { returns(Restate::ObjectContext) }
+  def self.current_object_context; end
+
+  # Returns the current context for a VirtualObject shared handler.
+  sig { returns(Restate::ObjectSharedContext) }
+  def self.current_shared_context; end
+
+  # Returns the current context for a Workflow main handler.
+  sig { returns(Restate::WorkflowContext) }
+  def self.current_workflow_context; end
+
+  # Returns the current context for a Workflow shared handler.
+  sig { returns(Restate::WorkflowSharedContext) }
+  def self.current_shared_workflow_context; end
+
+  class TerminalError < StandardError
+    sig { returns(Integer) }
+    def status_code; end
+
+    sig { params(message: String, status_code: Integer).void }
+    def initialize(message = '', status_code: 500); end
+  end
+
+  class AttemptFinishedEvent
+    sig { returns(T::Boolean) }
+    def set?; end
+
+    sig { void }
+    def wait; end
+  end
+
+  Request = T.type_alias { T.untyped }
+
+  class RunRetryPolicy < T::Struct
+    const :initial_interval, T.nilable(Integer)
+    const :max_attempts, T.nilable(Integer)
+    const :max_duration, T.nilable(Integer)
+    const :max_interval, T.nilable(Integer)
+    const :interval_factor, T.nilable(Float)
+  end
+
+  class DurableFuture
+    sig { returns(T.untyped) }
+    def await; end
+
+    sig { returns(T::Boolean) }
+    def completed?; end
+
+    sig { returns(Integer) }
+    def handle; end
+  end
+
+  class DurableCallFuture < DurableFuture
+    sig { returns(String) }
+    def invocation_id; end
+
+    sig { void }
+    def cancel; end
+  end
+
+  class SendHandle
+    sig { returns(String) }
+    def invocation_id; end
+
+    sig { void }
+    def cancel; end
+  end
+
+  # Base context interface for all Restate handlers.
+  module Context
+    sig do
+      params(
+        name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
+        background: T::Boolean, action: T.proc.returns(T.untyped)
+      ).returns(DurableFuture)
+    end
+    def run(name, serde: Restate::JsonSerde, retry_policy: nil, background: false, &action); end
+
+    sig do
+      params(
+        name: String, serde: T.untyped, retry_policy: T.nilable(RunRetryPolicy),
+        background: T::Boolean, action: T.proc.returns(T.untyped)
+      ).returns(T.untyped)
+    end
+    def run_sync(name, serde: Restate::JsonSerde, retry_policy: nil, background: false, &action); end
+
+    sig { params(seconds: Numeric).returns(DurableFuture) }
+    def sleep(seconds); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        arg: T.untyped, key: T.nilable(String), idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def service_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil,
+                     input_serde: T.unsafe(nil), output_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        arg: T.untyped, key: T.nilable(String), delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def service_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil,
+                     headers: nil, input_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def object_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
+                    input_serde: T.unsafe(nil), output_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def object_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
+                    headers: nil, input_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String]), input_serde: T.untyped, output_serde: T.untyped
+      ).returns(DurableCallFuture)
+    end
+    def workflow_call(service, handler, key, arg, idempotency_key: nil, headers: nil,
+                      input_serde: T.unsafe(nil), output_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: T.any(String, T::Class[T.anything]), handler: T.any(String, Symbol),
+        key: String, arg: T.untyped, delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String]),
+        input_serde: T.untyped
+      ).returns(SendHandle)
+    end
+    def workflow_send(service, handler, key, arg, delay: nil, idempotency_key: nil,
+                      headers: nil, input_serde: T.unsafe(nil)); end
+
+    sig do
+      params(
+        service: String, handler: String, arg: String,
+        key: T.nilable(String), idempotency_key: T.nilable(String),
+        headers: T.nilable(T::Hash[String, String])
+      ).returns(DurableCallFuture)
+    end
+    def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil); end
+
+    sig do
+      params(
+        service: String, handler: String, arg: String,
+        key: T.nilable(String), delay: T.nilable(Numeric),
+        idempotency_key: T.nilable(String), headers: T.nilable(T::Hash[String, String])
+      ).returns(SendHandle)
+    end
+    def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil); end
+
+    sig { params(serde: T.untyped).returns([String, DurableFuture]) }
+    def awakeable(serde: Restate::JsonSerde); end
+
+    sig { params(awakeable_id: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_awakeable(awakeable_id, payload, serde: Restate::JsonSerde); end
+
+    sig { params(awakeable_id: String, message: String, code: Integer).void }
+    def reject_awakeable(awakeable_id, message, code: 500); end
+
+    sig { params(invocation_id: String).void }
+    def cancel_invocation(invocation_id); end
+
+    sig { params(futures: DurableFuture).returns([T::Array[DurableFuture], T::Array[DurableFuture]]) }
+    def wait_any(*futures); end
+
+    sig { returns(T.untyped) }
+    def request; end
+
+    sig { returns(String) }
+    def key; end
+  end
+
+  # VirtualObject shared handler context (read-only state).
+  module ObjectSharedContext
+    include Context
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def get(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, serde: T.untyped).returns(DurableFuture) }
+    def get_async(name, serde: Restate::JsonSerde); end
+
+    sig { returns(T.untyped) }
+    def state_keys; end
+
+    sig { returns(DurableFuture) }
+    def state_keys_async; end
+  end
+
+  # VirtualObject exclusive handler context (full state access).
+  module ObjectContext
+    include ObjectSharedContext
+
+    sig { params(name: String, value: T.untyped, serde: T.untyped).void }
+    def set(name, value, serde: Restate::JsonSerde); end
+
+    sig { params(name: String).void }
+    def clear(name); end
+
+    sig { void }
+    def clear_all; end
+  end
+
+  # Workflow shared handler context (read-only state + promises).
+  module WorkflowSharedContext
+    include ObjectSharedContext
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def peek_promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_promise(name, payload, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, message: String, code: Integer).void }
+    def reject_promise(name, message, code: 500); end
+  end
+
+  # Workflow main handler context (full state + promises).
+  module WorkflowContext
+    include ObjectContext
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, serde: T.untyped).returns(T.untyped) }
+    def peek_promise(name, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, payload: T.untyped, serde: T.untyped).void }
+    def resolve_promise(name, payload, serde: Restate::JsonSerde); end
+
+    sig { params(name: String, message: String, code: Integer).void }
+    def reject_promise(name, message, code: 500); end
+  end
+
+  # Stateless service base class.
+  class Service; end
+
+  # Keyed virtual object base class.
+  class VirtualObject; end
+
+  # Durable workflow base class.
+  class Workflow; end
+
+  class Endpoint
+    sig { params(services: T.untyped).void }
+    def bind(*services); end
+
+    sig { void }
+    def streaming_protocol; end
+
+    sig { void }
+    def request_response_protocol; end
+
+    sig { params(key: String).void }
+    def identity_key(key); end
+
+    sig { returns(T.untyped) }
+    def app; end
+  end
+
+  module JsonSerde; end
+  module BytesSerde; end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.5.0
+  version: 0.5.1
 platform: aarch64-linux
 authors:
 - Restate Developers
@@ -89,6 +89,7 @@ files:
 - lib/restate/vm.rb
 - lib/restate/workflow.rb
 - lib/tapioca/dsl/compilers/restate.rb
+- rbi/restate-sdk.rbi
 homepage: https://github.com/restatedev/sdk-ruby
 licenses:
 - MIT