restate-sdk 0.4.4-aarch64-linux → 0.5.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0fec8d8aa1a7498a2013a683141ae930d31ceabcc86b48b984a97df391bfb72c
-  data.tar.gz: 92b310e7c9c6cf086cdec9818a08553419c3ff3e63c4d1558aeb22d719b35291
+  metadata.gz: 6c4926d9f1b3d398f990db7c8c1b69992d15dca6c4351b26ca2acdb544241dbb
+  data.tar.gz: fa7141828b226288c421d9fd3e7e312542996ba54f84fa3b8037b7f392143315
 SHA512:
-  metadata.gz: f37bd02afa15824edd0f39315705427667ec411bf0a7af605160e97b23310453e306f9f3aa0094e3c24d47f5a9887418c418eb2e6b91e900c07707c4925d85c0
-  data.tar.gz: a422e826da3217c4ce560d52c74aa1af7cf32bb86ce79c0ff07ddd63694530a26a5a3ddd1f5ca6e5346bf03c86014327d9078f4e8f7cb0b9f9d9bb75c8aefeec
+  metadata.gz: 97997980254554521ee6b9a24244de9a8115664bef4585b1d856ac859b8c590ae20ed938208d06f245d1d019951ec7be51f73217c359e7ceaae43da24875f21b
+  data.tar.gz: 135673211c2a556bba886aefc3ce4b3d8b20312330a985d908a08d50b4e2d1c744514b3fec5918ecfe1fc89bb916adcc353649d28371365725913cf3872fce01

data/Cargo.lock

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

data/README.md

@@ -5,14 +5,15 @@
 
 # Restate Ruby SDK
 
