restate-sdk 0.6.0 → 0.8.0

data/lib/restate/service.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 module Restate
@@ -11,7 +11,6 @@ module Restate
   #     end
   #   end
   class Service
-    extend T::Sig
     extend ServiceDSL
 
     # Register a handler method on this service.
@@ -27,7 +26,29 @@ module Restate
       end
       return method_name unless method_name.is_a?(Symbol)
 
-      _register_handler(method_name, **T.unsafe({ kind: nil, **opts }))
+      _register_handler(method_name, kind: nil, **opts)
+    end
+
+    # Returns a call proxy for fluent durable calls to this service.
+    #
+    # @example
+    #   Greeter.call.greet("World").await
+    #
+    # @return [ServiceCallProxy]
+    def self.call
+      ServiceCallProxy.new(self, call_method: :service_call)
+    end
+
+    # Returns a send proxy for fluent fire-and-forget sends to this service.
+    #
+    # @example
+    #   Greeter.send!.greet("World")
+    #   Greeter.send!(delay: 60).greet("World")
+    #
+    # @param delay [Numeric, nil] optional delay in seconds
+    # @return [ServiceSendProxy]
+    def self.send!(delay: nil)
+      ServiceSendProxy.new(self, send_method: :service_send, delay: delay)
     end
 
     def self._service_kind

data/lib/restate/service_dsl.rb

@@ -31,6 +31,70 @@ module Restate
       subclass.instance_variable_set(:@_idempotency_retention, nil)
       subclass.instance_variable_set(:@_ingress_private, nil)
       subclass.instance_variable_set(:@_invocation_retry_policy, nil)
+      subclass.instance_variable_set(:@_state_declarations, {})
+    end
+
+    # Declare a durable state entry with auto-generated getter, setter, and clear methods.
+    # Only available on VirtualObject and Workflow.
+    #
+    # The generated methods delegate to the current Restate context via +Thread.current+
+    # (fiber-scoped in Ruby 3.0+), so they work correctly across concurrent invocations.
+    #
+    # @param name [Symbol] state key name
+    # @param default [Object, nil] default value returned when state is not set
+    # @param serde [Object] serializer/deserializer (defaults to JsonSerde)
+    #
+    # @example
+    #   class Counter < Restate::VirtualObject
+    #     state :count, default: 0
+    #
+    #     handler def add(ctx, addend)
+    #       self.count += addend  # reads then writes via ctx.get/ctx.set
+    #     end
+    #
+    #     shared def get(ctx)
+    #       count  # reads via ctx.get, returns 0 if unset
+    #     end
+    #   end
+    def state(name, default: nil, serde: nil) # rubocop:disable Metrics/MethodLength,Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/PerceivedComplexity
+      unless respond_to?(:_service_kind) && %w[object workflow].include?(_service_kind)
+        Kernel.raise ArgumentError, 'state declarations are only available on VirtualObject and Workflow'
+      end
+
+      name = name.to_sym
+      @_state_declarations[name] = { default: default, serde: serde }
+      state_key = name.to_s
+      state_serde = serde
+      state_default = default
+
+      # Getter: reads from durable state, returns default if unset
+      define_method(name) do
+        ctx = Thread.current[:restate_context]
+        Kernel.raise 'Not inside a Restate handler' unless ctx
+
+        val = state_serde ? ctx.get(state_key, serde: state_serde) : ctx.get(state_key)
+        val.nil? ? state_default : val
+      end
+
+      # Setter: writes to durable state
+      define_method(:"#{name}=") do |value|
+        ctx = Thread.current[:restate_context]
+        Kernel.raise 'Not inside a Restate handler' unless ctx
+
+        if state_serde
+          ctx.set(state_key, value, serde: state_serde)
+        else
+          ctx.set(state_key, value)
+        end
+      end
+
+      # Clear: removes the state entry
+      define_method(:"clear_#{name}") do
+        ctx = Thread.current[:restate_context]
+        Kernel.raise 'Not inside a Restate handler' unless ctx
+
+        ctx.clear(state_key)
+      end
     end
 
     # Get or set the service name. Defaults to the unqualified class name.
@@ -41,7 +105,7 @@ module Restate
       if name
         @_service_name = name
       else
-        @_service_name || T.unsafe(self).name&.split('::')&.last
+        @_service_name ||= self.name&.split('::')&.last # rubocop:disable Naming/MemoizedInstanceVariableName
       end
     end
 
