restate-sdk 0.6.0-aarch64-linux → 0.8.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '08c58b099881b9e29b7916d8fdf889061deec26b3cd10cdaba26b3d1a0a5411b'
-  data.tar.gz: a2ed4acff5fd49fdcf35010a5f5ebfddf0c117eac4adf3a7741f18130d9a4461
+  metadata.gz: 3d6b44b67a72794c5def96163fbc7a1a134180ddca5477083468a2d88720b756
+  data.tar.gz: 36032a61a77ba21adde9b2cf2aede6456812fc4a40ec98bb082cc5e2a5676ae3
 SHA512:
-  metadata.gz: 7f1cb8d1b8ffcbb86da980bbfcb80f378a8649b7747916690f51541c0777453adb14e963c1ee2f2250d062eb02ce6234b5b68d104887d326301a71ef40a78057
-  data.tar.gz: 8f0e41f655233dde1afd08dc2d722019c20ca0f105497bc147d08c7d657b9631c7f42e170e840a21806173acffaa089609929701a4cba3c37c3a05bcb7fe69df
+  metadata.gz: ec7cef72a64b0158f9a6bec982d6ec68718133ad527b5fbc0e9d30969bad539cbb5e4427eb98877d42c6a947fd5bcae080ed235097a31c0cf119e648f12fc03c
+  data.tar.gz: d7c3432a6a02c9442d56b164d1de390899683bc20b2775392cff1515fbc234bb84d36515c67a23926c4945386e9cf481dbaead5ed7a8a6f73f91959a4496dd7b

data/Cargo.lock

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

data/README.md

@@ -13,8 +13,20 @@
 require 'restate'
 
 class Greeter < Restate::Service
-  handler def greet(ctx, name)
-    ctx.run_sync('build-greeting') { "Hello, #{name}!" }
+  handler def greet(name)
+    Restate.run_sync('build-greeting') { "Hello, #{name}!" }
+  end
+end
+
+class Counter < Restate::VirtualObject
+  state :count, default: 0
+
+  handler def add(addend)
+    self.count += addend
+  end
+
+  shared def get
+    count
   end
 end
 ```
@@ -46,29 +58,34 @@ Or add the gem to an existing project:
 gem install restate-sdk
 ```
 
-### Typed handlers with T::Struct
+### Typed handlers with Dry::Struct
 
