restate-sdk 0.6.0 → 0.8.0

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,15 @@
 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
 
-    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 = []
     end
 
     # Bind one or more services to this endpoint.
@@ -31,7 +20,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,21 +31,18 @@ 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
@@ -116,7 +101,6 @@ module Restate
     # @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)
@@ -128,7 +112,6 @@ module Restate
     end
 
     # Build and return the Rack-compatible application.
-    sig { returns(T.untyped) }
     def app
       require_relative 'server'
       Server.new(self)

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,38 +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 == 2
-        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(ctx, in_arg)
-      else
-        handler.callable.call(ctx)
+
+  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.
+  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

data/lib/restate/serde.rb

@@ -4,23 +4,22 @@
 require 'json'
 
 module Restate
+  EMPTY_BYTES = ''.b.freeze
+  private_constant :EMPTY_BYTES
+
   # JSON serializer/deserializer (default).
   # Converts Ruby objects to JSON byte strings and back.
   module JsonSerde
-    extend T::Sig
-
     module_function
 
     # Serialize a Ruby object to a JSON byte string. Returns empty bytes for nil.
-    sig { params(obj: T.untyped).returns(String) }
     def serialize(obj)
-      return ''.b if obj.nil?
+      return EMPTY_BYTES if obj.nil?
 
       JSON.generate(obj).b
     end
 
     # Deserialize a JSON byte string to a Ruby object. Returns nil for nil or empty input.
-    sig { params(buf: T.nilable(String)).returns(T.untyped) }
     def deserialize(buf)
       return nil if buf.nil? || buf.empty?
 
@@ -28,7 +27,6 @@ module Restate
     end
 
     # Return the JSON Schema for this serde, or nil if unspecified.
-    sig { returns(T.nilable(T::Hash[String, T.untyped])) }
     def json_schema
       nil
     end
@@ -40,26 +38,21 @@ module Restate
   # Pass-through bytes serializer/deserializer.
   # Passes binary data through without transformation.
   module BytesSerde
-    extend T::Sig
-
     module_function
 
     # Serialize an object by returning its binary encoding. Returns empty bytes for nil.
-    sig { params(obj: T.untyped).returns(String) }
     def serialize(obj)
-      return ''.b if obj.nil?
+      return EMPTY_BYTES if obj.nil?
 
       obj.b
     end
 
     # Deserialize by returning the raw buffer unchanged.
-    sig { params(buf: T.nilable(String)).returns(T.nilable(String)) }
     def deserialize(buf)
       buf
     end
 
     # Return the JSON Schema for this serde, or nil if unspecified.
-    sig { returns(T.nilable(T::Hash[String, T.untyped])) }
     def json_schema
       nil
     end
@@ -67,34 +60,29 @@ module Restate
 
   # Maps Ruby primitive types to JSON Schema snippets for discovery.
   PRIMITIVE_SCHEMAS = {
-    String => { 'type' => 'string' },
-    Integer => { 'type' => 'integer' },
-    Float => { 'type' => 'number' },
-    TrueClass => { 'type' => 'boolean' },
-    FalseClass => { 'type' => 'boolean' },
-    Array => { 'type' => 'array' },
-    Hash => { 'type' => 'object' },
-    NilClass => { 'type' => 'null' }
+    String => { 'type' => 'string' }.freeze,
+    Integer => { 'type' => 'integer' }.freeze,
+    Float => { 'type' => 'number' }.freeze,
+    TrueClass => { 'type' => 'boolean' }.freeze,
+    FalseClass => { 'type' => 'boolean' }.freeze,
+    Array => { 'type' => 'array' }.freeze,
+    Hash => { 'type' => 'object' }.freeze,
+    NilClass => { 'type' => 'null' }.freeze
   }.freeze
 
   # Serde resolution utilities: converts a type or serde into a serde object.
   module Serde
-    extend T::Sig
-
     module_function
 
     # Check if an object quacks like a serde (has serialize + deserialize).