@@ -135,7 +199,7 @@ module Restate
     #
     # @return [ServiceTag]
     def service_tag
-      ServiceTag.new(kind: T.unsafe(self)._service_kind, name: service_name,
+      ServiceTag.new(kind: _service_kind, name: service_name,
                      description: @_description, metadata: @_metadata)
     end
 
@@ -195,7 +259,7 @@ module Restate
     def _build_handlers # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
       tag = service_tag
       result = {}
-      instance = T.unsafe(self).allocate
+      instance = allocate
 
       @_handler_registry.each do |name, meta| # rubocop:disable Metrics/BlockLength
         input_serde = Serde.resolve(meta[:input])
@@ -208,10 +272,10 @@ module Restate
           output_serde: output_serde
         )
 
-        um = T.unsafe(self).instance_method(name)
+        um = instance_method(name)
         arity = um.arity.abs
-        unless [1, 2].include?(arity)
-          Kernel.raise ArgumentError, "handler '#{name}' must accept 1 or 2 parameters (ctx[, input]), got #{arity}"
+        unless [0, 1].include?(arity)
+          Kernel.raise ArgumentError, "handler '#{name}' must accept 0 or 1 parameters ([input]), got #{arity}"
         end
 
         bound = um.bind(instance)

data/lib/restate/service_proxy.rb

@@ -0,0 +1,73 @@
+# typed: true
+# frozen_string_literal: true
+
+module Restate
+  # Proxy for fluent durable calls: +Service.call.handler(arg)+
+  #
+  # Returned by the +.call+ class method on service classes. Uses +method_missing+
+  # to forward handler invocations to the current Restate context.
+  #
+  # @example
+  #   # Instead of: ctx.service_call(Greeter, :greet, "World")
+  #   Greeter.call.greet("World")
+  #
+  #   # Instead of: ctx.object_call(Counter, :add, "key", 5)
+  #   Counter.call("key").add(5)
+  #
+  # @!visibility private
+  class ServiceCallProxy
+    def initialize(service_class, key: nil, call_method: :service_call)
+      @service_class = service_class
+      @key = key
+      @call_method = call_method
+    end
+
+    def method_missing(handler_name, arg = nil, **opts)
+      ctx = Restate.fetch_context!
+      if @key
+        ctx.public_send(@call_method, @service_class, handler_name, @key, arg, **opts)
+      else
+        ctx.public_send(@call_method, @service_class, handler_name, arg, **opts)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      (@service_class.respond_to?(:handlers) && @service_class.handlers.key?(method_name.to_s)) || super
+    end
+  end
+
+  # Proxy for fluent fire-and-forget sends: +Service.send!.handler(arg)+
+  #
+  # Returned by the +.send!+ class method on service classes.
+  #
+  # @example
+  #   # Instead of: ctx.service_send(Greeter, :greet, "World")
+  #   Greeter.send!.greet("World")
+  #
+  #   # Instead of: ctx.object_send(Counter, :add, "key", 5, delay: 60)
+  #   Counter.send!("key", delay: 60).add(5)
+  #
+  # @!visibility private
+  class ServiceSendProxy
+    def initialize(service_class, key: nil, send_method: :service_send, delay: nil)
+      @service_class = service_class
+      @key = key
+      @send_method = send_method
+      @delay = delay
+    end
+
+    def method_missing(handler_name, arg = nil, **opts)
+      ctx = Restate.fetch_context!
+      opts[:delay] = @delay if @delay
+      if @key
+        ctx.public_send(@send_method, @service_class, handler_name, @key, arg, **opts)
+      else
+        ctx.public_send(@send_method, @service_class, handler_name, arg, **opts)
+      end
+    end
+
+    def respond_to_missing?(method_name, include_private = false)
+      (@service_class.respond_to?(:handlers) && @service_class.handlers.key?(method_name.to_s)) || super
+    end
+  end
+end

data/lib/restate/testing.rb

@@ -1,4 +1,4 @@
-# typed: false
+# typed: ignore
 # frozen_string_literal: true
 
 require 'restate'

data/lib/restate/version.rb

@@ -1,6 +1,6 @@
-# typed: strict
+# typed: true
 # frozen_string_literal: true
 
 module Restate
-  VERSION = '0.6.0'
+  VERSION = '0.8.0'
 end

data/lib/restate/virtual_object.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 module Restate
@@ -17,7 +17,6 @@ module Restate
   #     end
   #   end
   class VirtualObject
