restate-sdk 0.7.0-aarch64-linux → 0.9.0-aarch64-linux

data/lib/restate/durable_future.rb

@@ -5,24 +5,19 @@ module Restate
   # A durable future wrapping a VM handle. Lazily resolves on first +await+ and caches the result.
   # Returned by +ctx.run+ and +ctx.sleep+.
   class DurableFuture
-    extend T::Sig
-
-    sig { returns(Integer) }
     attr_reader :handle
 
-    sig { params(ctx: ServerContext, handle: Integer, serde: T.untyped).void }
     def initialize(ctx, handle, serde: nil)
-      @ctx = T.let(ctx, ServerContext)
-      @handle = T.let(handle, Integer)
-      @serde = T.let(serde, T.untyped)
-      @resolved = T.let(false, T::Boolean)
-      @value = T.let(nil, T.untyped)
+      @ctx = ctx
+      @handle = handle
+      @serde = serde
+      @resolved = false
+      @value = nil
     end
 
     # Block until the result is available and return it. Caches across calls.
     #
     # @return [Object] the deserialized result
-    sig { returns(T.untyped) }
     def await
       unless @resolved
         raw = @ctx.resolve_handle(@handle)
@@ -35,7 +30,6 @@ module Restate
     # Check whether the future has completed (non-blocking).
     #
     # @return [Boolean]
-    sig { returns(T::Boolean) }
     def completed?
       @resolved || @ctx.completed?(@handle)
     end
@@ -45,26 +39,15 @@ module Restate
   # Adds +invocation_id+ and +cancel+ on top of DurableFuture.
   # Returned by +ctx.service_call+, +ctx.object_call+, +ctx.workflow_call+.
   class DurableCallFuture < DurableFuture
-    extend T::Sig
-
-    sig do
-      params(
-        ctx: ServerContext,
-        result_handle: Integer,
-        invocation_id_handle: Integer,
-        output_serde: T.untyped
-      ).void
-    end
     def initialize(ctx, result_handle, invocation_id_handle, output_serde:)
       super(ctx, result_handle)
-      @invocation_id_handle = T.let(invocation_id_handle, Integer)
-      @output_serde = T.let(output_serde, T.untyped)
-      @invocation_id_resolved = T.let(false, T::Boolean)
-      @invocation_id_value = T.let(nil, T.untyped)
+      @invocation_id_handle = invocation_id_handle
+      @output_serde = output_serde
+      @invocation_id_resolved = false
+      @invocation_id_value = nil
     end
 
     # Block until the result is available and return it. Deserializes via +output_serde+.
-    sig { returns(T.untyped) }
     def await
       unless @resolved
         raw = @ctx.resolve_handle(@handle)
@@ -81,17 +64,15 @@ module Restate
     # Returns the invocation ID of the remote call. Lazily resolved.
     #
     # @return [String] the invocation ID
-    sig { returns(String) }
     def invocation_id
       unless @invocation_id_resolved
         @invocation_id_value = @ctx.resolve_handle(@invocation_id_handle)
         @invocation_id_resolved = true
       end
-      T.must(@invocation_id_value)
+      @invocation_id_value
     end
 
     # Cancel the remote invocation.
-    sig { void }
     def cancel
       @ctx.cancel_invocation(invocation_id)
     end
@@ -100,30 +81,25 @@ module Restate
   # A handle for fire-and-forget send operations.
   # Returned by +ctx.service_send+, +ctx.object_send+, +ctx.workflow_send+.
   class SendHandle
-    extend T::Sig
-
-    sig { params(ctx: ServerContext, invocation_id_handle: Integer).void }
     def initialize(ctx, invocation_id_handle)
-      @ctx = T.let(ctx, ServerContext)
-      @invocation_id_handle = T.let(invocation_id_handle, Integer)
-      @invocation_id_resolved = T.let(false, T::Boolean)
-      @invocation_id_value = T.let(nil, T.untyped)
+      @ctx = ctx
+      @invocation_id_handle = invocation_id_handle
+      @invocation_id_resolved = false
+      @invocation_id_value = nil
     end
 
     # Returns the invocation ID of the sent call. Lazily resolved.
     #
     # @return [String] the invocation ID
-    sig { returns(String) }
     def invocation_id
       unless @invocation_id_resolved
         @invocation_id_value = @ctx.resolve_handle(@invocation_id_handle)
         @invocation_id_resolved = true
       end
-      T.must(@invocation_id_value)
+      @invocation_id_value
     end
 
     # Cancel the remote invocation.
-    sig { void }
     def cancel
       @ctx.cancel_invocation(invocation_id)
     end

data/lib/restate/endpoint.rb

@@ -4,26 +4,16 @@
 module Restate
   # Container for registered services. Bind services here, then create the Rack app.
   class Endpoint
-    extend T::Sig
+    attr_reader :services, :identity_keys, :middleware, :outbound_middleware
 
-    sig { returns(T::Hash[String, T.untyped]) }
-    attr_reader :services
-
-    sig { returns(T::Array[String]) }
-    attr_reader :identity_keys
-
-    sig { returns(T.nilable(String)) }
     attr_accessor :protocol
 