-    sig { params(obj: T.untyped).returns(T::Boolean) }
     def serde?(obj)
       obj.respond_to?(:serialize) && obj.respond_to?(:deserialize)
     end
 
     # Resolve a type or serde into a serde object with serialize/deserialize/json_schema.
-    sig { params(type_or_serde: T.untyped).returns(T.untyped) }
     def resolve(type_or_serde)
       return JsonSerde if type_or_serde.nil?
       return type_or_serde if serde?(type_or_serde)
-      return TStructSerde.new(type_or_serde) if t_struct?(type_or_serde)
       return DryStructSerde.new(type_or_serde) if dry_struct?(type_or_serde)
       return TypeSerde.new(type_or_serde, PRIMITIVE_SCHEMAS[type_or_serde]) if PRIMITIVE_SCHEMAS.key?(type_or_serde)
       return TypeSerde.new(type_or_serde, type_or_serde.json_schema) if type_or_serde.respond_to?(:json_schema)
@@ -102,60 +90,12 @@ module Restate
       JsonSerde
     end
 
-    # Check if a value is a T::Struct subclass.
-    sig { params(val: T.untyped).returns(T::Boolean) }
-    def t_struct?(val)
-      !!(val.is_a?(Class) && val < T::Struct)
-    end
-
     # Check if a value is a Dry::Struct subclass.
-    sig { params(val: T.untyped).returns(T.nilable(T::Boolean)) }
     def dry_struct?(val)
       defined?(::Dry::Struct) && val.is_a?(Class) && val < ::Dry::Struct
     end
 
-    # Generate a JSON Schema from a T::Struct class by introspecting its props.
-    sig { params(struct_class: T.class_of(T::Struct)).returns(T::Hash[String, T.untyped]) }
-    def t_struct_to_json_schema(struct_class) # rubocop:disable Metrics
-      properties = {}
-      required = []
-
-      T.unsafe(struct_class).props.each do |name, meta|
-        prop_name = (meta[:serialized_form] || name).to_s
-        properties[prop_name] = t_type_to_json_schema(meta[:type_object] || meta[:type])
-        required << prop_name unless meta[:fully_optional] || meta[:_tnilable]
-      end
-
-      schema = { 'type' => 'object', 'properties' => properties }
-      schema['required'] = required unless required.empty?
-      schema
-    end
-
-    # Convert a Sorbet T::Types type object to a JSON Schema hash.
-    sig { params(type: T.untyped).returns(T::Hash[String, T.untyped]) }
-    def t_type_to_json_schema(type) # rubocop:disable Metrics
-      case type
-      when T::Types::Simple
-        PRIMITIVE_SCHEMAS[type.raw_type] || {}
-      when T::Types::Union
-        schemas = type.types.map { |t| t_type_to_json_schema(t) }
-        schemas.uniq!
-        schemas.length == 1 ? schemas.first : { 'anyOf' => schemas }
-      when T::Types::TypedArray
-        { 'type' => 'array', 'items' => t_type_to_json_schema(type.type) }
-      when T::Types::TypedHash
-        { 'type' => 'object' }
-      when Class
-        return t_struct_to_json_schema(type) if type < T::Struct
-
-        PRIMITIVE_SCHEMAS[type] || {}
-      else
-        {}
-      end
-    end
-
     # Generate a JSON Schema from a Dry::Struct class.
-    sig { params(struct_class: T.untyped).returns(T::Hash[String, T.untyped]) }
     def dry_struct_to_json_schema(struct_class)
       properties = {}
       required = []
@@ -172,7 +112,6 @@ module Restate
     end
 
     # Convert a dry-types type to a JSON Schema hash.
-    sig { params(type: T.untyped).returns(T::Hash[String, T.untyped]) }
     def dry_type_to_json_schema(type) # rubocop:disable Metrics
       type_class = type.class.name || ''
 
@@ -198,7 +137,6 @@ module Restate
     end
 
     # Convert a nominal dry-type (with .primitive) to JSON Schema.
-    sig { params(type: T.untyped).returns(T::Hash[String, T.untyped]) }
     def nominal_to_json_schema(type)
       prim = type.primitive
       return dry_struct_to_json_schema(prim) if dry_struct?(prim)