-    extend T::Sig
     extend ServiceDSL
 
     # Register an exclusive handler. Use as: +handler def my_method(ctx, arg)+
@@ -33,7 +32,7 @@ module Restate
       end
       return method_name unless method_name.is_a?(Symbol)
 
-      _register_handler(method_name, **T.unsafe({ kind: kind.to_s, **opts }))
+      _register_handler(method_name, kind: kind.to_s, **opts)
     end
 
     # Register a shared (concurrent-access) handler.
@@ -46,7 +45,31 @@ module Restate
               "handler expects a Symbol (use `shared def #{method_name}(...)` or `shared :#{method_name}`)"
       end
 
-      _register_handler(method_name, **T.unsafe({ kind: 'shared', **opts }))
+      _register_handler(method_name, kind: 'shared', **opts)
+    end
+
+    # Returns a call proxy for fluent durable calls to this virtual object.
+    #
+    # @example
+    #   Counter.call("my-key").add(5).await
+    #
+    # @param key [String] the object key
+    # @return [ServiceCallProxy]
+    def self.call(key)
+      ServiceCallProxy.new(self, key: key, call_method: :object_call)
+    end
+
+    # Returns a send proxy for fluent fire-and-forget sends to this virtual object.
+    #
+    # @example
+    #   Counter.send!("my-key").add(5)
+    #   Counter.send!("my-key", delay: 60).add(5)
+    #
+    # @param key [String] the object key
+    # @param delay [Numeric, nil] optional delay in seconds
+    # @return [ServiceSendProxy]
+    def self.send!(key, delay: nil)
+      ServiceSendProxy.new(self, key: key, send_method: :object_send, delay: delay)
     end
 
     def self._service_kind

data/lib/restate/vm.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: ignore
 # frozen_string_literal: true
 
 begin
@@ -19,9 +19,9 @@ module Restate
   class NotReady; end
   class Suspended; end
 
-  NOT_READY = T.let(NotReady.new.freeze, NotReady)
-  SUSPENDED = T.let(Suspended.new.freeze, Suspended)
-  CANCEL_HANDLE = T.let(Internal::CANCEL_NOTIFICATION_HANDLE, Integer)
+  NOT_READY = NotReady.new.freeze
+  SUSPENDED = Suspended.new.freeze
+  CANCEL_HANDLE = Internal::CANCEL_NOTIFICATION_HANDLE
 
   # Progress loop result types
   class DoProgressAnyCompleted; end
@@ -29,10 +29,10 @@ module Restate
   class DoProgressCancelSignalReceived; end
   class DoWaitPendingRun; end
 
-  DO_PROGRESS_ANY_COMPLETED = T.let(DoProgressAnyCompleted.new.freeze, DoProgressAnyCompleted)
-  DO_PROGRESS_READ_FROM_INPUT = T.let(DoProgressReadFromInput.new.freeze, DoProgressReadFromInput)
-  DO_PROGRESS_CANCEL_SIGNAL_RECEIVED = T.let(DoProgressCancelSignalReceived.new.freeze, DoProgressCancelSignalReceived)
-  DO_WAIT_PENDING_RUN = T.let(DoWaitPendingRun.new.freeze, DoWaitPendingRun)
+  DO_PROGRESS_ANY_COMPLETED = DoProgressAnyCompleted.new.freeze
+  DO_PROGRESS_READ_FROM_INPUT = DoProgressReadFromInput.new.freeze
+  DO_PROGRESS_CANCEL_SIGNAL_RECEIVED = DoProgressCancelSignalReceived.new.freeze
+  DO_WAIT_PENDING_RUN = DoWaitPendingRun.new.freeze
 
   DoProgressExecuteRun = Struct.new(:handle, keyword_init: true)
 
@@ -52,50 +52,39 @@ module Restate
 
   # Wraps the native Restate::Internal::VM, mapping native types to Ruby types.
   class VMWrapper
-    extend T::Sig
-
-    sig { params(headers: T.untyped).void }
     def initialize(headers)
-      @vm = T.let(Internal::VM.new(headers), Internal::VM)
+      @vm = Internal::VM.new(headers)
     end
 
-    sig { returns([Integer, T.untyped]) }
     def get_response_head
       result = @vm.get_response_head
       [result.status_code, result.headers]
     end
 
-    sig { params(buf: String).void }
     def notify_input(buf)
       @vm.notify_input(buf)
     end
 
-    sig { void }
     def notify_input_closed
       @vm.notify_input_closed
     end
 