-Use Sorbet's `T::Struct` for typed input/output with automatic JSON Schema generation:
+Use [dry-struct](https://dry-rb.org/gems/dry-struct/) for typed input/output with automatic JSON Schema generation:
 
 ```ruby
 require 'restate'
+require 'dry-struct'
+
+module Types
+  include Dry.Types()
+end
 
-class RegistrationRequest < T::Struct
-  const :event_name, String
-  const :attendee, String
-  const :num_guests, Integer
-  const :note, T.nilable(String)
+class RegistrationRequest < Dry::Struct
+  attribute :event_name, Types::String
+  attribute :attendee, Types::String
+  attribute :num_guests, Types::Integer
+  attribute? :note, Types::String       # optional attribute
 end
 
-class RegistrationResponse < T::Struct
-  const :registration_id, String
-  const :status, String
+class RegistrationResponse < Dry::Struct
+  attribute :registration_id, Types::String
+  attribute :status, Types::String
 end
 
 class EventService < Restate::Service
   handler :register, input: RegistrationRequest, output: RegistrationResponse
-  def register(ctx, request)
-    registration_id = ctx.run_sync('create-registration') do
+  def register(request)
+    registration_id = Restate.run_sync('create-registration') do
       "reg_#{request.event_name}_#{rand(10_000)}"
     end
 

data/ext/restate_internal/Cargo.toml

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

data/lib/restate/client.rb

@@ -0,0 +1,157 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+
+module Restate
+  # HTTP client for invoking Restate services and managing the Restate runtime
+  # from outside the Restate runtime.
+  #
+  # @example Via global config (recommended)
+  #   Restate.configure do |c|
+  #     c.ingress_url = "http://localhost:8080"
+  #     c.admin_url = "http://localhost:9070"
+  #   end
+  #   client = Restate.client
+  #   result = client.service(Greeter).greet("World")
+  #
+  # @example Standalone
+  #   client = Restate::Client.new(ingress_url: "http://localhost:8080",
+  #                                admin_url: "http://localhost:9070")
+  #
+  # @example Service invocation
+  #   client.service("Greeter").greet("World")
+  #   client.object("Counter", "my-key").add(5)
+  #   client.workflow("UserSignup", "user42").run("user@example.com")
+  #
+  # @example Admin operations
+  #   client.resolve_awakeable(awakeable_id, "result")
+  #   client.reject_awakeable(awakeable_id, "failed")
+  #   client.cancel_invocation(invocation_id)
+  #   client.create_deployment("http://localhost:9080")
+  class Client
+    def initialize(ingress_url: 'http://localhost:8080', admin_url: 'http://localhost:9070',
+                   ingress_headers: {}, admin_headers: {})
+      @ingress_url = ingress_url.chomp('/')
+      @admin_url = admin_url.chomp('/')
+      @ingress_headers = ingress_headers
+      @admin_headers = admin_headers
+    end
+
+    # ── Service invocation proxies ──
+
+    # Returns a proxy for calling a stateless service.
+    def service(service)
+      ClientServiceProxy.new(@ingress_url, resolve_name(service), nil, @ingress_headers)
+    end
+
+    # Returns a proxy for calling a keyed virtual object.
+    def object(service, key)
+      ClientServiceProxy.new(@ingress_url, resolve_name(service), key, @ingress_headers)
+    end
+
+    # Returns a proxy for calling a workflow.
+    def workflow(service, key)
+      ClientServiceProxy.new(@ingress_url, resolve_name(service), key, @ingress_headers)
+    end
+
+    # ── Awakeable operations ──
+
+    # Resolve an awakeable from outside the Restate runtime.
+    def resolve_awakeable(awakeable_id, payload)
+      post_ingress("/restate/awakeables/#{awakeable_id}/resolve", payload)
+    end
+
+    # Reject an awakeable from outside the Restate runtime.
+    def reject_awakeable(awakeable_id, message, code: 500)
+      post_ingress("/restate/awakeables/#{awakeable_id}/reject",
+                   { 'message' => message, 'code' => code })
+    end
+
+    # ── Invocation management ──
+
+    # Cancel a running invocation.
+    def cancel_invocation(invocation_id)
+      post_admin("/restate/invocations/#{invocation_id}/cancel", nil)
+    end
+
+    # Kill a running invocation (immediate termination, no cleanup).
+    def kill_invocation(invocation_id)
+      post_admin("/restate/invocations/#{invocation_id}/kill", nil)
+    end
+
+    private
+
+    def resolve_name(service)
+      if service.is_a?(Class) && service.respond_to?(:service_name)
+        service.service_name # steep:ignore NoMethod
+      else
+        service.to_s
+      end
+    end
+
+    def post_ingress(path, body) # rubocop:disable Metrics/AbcSize
+      uri = URI("#{@ingress_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      @ingress_headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(body) if body
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
+                                 use_ssl: uri.scheme == 'https',
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate ingress error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      parse_response(response)
+    end
+
+    def post_admin(path, body) # rubocop:disable Metrics/AbcSize
+      uri = URI("#{@admin_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      @admin_headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(body) if body
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
+                                 use_ssl: uri.scheme == 'https',
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate admin error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      parse_response(response)
+    end
+
+    def parse_response(response)
+      body = response.body
+      body && !body.empty? ? JSON.parse(body) : nil
+    end
+  end
+
+  # Proxy that sends HTTP requests to the Restate ingress for a specific service.
+  # Handler calls are forwarded via +method_missing+.
+  #
+  # @!visibility private
+  class ClientServiceProxy
+    def initialize(base_url, service_name, key, headers)
+      @base_url = base_url
+      @service_name = service_name
+      @key = key
+      @headers = headers
+    end
+
+    def method_missing(handler_name, arg = nil) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      path = @key ? "/#{@service_name}/#{@key}/#{handler_name}" : "/#{@service_name}/#{handler_name}"
+      uri = URI("#{@base_url}#{path}")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      @headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate(arg)
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
+                                 use_ssl: uri.scheme == 'https',
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate ingress error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      body = response.body
+      body && !body.empty? ? JSON.parse(body) : nil
+    end
+
+    def respond_to_missing?(_method_name, _include_private = false)
+      true
+    end
+  end
+end

data/lib/restate/config.rb

@@ -0,0 +1,35 @@
+# typed: true
+# frozen_string_literal: true
+
+module Restate
+  # Global SDK configuration. Set via +Restate.configure+.
+  #
+  # @example
+  #   Restate.configure do |c|
+  #     c.ingress_url = "http://localhost:8080"
+  #     c.admin_url   = "http://localhost:9070"
+  #   end
+  #
+  #   # Then use the pre-configured client:
+  #   Restate.client.service(Greeter).greet("World")
+  class Config
+    # Restate ingress URL (for invoking services).
+    attr_accessor :ingress_url
+
+    # Restate admin URL (for deployments, invocation management).
+    attr_accessor :admin_url
+
+    # Default headers sent with every ingress request.
+    attr_accessor :ingress_headers
+
+    # Default headers sent with every admin request.
+    attr_accessor :admin_headers
+
+    def initialize
+      @ingress_url = 'http://localhost:8080'
+      @admin_url = 'http://localhost:9070'
+      @ingress_headers = {}
+      @admin_headers = {}
+    end
+  end
+end

data/lib/restate/context.rb

@@ -1,7 +1,7 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/ModuleLength,Metrics/ParameterLists,Style/EmptyMethod
+# rubocop:disable Style/EmptyMethod
 module Restate
   # Signals when the current invocation attempt has finished — either the handler
   # completed, the connection was lost, or a transient error occurred.
@@ -17,27 +17,22 @@ module Restate
   #     # poll event.set? periodically, or pass it to your HTTP client
   #   end
   class AttemptFinishedEvent
-    extend T::Sig
-
-    sig { void }
     def initialize
-      @mutex = T.let(Mutex.new, Mutex)
-      @set = T.let(false, T::Boolean)
-      @waiters = T.let([], T::Array[Thread::Queue])
+      @mutex = Mutex.new
+      @set = false
+      @waiters = []
     end
 
     # Returns true if the attempt has finished.
-    sig { returns(T::Boolean) }
     def set?
       @set
     end
 
     # Blocks the current fiber/thread until the attempt finishes.
-    sig { void }
     def wait
       return if @set
 
-      waiter = T.let(nil, T.nilable(Thread::Queue))
+      waiter = nil
       @mutex.synchronize do
         unless @set
           waiter = Thread::Queue.new
@@ -49,7 +44,6 @@ module Restate
 
     # Marks the event as set and wakes all waiters.
     # Called internally by the SDK when the attempt ends.
-    sig { void }
     def set!
       @mutex.synchronize do
         @set = true
@@ -79,258 +73,149 @@ module Restate
   # @see ObjectContext for VirtualObject handlers (adds state operations)
   # @see WorkflowContext for Workflow handlers (adds promise operations)
   module Context
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
-
     # Execute a durable side effect. The block runs at most once; the result
     # is journaled and replayed on retries.
     #
     # Pass +background: true+ to offload the block to a real OS Thread,
     # keeping the fiber event loop responsive for CPU-intensive work.
-    sig do
-      abstract.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: JsonSerde, retry_policy: nil, background: false, &action); end
 
     # Convenience shortcut for +run(...).await+. Returns the result directly.
     # Accepts all the same options as +run+, including +background: true+.
-    sig do
-      abstract.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: JsonSerde, retry_policy: nil, background: false, &action); end
 
     # Durable timer that survives handler restarts.
-    sig { params(seconds: Numeric).returns(DurableFuture) }
     def sleep(seconds) # rubocop:disable Lint/UnusedMethodArgument
       Kernel.raise NotImplementedError
     end
 
     # Durably call a handler on a Restate service.
-    sig do
-      abstract.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: NOT_SET, output_serde: NOT_SET)
     end
+
     # Fire-and-forget send to a Restate service handler.
-    sig do
-      abstract.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: NOT_SET)
     end
+
     # Durably call a handler on a Restate virtual object.
-    sig do
-      abstract.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: NOT_SET, output_serde: NOT_SET)
     end
+
     # Fire-and-forget send to a Restate virtual object handler.
-    sig do
-      abstract.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: NOT_SET)
     end
+
     # Durably call a handler on a Restate workflow.
-    sig do
-      abstract.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: NOT_SET, output_serde: NOT_SET)
     end
+
     # Fire-and-forget send to a Restate workflow handler.
-    sig do
-      abstract.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: NOT_SET)
     end
+
     # Durably call a handler using raw bytes (no serialization).
-    sig do
-      abstract.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
 
     # Fire-and-forget send using raw bytes (no serialization).
-    sig do
-      abstract.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
 
     # Create an awakeable for external callbacks.
     # Returns [awakeable_id, DurableFuture].
-    sig { abstract.params(serde: T.untyped).returns([String, DurableFuture]) }
     def awakeable(serde: JsonSerde); end
 
     # Resolve an awakeable with a success value.
-    sig { abstract.params(awakeable_id: String, payload: T.untyped, serde: T.untyped).void }
     def resolve_awakeable(awakeable_id, payload, serde: JsonSerde); end
 
     # Reject an awakeable with a terminal failure.
-    sig { abstract.params(awakeable_id: String, message: String, code: Integer).void }
     def reject_awakeable(awakeable_id, message, code: 500); end
 
     # Request cancellation of another invocation.
-    sig { abstract.params(invocation_id: String).void }
     def cancel_invocation(invocation_id); end
 
     # Wait until any of the given futures completes.
     # Returns [completed, remaining].
-    sig { abstract.params(futures: DurableFuture).returns([T::Array[DurableFuture], T::Array[DurableFuture]]) }
     def wait_any(*futures); end
 
     # Returns metadata about the current invocation.
-    sig { abstract.returns(Request) }
     def request; end
 
     # Returns the key for this virtual object or workflow invocation.
-    sig { abstract.returns(String) }
     def key; end
   end
 
   # Context interface for VirtualObject shared handlers (read-only state).
   # Extends {Context} with +get+, +state_keys+, and +key+ — but no mutations.
   module ObjectSharedContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include Context
 
     # Durably retrieve a state entry. Returns nil if unset.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def get(name, serde: JsonSerde); end
 
     # Durably retrieve a state entry, returning a DurableFuture instead of blocking.
-    sig { abstract.params(name: String, serde: T.untyped).returns(DurableFuture) }
     def get_async(name, serde: JsonSerde); end
 
     # List all state entry names.
-    sig { abstract.returns(T.untyped) }
     def state_keys; end
 
     # List all state entry names, returning a DurableFuture instead of blocking.
-    sig { abstract.returns(DurableFuture) }
     def state_keys_async; end
   end
 
   # Context interface for VirtualObject exclusive handlers (full state access).
   # Extends {ObjectSharedContext} with mutating state operations.
   module ObjectContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include ObjectSharedContext
 
     # Durably set a state entry.
-    sig { abstract.params(name: String, value: T.untyped, serde: T.untyped).void }
     def set(name, value, serde: JsonSerde); end
 
     # Durably remove a single state entry.
-    sig { abstract.params(name: String).void }
     def clear(name); end
 
     # Durably remove all state entries.
-    sig { abstract.void }
     def clear_all; end
   end
 
   # Context interface for Workflow shared handlers (read-only state + promises).
   # Extends {ObjectSharedContext} with durable promise operations.
   module WorkflowSharedContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include ObjectSharedContext
 
     # Get a durable promise value, blocking until resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def promise(name, serde: JsonSerde); end
 
     # Peek at a durable promise without blocking. Returns nil if not yet resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def peek_promise(name, serde: JsonSerde); end
 
     # Resolve a durable promise with a value.
-    sig { abstract.params(name: String, payload: T.untyped, serde: T.untyped).void }
     def resolve_promise(name, payload, serde: JsonSerde); end
 
     # Reject a durable promise with a terminal failure.
-    sig { abstract.params(name: String, message: String, code: Integer).void }
     def reject_promise(name, message, code: 500); end
   end
 
   # Context interface for Workflow main handler (full state + promises).
   # Extends {ObjectContext} with durable promise operations.
   module WorkflowContext
-    extend T::Sig
-    extend T::Helpers
-
-    abstract!
     include ObjectContext
 
     # Get a durable promise value, blocking until resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def promise(name, serde: JsonSerde); end
 
     # Peek at a durable promise without blocking. Returns nil if not yet resolved.
-    sig { abstract.params(name: String, serde: T.untyped).returns(T.untyped) }
     def peek_promise(name, serde: JsonSerde); end
 
     # Resolve a durable promise with a value.
-    sig { abstract.params(name: String, payload: T.untyped, serde: T.untyped).void }
     def resolve_promise(name, payload, serde: JsonSerde); end
 
     # Reject a durable promise with a terminal failure.
-    sig { abstract.params(name: String, message: String, code: Integer).void }
     def reject_promise(name, message, code: 500); end
   end
 end
-# rubocop:enable Metrics/ModuleLength,Metrics/ParameterLists,Style/EmptyMethod
+# rubocop:enable Style/EmptyMethod