-    sig { returns(T::Array[T.untyped]) }
-    attr_reader :middleware
-
-    sig { void }
     def initialize
-      @services = T.let({}, T::Hash[String, T.untyped])
-      @protocol = T.let(nil, T.nilable(String))
-      @identity_keys = T.let([], T::Array[String])
-      @middleware = T.let([], T::Array[T.untyped])
+      @services = {}
+      @protocol = nil
+      @identity_keys = []
+      @middleware = []
+      @outbound_middleware = []
     end
 
     # Bind one or more services to this endpoint.
@@ -31,7 +21,6 @@ module Restate
     # @param svcs [Array<Class<Service>, Class<VirtualObject>, Class<Workflow>>] services to bind
     # @return [self]
     # @raise [ArgumentError] if a service with the same name is already bound
-    sig { params(svcs: T.untyped).returns(T.self_type) }
     def bind(*svcs)
       svcs.each do |svc|
         svc_name = svc.service_name
@@ -43,49 +32,42 @@ module Restate
     end
 
     # Force bidirectional streaming protocol.
-    sig { returns(T.self_type) }
     def streaming_protocol
       @protocol = 'bidi'
       self
     end
 
     # Force request/response protocol.
-    sig { returns(T.self_type) }
     def request_response_protocol
       @protocol = 'request_response'
       self
     end
 
     # Add an identity key for request verification.
-    sig { params(key: String).returns(T.self_type) }
     def identity_key(key)
       @identity_keys << key
       self
     end
 
-    # Add handler-level middleware.
+    # Add inbound (server) middleware.
     #
-    # Middleware wraps every handler invocation with access to the handler metadata
-    # and context. Use it for tracing, metrics, logging, error reporting, etc.
+    # Inbound middleware wraps every handler invocation, like
+    # {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq server middleware}.
     #
     # A middleware is a class whose instances respond to +call(handler, ctx)+.
     # Use +yield+ inside +call+ to invoke the next middleware or the handler.
     # The return value of +yield+ is the handler's return value.
     #
-    # This follows the same pattern as {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq middleware}.
-    #
     # @example OpenTelemetry tracing
-    #   class OpenTelemetryMiddleware
+    #   class TracingMiddleware
     #     def call(handler, ctx)
-    #       tracer.in_span(handler.name, attributes: {
-    #         'restate.service' => handler.service_tag.name,
-    #         'restate.invocation_id' => ctx.request.id
-    #       }) do
-    #         yield
+    #       extracted = OpenTelemetry.propagation.extract(ctx.request.headers)
+    #       OpenTelemetry::Context.with_current(extracted) do
+    #         tracer.in_span(handler.name) { yield }
     #       end
     #     end
     #   end
-    #   endpoint.use(OpenTelemetryMiddleware)
+    #   endpoint.use(TracingMiddleware)
     #
     # @example Metrics
     #   class MetricsMiddleware
@@ -99,39 +81,70 @@ module Restate
     #   end
     #   endpoint.use(MetricsMiddleware)
     #
-    # @example Middleware with configuration
-    #   class AuthMiddleware
-    #     def initialize(api_key:)
-    #       @api_key = api_key
+    # @param klass [Class] middleware class (will be instantiated by the SDK)
+    # @param args [Array] positional arguments for the middleware constructor
+    # @param kwargs [Hash] keyword arguments for the middleware constructor
+    # @return [self]
+    def use(klass, *args, **kwargs)
+      @middleware << instantiate_middleware(klass, args, kwargs)
+      self
+    end
+
+    # Add outbound (client) middleware.
+    #
+    # Outbound middleware wraps every outgoing service call and send, like
+    # {https://github.com/sidekiq/sidekiq/wiki/Middleware Sidekiq client middleware}.
+    #
+    # A middleware is a class whose instances respond to +call(service, handler, headers)+.
+    # The +headers+ hash is mutable — modify it to attach headers to the outgoing
+    # request. Use +yield+ to continue the chain.
+    #
+    # Note: Restate automatically propagates inbound headers to outbound calls.
+    # Outbound middleware is for injecting *new* headers that aren't on the
+    # original request (e.g., tenant IDs from fiber-local storage, authorization
+    # tokens for specific target services).
+    #
+    # @example Propagate tenant ID to all outgoing calls
+    #   class TenantOutboundMiddleware
+    #     def call(_service, _handler, headers)
+    #       headers['x-tenant-id'] = Thread.current[:tenant_id]
+    #       yield
     #     end
+    #   end
+    #   endpoint.use_outbound(TenantOutboundMiddleware)
     #
-    #     def call(handler, ctx)
-    #       raise Restate::TerminalError.new('unauthorized', status_code: 401) unless valid?(ctx)
+    # @example Log all outgoing calls
+    #   class OutboundLogger
+    #     def call(service, handler, headers)
+    #       logger.info("Calling #{service}/#{handler}")
     #       yield
     #     end
     #   end