-    sig { params(error: String, stacktrace: T.nilable(String)).void }
     def notify_error(error, stacktrace = nil)
       @vm.notify_error(error, stacktrace)
     end
 
-    sig { returns(T.nilable(String)) }
     def take_output
       @vm.take_output
     end
 
-    sig { returns(T::Boolean) }
     def is_ready_to_execute
       @vm.is_ready_to_execute
     end
 
-    sig { params(handle: Integer).returns(T::Boolean) }
     def is_completed(handle)
       @vm.is_completed(handle)
     end
 
-    sig { params(handles: T::Array[Integer]).returns(T.untyped) }
     def do_progress(handles)
       result = @vm.do_progress(handles)
       map_do_progress(result)
@@ -103,7 +92,6 @@ module Restate
       e
     end
 
-    sig { params(handle: Integer).returns(T.untyped) }
     def take_notification(handle)
       result = @vm.take_notification(handle)
       map_notification(result)
@@ -111,7 +99,6 @@ module Restate
       e
     end
 
-    sig { returns(T.untyped) }
     def sys_input
       inp = @vm.sys_input
       headers = inp.headers.map { |h| [h.key, h.value] }
@@ -124,94 +111,56 @@ module Restate
       )
     end
 
-    sig { params(name: String).returns(Integer) }
     def sys_get_state(name)
       @vm.sys_get_state(name)
     end
 
-    sig { returns(Integer) }
     def sys_get_state_keys
       @vm.sys_get_state_keys
     end
 
-    sig { params(name: String, value: String).void }
     def sys_set_state(name, value)
       @vm.sys_set_state(name, value)
     end
 
-    sig { params(name: String).void }
     def sys_clear_state(name)
       @vm.sys_clear_state(name)
     end
 
-    sig { void }
     def sys_clear_all_state
       @vm.sys_clear_all_state
     end
 
-    sig { params(millis: Integer, name: T.nilable(String)).returns(Integer) }
     def sys_sleep(millis, name = nil)
       # Rust side always expects 2 args: (millis, name_or_nil)
       @vm.sys_sleep(millis, name)
     end
 
-    sig do
-      params(
-        service: String,
-        handler: String,
-        parameter: String,
-        key: T.nilable(String),
-        idempotency_key: T.nilable(String),
-        headers: T.nilable(T::Hash[String, String])
-      ).returns(Internal::CallHandle)
-    end
     def sys_call(service:, handler:, parameter:, key: nil, idempotency_key: nil, headers: nil)
       # Rust side expects 6 args: (service, handler, buffer, key_or_nil, idem_key_or_nil, headers_or_nil)
       hdr_array = headers&.map { |k, v| [k, v] }
       @vm.sys_call(service, handler, parameter, key, idempotency_key, hdr_array)
     end
 
-    sig do
-      params(
-        service: String,
-        handler: String,
-        parameter: String,
-        key: T.nilable(String),
-        delay: T.nilable(Integer),
-        idempotency_key: T.nilable(String),
-        headers: T.nilable(T::Hash[String, String])
-      ).returns(Integer)
-    end
     def sys_send(service:, handler:, parameter:, key: nil, delay: nil, idempotency_key: nil, headers: nil)
       # Rust side expects 7 args
       hdr_array = headers&.map { |k, v| [k, v] }
       @vm.sys_send(service, handler, parameter, key, delay, idempotency_key, hdr_array)
     end
 
-    sig { params(name: String).returns(Integer) }
     def sys_run(name)
       @vm.sys_run(name)
     end
 
-    sig { params(handle: Integer, output: String).void }
     def propose_run_completion_success(handle, output)
       @vm.propose_run_completion_success(handle, output)
     end
 
-    sig { params(handle: Integer, failure: T.untyped).void }
     def propose_run_completion_failure(handle, failure)
       native_failure = Internal::Failure.new(failure.code, failure.message, nil)
       @vm.propose_run_completion_failure(handle, native_failure)
     end
 