+> **Note:** This SDK is currently under active development. APIs may change between releases.
+
 [Restate](https://restate.dev/) is a system for easily building resilient applications using *distributed durable async/await*. This repository contains the Restate SDK for writing services in **Ruby**.
 
 ```ruby
 require 'restate'
 
 class Greeter < Restate::Service
-  handler def greet(name)
-    ctx = Restate.current_context
+  handler def greet(ctx, name)
     ctx.run_sync('build-greeting') { "Hello, #{name}!" }
   end
 end
@@ -66,9 +67,7 @@ end
 
 class EventService < Restate::Service
   handler :register, input: RegistrationRequest, output: RegistrationResponse
-  def register(request)
-    ctx = Restate.current_context
-
+  def register(ctx, request)
     registration_id = ctx.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.4.4"
+version = "0.5.0"
 edition = "2021"
 publish = false
 

data/lib/restate/handler.rb

@@ -31,20 +31,20 @@ module Restate
 
   module_function
 
-  # Invoke a handler with raw input bytes. The context is available via
-  # fiber-local Restate.current_context (set by ServerContext#enter).
+  # Invoke a handler with the context and raw input bytes.
+  # The context is passed as the first argument to every handler.
   # Returns raw output bytes.
-  sig { params(handler: T.untyped, in_buffer: String).returns(String) }
-  def invoke_handler(handler:, in_buffer:)
-    if handler.arity == 1
+  sig { params(handler: T.untyped, ctx: T.untyped, in_buffer: String).returns(String) }
+  def invoke_handler(handler:, ctx:, in_buffer:)
+    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
-      out_arg = handler.callable.call(in_arg)
+      out_arg = handler.callable.call(ctx, in_arg)
     else
-      out_arg = handler.callable.call
+      out_arg = handler.callable.call(ctx)
     end
     handler.handler_io.output_serde.serialize(out_arg)
   end

data/lib/restate/serde.rb

@@ -212,10 +212,13 @@ module Restate
   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 = type
+      @type_class = type
       @schema = schema
     end
 
@@ -243,6 +246,9 @@ module Restate
   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)
@@ -280,6 +286,9 @@ module Restate
   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)

data/lib/restate/server_context.rb

@@ -48,7 +48,7 @@ module Restate
       Thread.current[:restate_service_kind] = @handler.service_tag.kind
       Thread.current[:restate_handler_kind] = @handler.kind
       in_buffer = @invocation.input_buffer
-      out_buffer = Restate.invoke_handler(handler: @handler, in_buffer: in_buffer)
+      out_buffer = Restate.invoke_handler(handler: @handler, ctx: self, in_buffer: in_buffer)
       @vm.sys_write_output_success(out_buffer.b)
       @vm.sys_end
     rescue TerminalError => e

data/lib/restate/service.rb

@@ -6,8 +6,8 @@ module Restate
   #
   # @example
   #   class Greeter < Restate::Service
-  #     handler def greet(name)
-  #       "Hello, #{name}!"
+  #     handler def greet(ctx, name)
+  #       ctx.run_sync('build-greeting') { "Hello, #{name}!" }
   #     end
   #   end
   class Service
@@ -15,7 +15,7 @@ module Restate
     extend ServiceDSL
 
     # Register a handler method on this service.
-    # Use as: +handler def my_method(arg)+ or +handler :my_method, input: String+
+    # Use as: +handler def my_method(ctx, arg)+ or +handler :my_method, input: String+
     #
     # @param method_name [Symbol] name of the method to register
     # @param opts [Hash] handler options (+input:+, +output:+, +accept:+, +content_type:+)

data/lib/restate/service_dsl.rb

@@ -9,8 +9,7 @@ module Restate
   #
   # @example
   #   class Counter < Restate::VirtualObject
-  #     handler def add(addend)
-  #       ctx = Restate.current_object_context
+  #     handler def add(ctx, addend)
   #       old = ctx.get('counter') || 0
   #       ctx.set('counter', old + addend)
   #       old + addend
@@ -211,8 +210,8 @@ module Restate
 
         um = T.unsafe(self).instance_method(name)
         arity = um.arity.abs
-        unless [0, 1].include?(arity)
-          Kernel.raise ArgumentError, "handler '#{name}' must accept 0 or 1 parameters ([input]), got #{arity}"
+        unless [1, 2].include?(arity)
+          Kernel.raise ArgumentError, "handler '#{name}' must accept 1 or 2 parameters (ctx[, input]), got #{arity}"
         end
 
         bound = um.bind(instance)

data/lib/restate/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module Restate
-  VERSION = '0.4.4'
+  VERSION = '0.5.0'
 end

data/lib/restate/virtual_object.rb

@@ -6,15 +6,13 @@ module Restate
   #
   # @example
   #   class Counter < Restate::VirtualObject
-  #     handler def add(addend)
-  #       ctx = Restate.current_object_context
+  #     handler def add(ctx, addend)
   #       old = ctx.get("count") || 0
   #       ctx.set("count", old + addend)
   #       old + addend
   #     end
   #
-  #     shared def get
-  #       ctx = Restate.current_object_context
+  #     shared def get(ctx)
   #       ctx.get("count") || 0
   #     end
   #   end
@@ -22,7 +20,7 @@ module Restate
     extend T::Sig
     extend ServiceDSL
 
-    # Register an exclusive handler. Use as: +handler def my_method(arg)+
+    # Register an exclusive handler. Use as: +handler def my_method(ctx, arg)+
     #
     # @param method_name [Symbol] name of the method to register
     # @param kind [Symbol] concurrency mode (+:exclusive+ or +:shared+)

data/lib/restate/workflow.rb

@@ -6,12 +6,11 @@ module Restate
   #
   # @example
   #   class Signup < Restate::Workflow
-  #     main def run(email)
+  #     main def run(ctx, email)
   #       # workflow logic
   #     end
   #
-  #     handler def status
-  #       ctx = Restate.current_workflow_context
+  #     handler def status(ctx)
   #       ctx.get("status")
   #     end
   #   end
@@ -20,7 +19,7 @@ module Restate
     extend ServiceDSL
 
     # Register the main workflow entry point.
-    # Use as: +main def run(arg)+ or +main :run, input: String+
+    # Use as: +main def run(ctx, arg)+ or +main :run, input: String+
     #
     # @param method_name [Symbol] name of the method to register
     # @param opts [Hash] handler options (+input:+, +output:+, +accept:+, +content_type:+)

data/lib/restate.rb

@@ -46,12 +46,12 @@ module Restate
 
   # ── Fiber-local context accessors ──
   #
-  # The SDK stores the current handler context in fiber-local storage
-  # (Thread.current[], which is fiber-scoped in Ruby). These methods
-  # retrieve it with the appropriate type for IDE completion.
+  # The SDK passes the context as the first argument to every handler.
+  # It is also stored in fiber-local storage (Thread.current[], which is
+  # fiber-scoped in Ruby). These methods retrieve it with the appropriate
+  # type for IDE completion.
   #
-  # Use these instead of the +ctx+ parameter when you need the context
-  # from a nested method that doesn't have +ctx+ in scope.
+  # Use these from nested helper methods that don't have +ctx+ in scope.
 
   # Returns the current context for a Service handler.
   # Raises if called outside a Restate handler.

data/lib/tapioca/dsl/compilers/restate.rb

@@ -3,14 +3,15 @@
 
 return unless defined?(Tapioca::Dsl::Compiler)
 
+require 'restate'
+
 module Tapioca
   module Dsl
     module Compilers
       # Generates Sorbet sigs for Restate handler methods.
       #
-      # Handlers no longer receive +ctx+ as a parameter — context is accessed
-      # via fiber-local +Restate.current_context+ (or typed variants). This
-      # compiler generates sigs reflecting the actual handler arity (0 or 1).
+      # Every handler receives +ctx+ as its first parameter. Handlers that
+      # accept input receive it as the second parameter (arity 2).
       #
       # Usage:
       #   bundle exec tapioca dsl
@@ -19,6 +20,10 @@ module Tapioca
 
         class << self
           def gather_constants
+            # Load service files so they're visible to all_classes.
+            # In non-Rails apps, Tapioca doesn't auto-load application code.
+            load_service_files
+
             all_classes.select do |klass|
               klass.is_a?(Class) && (
                 klass < ::Restate::Service ||
@@ -29,16 +34,82 @@ module Tapioca
               false
             end
           end
+
+          private
+
+          def load_service_files # rubocop:disable Metrics/MethodLength
+            root = Bundler.root.to_s
+            patterns = [
+              "#{root}/*.rb",
+              "#{root}/app/**/*.rb",
+              "#{root}/services/**/*.rb",
+              "#{root}/examples/**/*.rb"
+            ]
+            Dir.glob(patterns).each do |file|
+              next if file.end_with?('config.ru', 'Rakefile')
+
+              require file
+            rescue LoadError, StandardError
+              nil # skip files that can't be loaded
+            end
+          end
         end
 
-        def decorate
+        def decorate # rubocop:disable Metrics/MethodLength
           root.create_path(constant) do |klass|
             constant.handlers.each do |name, handler|
-              params = handler.arity == 1 ? [create_param('input', type: 'T.untyped')] : []
-              klass.create_method(name, parameters: params, return_type: 'T.untyped')
+              ctx_type = resolve_context_type(constant, handler)
+              params = [create_param('ctx', type: ctx_type)]
+              if handler.arity == 2
+                input_type = resolve_input_type(handler)
+                params << create_param('input', type: input_type)
+              end
+              output_type = resolve_output_type(handler)
+              klass.create_method(name, parameters: params, return_type: output_type)
             end
           end
         end
+
+        private
+
+        # Maps (service kind, handler kind) to the correct context module.
+        def resolve_context_type(klass, handler)
+          if klass < ::Restate::Workflow
+            handler.kind == 'workflow' ? 'Restate::WorkflowContext' : 'Restate::WorkflowSharedContext'
+          elsif klass < ::Restate::VirtualObject
+            handler.kind == 'shared' ? 'Restate::ObjectSharedContext' : 'Restate::ObjectContext'
+          else
+            'Restate::Context'
+          end
+        end
+
+        # Resolves the Sorbet type string for the handler's input serde.
+        def resolve_input_type(handler)
+          type_class = handler.handler_io&.input_serde
+          sorbet_type_name(type_class) || 'T.untyped'
+        end
+
+        # Resolves the Sorbet type string for the handler's output serde.
+        def resolve_output_type(handler)
+          type_class = handler.handler_io&.output_serde
+          sorbet_type_name(type_class) || 'T.untyped'
+        end
+
+        # Returns a Sorbet type string if the serde wraps a known type, nil otherwise.
+        def sorbet_type_name(serde)
+          return nil if serde.nil?
+
+          # TStructSerde exposes .struct_class (T::Struct subclasses are visible to Sorbet)
+          return serde.struct_class.name if serde.is_a?(::Restate::TStructSerde)
+
+          # TypeSerde wraps a primitive type in .type_class
+          if serde.respond_to?(:type_class)
+            name = serde.type_class.name
+            return name if %w[String Integer Float].include?(name)
+          end
+
+          nil
+        end
       end
     end
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.4.4
+  version: 0.5.0
 platform: aarch64-linux
 authors:
 - Restate Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-17 00:00:00.000000000 Z
+date: 2026-03-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async