-    #   endpoint.use(AuthMiddleware, api_key: 'secret')
+    #   endpoint.use_outbound(OutboundLogger)
     #
     # @param klass [Class] middleware class (will be instantiated by the SDK)
     # @param args [Array] positional arguments for the middleware constructor
     # @param kwargs [Hash] keyword arguments for the middleware constructor
     # @return [self]
-    sig { params(klass: T.untyped, args: T.untyped, kwargs: T.untyped).returns(T.self_type) }
-    def use(klass, *args, **kwargs)
-      instance = if kwargs.empty?
-                   klass.new(*args)
-                 else
-                   klass.new(*args, **kwargs)
-                 end
-      @middleware << instance
+    def use_outbound(klass, *args, **kwargs)
+      @outbound_middleware << instantiate_middleware(klass, args, kwargs)
       self
     end
 
     # Build and return the Rack-compatible application.
-    sig { returns(T.untyped) }
     def app
       require_relative 'server'
       Server.new(self)
     end
+
+    private
+
+    def instantiate_middleware(klass, args, kwargs)
+      if kwargs.empty?
+        klass.new(*args)
+      else
+        klass.new(*args, **kwargs)
+      end
+    end
   end
 end

data/lib/restate/errors.rb

@@ -1,4 +1,4 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 module Restate
@@ -7,24 +7,17 @@ module Restate
   # @example
   #   raise Restate::TerminalError.new('not found', status_code: 404)
   class TerminalError < StandardError
-    extend T::Sig
-
-    sig { returns(Integer) }
     attr_reader :status_code
 
-    sig { params(message: String, status_code: Integer).void }
     def initialize(message = 'Internal Server Error', status_code: 500)
       super(message)
-      @status_code = T.let(status_code, Integer)
+      @status_code = status_code
     end
   end
 
   # Internal: raised when the VM suspends execution.
   # User code should NOT catch this.
   class SuspendedError < StandardError
-    extend T::Sig
-
-    sig { void }
     def initialize
       super(
         "Invocation got suspended, Restate will resume this invocation when progress can be made.\n" \
@@ -37,9 +30,6 @@ module Restate
 
   # Internal: raised when the VM encounters a retryable error.
   class InternalError < StandardError
-    extend T::Sig
-
-    sig { void }
     def initialize
       super(
         "Invocation attempt raised a retryable error.\n" \
@@ -50,9 +40,6 @@ module Restate
 
   # Internal: raised when the HTTP connection is lost.
   class DisconnectedError < StandardError
-    extend T::Sig
-
-    sig { void }
     def initialize
       super('Disconnected. The connection to the restate server was lost. Restate will retry the attempt.')
     end

data/lib/restate/handler.rb

@@ -27,39 +27,39 @@ module Restate
     keyword_init: true
   )
 
-  extend T::Sig
-
   module_function
 
   # Invoke a handler with the context and raw input bytes.
   # The context is passed as the first argument to every handler.
   # Middleware (if any) wraps the handler call.
   # Returns raw output bytes.
-  sig do
-    params(handler: T.untyped, ctx: T.untyped, in_buffer: String,
-           middleware: T::Array[T.untyped]).returns(String)
+  def invoke_handler(handler:, ctx:, in_buffer:, middleware: [])
+    out_arg = if middleware.empty?
+                invoke_handler_direct(handler, in_buffer)
+              else
+                invoke_handler_with_middleware(handler, ctx, in_buffer, middleware)
+              end
+    handler.handler_io.output_serde.serialize(out_arg)
   end
-  def invoke_handler(handler:, ctx:, in_buffer:, middleware: []) # rubocop:disable Metrics/AbcSize
-    call_handler = Kernel.proc do
-      if handler.arity == 1
-        begin
-          in_arg = handler.handler_io.input_serde.deserialize(in_buffer)
-        rescue StandardError => e
-          Kernel.raise TerminalError, "Unable to parse input argument: #{e.message}"
-        end
-        handler.callable.call(in_arg)
-      else
-        handler.callable.call
+
+  def invoke_handler_direct(handler, in_buffer)
+    if handler.arity == 1
+      begin
+        in_arg = handler.handler_io.input_serde.deserialize(in_buffer)
+      rescue StandardError => e
+        Kernel.raise TerminalError, "Unable to parse input argument: #{e.message}"
       end
+      handler.callable.call(in_arg)
+    else
+      handler.callable.call
     end
+  end
 
-    # Build the middleware chain so each middleware can use `yield` to call the next.
-    # Middleware still receives (handler, ctx) for low-level access.
+  def invoke_handler_with_middleware(handler, ctx, in_buffer, middleware)
+    call_handler = Kernel.proc { invoke_handler_direct(handler, in_buffer) }
     chain = middleware.reverse.reduce(call_handler) do |nxt, mw|
       Kernel.proc { mw.call(handler, ctx, &nxt) }
     end
-
-    out_arg = chain.call
-    handler.handler_io.output_serde.serialize(out_arg)
+    chain.call
   end
 end