-    sig do
-      params(
-        handle: Integer,
-        failure: T.untyped,
-        attempt_duration_ms: Integer,
-        config: T.untyped
-      ).void
-    end
     def propose_run_completion_transient(handle, failure:, attempt_duration_ms:, config:)
       native_failure = Internal::Failure.new(failure.code, failure.message, failure.stacktrace)
       native_config = Internal::ExponentialRetryConfig.new(
@@ -222,73 +171,60 @@ module Restate
       @vm.propose_run_completion_failure_transient(handle, native_failure, attempt_duration_ms, native_config)
     end
 
-    sig { params(output: String).void }
     def sys_write_output_success(output)
       @vm.sys_write_output_success(output)
     end
 
-    sig { params(failure: T.untyped).void }
     def sys_write_output_failure(failure)
       native_failure = Internal::Failure.new(failure.code, failure.message, nil)
       @vm.sys_write_output_failure(native_failure)
     end
 
-    sig { void }
     def sys_end
       @vm.sys_end
     end
 
-    sig { returns(T::Boolean) }
     def is_replaying
       @vm.is_replaying
     end
 
     # Returns [awakeable_id (String), notification_handle (Integer)]
-    sig { returns([String, Integer]) }
     def sys_awakeable
       @vm.sys_awakeable
     end
 
-    sig { params(awakeable_id: String, value: String).void }
     def sys_complete_awakeable_success(awakeable_id, value)
       @vm.sys_complete_awakeable_success(awakeable_id, value)
     end
 
-    sig { params(awakeable_id: String, failure: T.untyped).void }
     def sys_complete_awakeable_failure(awakeable_id, failure)
       native_failure = Internal::Failure.new(failure.code, failure.message, nil)
       @vm.sys_complete_awakeable_failure(awakeable_id, native_failure)
     end
 
-    sig { params(key: String).returns(Integer) }
     def sys_get_promise(key)
       @vm.sys_get_promise(key)
     end
 
-    sig { params(key: String).returns(Integer) }
     def sys_peek_promise(key)
       @vm.sys_peek_promise(key)
     end
 
-    sig { params(key: String, value: String).returns(Integer) }
     def sys_complete_promise_success(key, value)
       @vm.sys_complete_promise_success(key, value)
     end
 
-    sig { params(key: String, failure: T.untyped).returns(Integer) }
     def sys_complete_promise_failure(key, failure)
       native_failure = Internal::Failure.new(failure.code, failure.message, nil)
       @vm.sys_complete_promise_failure(key, native_failure)
     end
 
-    sig { params(invocation_id: String).void }
     def sys_cancel_invocation(invocation_id)
       @vm.sys_cancel_invocation(invocation_id)
     end
 
     private
 
-    sig { params(result: T.untyped).returns(T.untyped) }
     def map_do_progress(result)
       case result
       when Internal::Suspended
@@ -308,7 +244,6 @@ module Restate
       end
     end
 
-    sig { params(result: T.untyped).returns(T.untyped) }
     def map_notification(result)
       case result
       when Internal::Suspended

data/lib/restate/workflow.rb

@@ -1,4 +1,4 @@
-# typed: true
+# typed: false
 # frozen_string_literal: true
 
 module Restate
@@ -15,7 +15,6 @@ module Restate
   #     end
   #   end
   class Workflow
-    extend T::Sig
     extend ServiceDSL
 
     # Register the main workflow entry point.
@@ -31,7 +30,7 @@ module Restate
       end
       return method_name unless method_name.is_a?(Symbol)
 
-      _register_handler(method_name, **T.unsafe({ kind: 'workflow', **opts }))
+      _register_handler(method_name, kind: 'workflow', **opts)
     end
 
     # Register a shared handler on this workflow.
@@ -46,7 +45,31 @@ module Restate
       end
       return method_name unless method_name.is_a?(Symbol)
 
-      _register_handler(method_name, **T.unsafe({ kind: 'shared', **opts }))
+      _register_handler(method_name, kind: 'shared', **opts)
+    end
+
+    # Returns a call proxy for fluent durable calls to this workflow.
+    #
+    # @example
+    #   UserSignup.call("user42").run("user@example.com").await
+    #
+    # @param key [String] the workflow key
+    # @return [ServiceCallProxy]
+    def self.call(key)
+      ServiceCallProxy.new(self, key: key, call_method: :workflow_call)
+    end
+
+    # Returns a send proxy for fluent fire-and-forget sends to this workflow.
+    #
+    # @example
+    #   UserSignup.send!("user42").run("user@example.com")
+    #   UserSignup.send!("user42", delay: 60).run("user@example.com")
+    #
+    # @param key [String] the workflow key
+    # @param delay [Numeric, nil] optional delay in seconds
+    # @return [ServiceSendProxy]
+    def self.send!(key, delay: nil)
+      ServiceSendProxy.new(self, key: key, send_method: :workflow_send, delay: delay)
     end
 
     def self._service_kind