@@ -210,32 +148,25 @@ module Restate
   # Serde wrapper for primitive types and classes with a .json_schema method.
   # Delegates serialize/deserialize to JsonSerde, adds schema.
   class TypeSerde
-    extend T::Sig
-
-    sig { returns(T.untyped) }
     attr_reader :type_class
 
     # Create a TypeSerde for the given type with a precomputed JSON Schema.
-    sig { params(type: T.untyped, schema: T.nilable(T::Hash[String, T.untyped])).void }
     def initialize(type, schema)
       @type_class = type
       @schema = schema
     end
 
     # Serialize a Ruby object to JSON bytes via JsonSerde.
-    sig { params(obj: T.untyped).returns(String) }
     def serialize(obj)
       JsonSerde.serialize(obj)
     end
 
     # Deserialize JSON bytes to a Ruby object via JsonSerde.
-    sig { params(buf: T.nilable(String)).returns(T.untyped) }
     def deserialize(buf)
       JsonSerde.deserialize(buf)
     end
 
     # Return the JSON Schema for this type.
-    sig { returns(T.nilable(T::Hash[String, T.untyped])) }
     def json_schema
       @schema
     end
@@ -244,28 +175,22 @@ module Restate
   # Serde for Dry::Struct types.
   # Deserializes JSON into struct instances, serializes structs to JSON.
   class DryStructSerde
-    extend T::Sig
-
-    sig { returns(T.untyped) }
     attr_reader :struct_class
 
     # Create a DryStructSerde for the given Dry::Struct class.
-    sig { params(struct_class: T.untyped).void }
     def initialize(struct_class)
       @struct_class = struct_class
     end
 
     # Serialize a Dry::Struct (or hash-like object) to JSON bytes.
-    sig { params(obj: T.untyped).returns(String) }
     def serialize(obj)
-      return ''.b if obj.nil?
+      return EMPTY_BYTES if obj.nil?
 
       hash = obj.respond_to?(:to_h) ? obj.to_h : obj
       JSON.generate(hash).b
     end
 
     # Deserialize JSON bytes into a Dry::Struct instance.
-    sig { params(buf: T.nilable(String)).returns(T.untyped) }
     def deserialize(buf)
       return nil if buf.nil? || buf.empty?
 
@@ -274,49 +199,8 @@ module Restate
     end
 
     # Return the JSON Schema derived from the Dry::Struct definition.
-    sig { returns(T::Hash[String, T.untyped]) }
     def json_schema
       @json_schema ||= Serde.dry_struct_to_json_schema(@struct_class)
     end
   end
-
-  # Serde for T::Struct types (Sorbet's native typed structs).
-  # Uses T::Struct#serialize for output and T::Struct.from_hash for input.
-  # Generates JSON Schema from T::Struct props introspection.
-  class TStructSerde
-    extend T::Sig
-
-    sig { returns(T.class_of(T::Struct)) }
-    attr_reader :struct_class
-
-    # Create a TStructSerde for the given T::Struct subclass.
-    sig { params(struct_class: T.class_of(T::Struct)).void }
-    def initialize(struct_class)
-      @struct_class = struct_class
-    end
-
-    # Serialize a T::Struct instance to JSON bytes.
-    sig { params(obj: T.untyped).returns(String) }
-    def serialize(obj)
-      return ''.b if obj.nil?
-
-      hash = obj.is_a?(T::Struct) ? obj.serialize : obj
-      JSON.generate(hash).b
-    end
-
-    # Deserialize JSON bytes into a T::Struct instance.
-    sig { params(buf: T.nilable(String)).returns(T.untyped) }
-    def deserialize(buf)
-      return nil if buf.nil? || buf.empty?
-
-      hash = JSON.parse(buf)
-      T.unsafe(@struct_class).from_hash(hash)
-    end
-
-    # Return the JSON Schema derived from the T::Struct props.
-    sig { returns(T::Hash[String, T.untyped]) }
-    def json_schema
-      @json_schema ||= Serde.t_struct_to_json_schema(@struct_class)
-    end
-  end
 end