restate-sdk 0.7.0 → 0.9.0

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

data/lib/restate/server.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: ignore
 # frozen_string_literal: true
 
 require 'async'
@@ -14,21 +14,17 @@ module Restate
   #   GET  /health                       → health check
   #   POST /invoke/:service/:handler     → handler invocation
   class Server
-    extend T::Sig
+    SDK_VERSION = Internal::SDK_VERSION
+    X_RESTATE_SERVER = "restate-sdk-ruby/#{SDK_VERSION}".freeze
 
-    SDK_VERSION = T.let(Internal::SDK_VERSION, String)
-    X_RESTATE_SERVER = T.let("restate-sdk-ruby/#{SDK_VERSION}".freeze, String)
+    LOGGER = Logger.new($stdout, progname: 'Restate::Server')
 
-    LOGGER = T.let(Logger.new($stdout, progname: 'Restate::Server'), Logger)
-
-    sig { params(endpoint: Endpoint).void }
     def initialize(endpoint)
-      @endpoint = T.let(endpoint, Endpoint)
-      @identity_verifier = T.let(Internal::IdentityVerifier.new(endpoint.identity_keys), Internal::IdentityVerifier)
+      @endpoint = endpoint
+      @identity_verifier = Internal::IdentityVerifier.new(endpoint.identity_keys)
     end
 
     # Rack interface
-    sig { params(env: T::Hash[String, T.untyped]).returns(T.untyped) }
     def call(env)
       path = env['PATH_INFO'] || '/'
       parsed = parse_path(path)
@@ -51,7 +47,6 @@ module Restate
 
     private
 
-    sig { params(path: String).returns(T::Hash[Symbol, T.untyped]) }
     def parse_path(path)
       segments = path.split('/').reject(&:empty?)
 
@@ -77,22 +72,18 @@ module Restate
       end
     end
 
-    sig { returns(T.untyped) }
     def health_response
       [200, { 'content-type' => 'application/json', 'x-restate-server' => X_RESTATE_SERVER }, ['{"status":"ok"}']]
     end
 
-    sig { returns(T.untyped) }
     def not_found_response
       [404, { 'x-restate-server' => X_RESTATE_SERVER }, ['']]
     end
 
-    sig { params(status: Integer, message: String).returns(T.untyped) }
     def error_response(status, message)
       [status, { 'content-type' => 'text/plain', 'x-restate-server' => X_RESTATE_SERVER }, [message]]
     end
 
-    sig { params(env: T::Hash[String, T.untyped]).returns(T.untyped) }
     def handle_discover(env)
       # Detect HTTP version for protocol mode
       http_version = env['HTTP_VERSION'] || env['SERVER_PROTOCOL'] || 'HTTP/1.1'
@@ -119,7 +110,6 @@ module Restate
       end
     end
 
-    sig { params(accept: String).returns(T.nilable(Integer)) }
     def negotiate_version(accept)
       if accept.include?('application/vnd.restate.endpointmanifest.v4+json')
         4
@@ -132,7 +122,6 @@ module Restate
       end
     end
 
-    sig { params(env: T::Hash[String, T.untyped], service_name: T.untyped, handler_name: T.untyped).returns(T.untyped) }
     def handle_invocation(env, service_name, handler_name)
       # Verify identity
       request_headers = extract_headers(env)
@@ -154,7 +143,6 @@ module Restate
       process_invocation(env, handler, request_headers)
     end
 
-    sig { params(env: T::Hash[String, T.untyped], handler: T.untyped, request_headers: T.untyped).returns(T.untyped) }
     def process_invocation(env, handler, request_headers)
       vm = VMWrapper.new(request_headers)
       status, response_headers = vm.get_response_head
@@ -171,7 +159,7 @@ module Restate
       # Read request body chunks and feed to VM until ready to execute,
       # then continue feeding remaining chunks via the input queue.
       rack_input = env['rack.input']
-      ready = T.let(false, T::Boolean)
+      ready = false
       if rack_input
         # Feed chunks until the VM has enough to start execution
         while (chunk = rack_input.read_partial(16_384))
@@ -205,7 +193,8 @@ module Restate
         invocation: invocation,
         send_output: send_output,
         input_queue: input_queue,
-        middleware: @endpoint.middleware
+        middleware: @endpoint.middleware,
+        outbound_middleware: @endpoint.outbound_middleware
       )
 
       # Spawn the handler as an async task so the response body can stream
@@ -246,11 +235,8 @@ module Restate
     # Rack 3 streaming body that yields chunks from an Async::Queue.
     # Terminates when nil is dequeued.
     class StreamingBody
-      extend T::Sig
-
-      sig { params(queue: Async::Queue).void }
       def initialize(queue)
-        @queue = T.let(queue, Async::Queue)
+        @queue = queue
       end
 
       def each
@@ -263,13 +249,12 @@ module Restate
       end
     end
 
-    sig { params(env: T::Hash[String, T.untyped]).returns(T::Array[T::Array[String]]) }
     def extract_headers(env)
-      headers = T.let([], T::Array[T::Array[String]])
+      headers = []
       env.each do |key, value|
         next unless key.start_with?('HTTP_')
 
-        header_name = key.sub('HTTP_', '').tr('_', '-').downcase
+        header_name = key.byteslice(5..).tr('_', '-').downcase!
         headers << [header_name, value]
       end
       # Also include content-type and content-length if present