restate-sdk 0.8.0-aarch64-linux → 0.10.0-aarch64-linux

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3d6b44b67a72794c5def96163fbc7a1a134180ddca5477083468a2d88720b756
-  data.tar.gz: 36032a61a77ba21adde9b2cf2aede6456812fc4a40ec98bb082cc5e2a5676ae3
+  metadata.gz: 80a62b147724910e3329f4263e61a290ccc55e6f0c097ecc0fad4ece63ef2407
+  data.tar.gz: 33661eccbb66c39e1ca6c57ea735e4ef74fa79a712e05136c7d0624720484ba9
 SHA512:
-  metadata.gz: ec7cef72a64b0158f9a6bec982d6ec68718133ad527b5fbc0e9d30969bad539cbb5e4427eb98877d42c6a947fd5bcae080ed235097a31c0cf119e648f12fc03c
-  data.tar.gz: d7c3432a6a02c9442d56b164d1de390899683bc20b2775392cff1515fbc234bb84d36515c67a23926c4945386e9cf481dbaead5ed7a8a6f73f91959a4496dd7b
+  metadata.gz: e0b1fec80f09851613ccb2c4c04ec677566f845b47e51ae5a248d001e4fa9400ed096b574f475551ac3c29e9ca63775a27be799e9876dc2c49a5c4a45e06a466
+  data.tar.gz: 4bbacd32b9999dfdec05918bf7eddb191a2e472b20c977dbab6b898c2bf8b2a6e8600649b2a6bc86fd8072368deab819e96e7b64c642dd2d17434be6084845d2

data/Cargo.lock

@@ -31,16 +31,14 @@ checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bindgen"
-version = "0.69.5"
+version = "0.72.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "271383c67ccabffb7381723dea0672a673f292304fcb45c01cc648c7a8d58088"
+checksum = "993776b509cfb49c750f11b8f07a46fa23e0a1386ffc01fb1e7d343efc387895"
 dependencies = [
  "bitflags",
  "cexpr",
  "clang-sys",
  "itertools 0.12.1",
- "lazy_static",
- "lazycell",
  "proc-macro2",
  "quote",
  "regex",
@@ -278,12 +276,6 @@ version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
 
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "libc"
 version = "0.2.183"
@@ -489,18 +481,18 @@ dependencies = [
 
 [[package]]
 name = "rb-sys"
-version = "0.9.124"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c85c4188462601e2aa1469def389c17228566f82ea72f137ed096f21591bc489"
+checksum = "45ca28513560e56cfb79a62b1fce363c73af170a182024ce880c77ee9429920a"
 dependencies = [
  "rb-sys-build",
 ]
 
 [[package]]
 name = "rb-sys-build"
-version = "0.9.124"
+version = "0.9.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "568068db4102230882e6d4ae8de6632e224ca75fe5970f6e026a04e91ed635d3"
+checksum = "ce04b2c55eff3a21aaa623fcc655d94373238e72cac6b3e1a3641ff31649f99a"
 dependencies = [
  "bindgen",
  "lazy_static",
@@ -569,7 +561,7 @@ dependencies = [
 
 [[package]]
 name = "restate_internal"
-version = "0.8.0"
+version = "0.10.0"
 dependencies = [
  "magnus",
  "rb-sys",
@@ -593,9 +585,9 @@ dependencies = [
 
 [[package]]
 name = "rustc-hash"
-version = "1.1.0"
+version = "2.1.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08d43f7aa6b08d49f382cde6a7982047c3426db949b1424bc4b7ec9ae12c6ce2"
+checksum = "94300abf3f1ae2e2b8ffb7b58043de3d399c73fa6f4b73826402a5c457614dbe"
 
 [[package]]
 name = "rustversion"

data/ext/restate_internal/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "restate_internal"
-version = "0.8.0"
+version = "0.10.0"
 edition = "2021"
 publish = false
 

data/lib/restate/client.rb

@@ -81,6 +81,33 @@ module Restate
       post_admin("/restate/invocations/#{invocation_id}/kill", nil)
     end
 
+    # ── Introspection queries ──
+
+    # Execute a SQL query against Restate's introspection API (DataFusion).
+    # The admin API exposes system tables (sys_invocation, sys_journal, state,
+    # etc.) that can be queried with standard SQL.
+    #
+    # @param sql [String] a SQL query string
+    # @return [Array<Hash>] rows returned by the query
+    #
+    # @example
+    #   client.execute_query("SELECT id, status FROM sys_invocation LIMIT 10")
+    def execute_query(sql) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+      uri = URI("#{@admin_url}/query")
+      request = Net::HTTP::Post.new(uri)
+      request['Content-Type'] = 'application/json'
+      request['Accept'] = 'application/json'
+      @admin_headers.each { |k, v| request[k] = v }
+      request.body = JSON.generate({ query: sql })
+      response = Net::HTTP.start(uri.hostname, uri.port, # steep:ignore ArgumentTypeMismatch
+                                 use_ssl: uri.scheme == 'https',
+                                 open_timeout: 5,
+                                 read_timeout: 30) { |http| http.request(request) }
+      Kernel.raise "Restate query error: #{response.code} #{response.body}" unless response.is_a?(Net::HTTPSuccess)
+      body = response.body
+      body && !body.empty? ? (JSON.parse(body)['rows'] || []) : []
+    end
+
     private
 
     def resolve_name(service)

data/lib/restate/endpoint.rb

@@ -4,7 +4,7 @@
 module Restate
   # Container for registered services. Bind services here, then create the Rack app.
   class Endpoint
-    attr_reader :services, :identity_keys, :middleware
+    attr_reader :services, :identity_keys, :middleware, :outbound_middleware
 
     attr_accessor :protocol
 
@@ -13,6 +13,7 @@ module Restate
       @protocol = nil
       @identity_keys = []
       @middleware = []
+      @outbound_middleware = []
     end
 
     # Bind one or more services to this endpoint.
@@ -48,29 +49,25 @@ module Restate
       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
@@ -84,30 +81,53 @@ 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]
-    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
 
@@ -116,5 +136,15 @@ module Restate
       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/introspection.rb

@@ -0,0 +1,127 @@
+# typed: false
+# frozen_string_literal: true
+
+require 'active_record'
+
+module Restate
+  # Arel table references for Restate's SQL introspection tables.
+  #
+  # Restate exposes a DataFusion-powered SQL endpoint at +/query+ on the admin
+  # API. These tables let you build queries using Arel's composable, type-safe
+  # predicate API — the same one ActiveRecord uses under the hood.
+  #
+  # @example Query running invocations for a service
+  #   i = Restate::Sys::Invocation
+  #   query = i.project(i[:id], i[:status], i[:created_at])
+  #            .where(i[:target_service_name].eq("MyService"))
+  #            .where(i[:status].eq("running"))
+  #            .order(i[:created_at].desc)
+  #            .take(50)
+  #   Restate.query(query)
+  #
+  # @example Join invocations with their journal input
+  #   i = Restate::Sys::Invocation
+  #   j = Restate::Sys::Journal
+  #   query = i.project(i[:id], i[:target], i[:status], j[:entry_json])
+  #            .join(j, Arel::Nodes::OuterJoin)
+  #            .on(j[:id].eq(i[:id]).and(j[:index].eq(0)))
+  #            .where(i[:target_service_name].eq("CrawlPipeline"))
+  #            .order(i[:created_at].desc)
+  #            .take(20)
+  #   Restate.query(query)
+  #
+  # @example Query virtual object state
+  #   s = Restate::Sys::State
+  #   query = s.project(s[:service_name], s[:service_key], s[:key], s[:value_utf8])
+  #            .where(s[:service_name].eq("Counter"))
+  #   Restate.query(query)
+  module Sys
+    Invocation       = Arel::Table.new(:sys_invocation)
+    Journal          = Arel::Table.new(:sys_journal)
+    JournalEvents    = Arel::Table.new(:sys_journal_events)
+    Inbox            = Arel::Table.new(:sys_inbox)
+    KeyedStatus      = Arel::Table.new(:sys_keyed_service_status)
+    Service          = Arel::Table.new(:sys_service)
+    Deployment       = Arel::Table.new(:sys_deployment)
+    Idempotency      = Arel::Table.new(:sys_idempotency)
+    Promise          = Arel::Table.new(:sys_promise)
+    State            = Arel::Table.new(:state)
+  end
+
+  # Minimal quoting adapter for Arel's ToSql visitor. Emits ANSI SQL
+  # (double-quoted identifiers, single-quoted strings) which DataFusion expects.
+  # Allows Arel query generation without an ActiveRecord database connection.
+  #
+  # @!visibility private
+  class DataFusionQuoting
+    def quote_table_name(name)
+      "\"#{name}\""
+    end
+
+    def quote_column_name(name)
+      "\"#{name}\""
+    end
+
+    def quote(value)
+      case value
+      when String then "'#{value.gsub("'", "''")}'"
+      when nil then 'NULL'
+      when true then 'TRUE'
+      when false then 'FALSE'
+      else value.to_s
+      end
+    end
+
+    def schema_cache
+      self
+    end
+
+    def columns_hash(_table)
+      {}
+    end
+
+    def data_source_exists?(_table)
+      true
+    end
+  end
+
+  # Arel visitor that generates ANSI SQL compatible with DataFusion.
+  # Uses DataFusionQuoting for identifier/value quoting without requiring
+  # a live database connection.
+  #
+  # @!visibility private
+  class DataFusionVisitor < Arel::Visitors::ToSql
+    def initialize
+      super(DataFusionQuoting.new)
+    end
+  end
+
+  class << self
+    # Convert an Arel AST to a SQL string without requiring an AR connection.
+    # Uses a standalone visitor that emits ANSI SQL (DataFusion-compatible).
+    #
+    # @param arel [Arel::SelectManager] an Arel query
+    # @return [String] SQL string
+    def arel_to_sql(arel)
+      collector = Arel::Collectors::SQLString.new
+      DataFusionVisitor.new.accept(arel.ast, collector).value
+    end
+
+    # Execute an Arel query or raw SQL string against the Restate admin
+    # introspection API. Returns an array of row hashes.
+    #
+    # @param arel_or_sql [Arel::SelectManager, String] an Arel query or raw SQL
+    # @return [Array<Hash>] rows returned by Restate
+    #
+    # @example With Arel
+    #   i = Restate::Sys::Invocation
+    #   Restate.query(i.project(Arel.star).take(10))
+    #
+    # @example With raw SQL
+    #   Restate.query("SELECT id, status FROM sys_invocation LIMIT 10")
+    def query(arel_or_sql)
+      sql = arel_or_sql.respond_to?(:ast) ? arel_to_sql(arel_or_sql) : arel_or_sql.to_s
+      client.execute_query(sql)
+    end
+  end
+end

data/lib/restate/railtie.rb

@@ -0,0 +1,17 @@
+# typed: false
+# frozen_string_literal: true
+
+module Restate
+  # Rails integration for the Restate SDK. Automatically loads the
+  # introspection module which provides Arel-based query support for
+  # Restate's SQL introspection API (powered by DataFusion).
+  #
+  # When Rails is present, +Restate::Sys+ table constants become available
+  # for building type-safe, composable queries against system tables like
+  # +sys_invocation+, +sys_journal+, and +state+.
+  class Railtie < Rails::Railtie
+    initializer 'restate.introspection' do
+      require_relative 'introspection'
+    end
+  end
+end

data/lib/restate/server.rb

@@ -193,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

data/lib/restate/server_context.rb

@@ -23,7 +23,8 @@ module Restate
 
     attr_reader :vm, :invocation
 
-    def initialize(vm:, handler:, invocation:, send_output:, input_queue:, middleware: [])
+    def initialize(vm:, handler:, invocation:, send_output:, input_queue:, middleware: [],
+                   outbound_middleware: [])
       @vm = vm
       @handler = handler
       @invocation = invocation
@@ -32,6 +33,7 @@ module Restate
       @run_coros_to_execute = {}
       @attempt_finished_event = AttemptFinishedEvent.new
       @middleware = middleware
+      @outbound_middleware = outbound_middleware
     end
 
     # ── Main entry point ──
@@ -204,12 +206,14 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       out_serde = resolve_serde(output_serde, handler_meta, :output_serde)
       parameter = in_serde.serialize(arg)
-      call_handle = @vm.sys_call(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, idempotency_key: idempotency_key, headers: headers
-      )
-      DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
-                            output_serde: out_serde)
+      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+        call_handle = @vm.sys_call(
+          service: svc_name, handler: handler_name, parameter: parameter,
+          key: key, idempotency_key: idempotency_key, headers: hdrs
+        )
+        DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
+                              output_serde: out_serde)
+      end
     end
 
     # Sends a one-way invocation to a Restate service handler (fire-and-forget).
@@ -219,11 +223,13 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       parameter = in_serde.serialize(arg)
       delay_ms = delay ? (delay * 1000).to_i : nil
-      invocation_id_handle = @vm.sys_send(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: headers
-      )
-      SendHandle.new(self, invocation_id_handle)
+      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+        invocation_id_handle = @vm.sys_send(
+          service: svc_name, handler: handler_name, parameter: parameter,
+          key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: hdrs
+        )
+        SendHandle.new(self, invocation_id_handle)
+      end
     end
 
     # Durably calls a handler on a Restate virtual object, keyed by +key+.
@@ -233,12 +239,14 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       out_serde = resolve_serde(output_serde, handler_meta, :output_serde)
       parameter = in_serde.serialize(arg)
-      call_handle = @vm.sys_call(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, idempotency_key: idempotency_key, headers: headers
-      )
-      DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
-                            output_serde: out_serde)
+      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+        call_handle = @vm.sys_call(
+          service: svc_name, handler: handler_name, parameter: parameter,
+          key: key, idempotency_key: idempotency_key, headers: hdrs
+        )
+        DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
+                              output_serde: out_serde)
+      end
     end
 
     # Sends a one-way invocation to a Restate virtual object handler (fire-and-forget).
@@ -248,11 +256,13 @@ module Restate
       in_serde = resolve_serde(input_serde, handler_meta, :input_serde)
       parameter = in_serde.serialize(arg)
       delay_ms = delay ? (delay * 1000).to_i : nil
-      invocation_id_handle = @vm.sys_send(
-        service: svc_name, handler: handler_name, parameter: parameter,
-        key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: headers
-      )
-      SendHandle.new(self, invocation_id_handle)
+      with_outbound_middleware(svc_name, handler_name, headers) do |hdrs|
+        invocation_id_handle = @vm.sys_send(
+          service: svc_name, handler: handler_name, parameter: parameter,
+          key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: hdrs
+        )
+        SendHandle.new(self, invocation_id_handle)
+      end
     end
 
     # Durably calls a handler on a Restate workflow, keyed by +key+.
@@ -332,22 +342,26 @@ module Restate
 
     # Durably calls a handler using raw bytes (no serialization). Useful for proxying.
     def generic_call(service, handler, arg, key: nil, idempotency_key: nil, headers: nil)
-      call_handle = @vm.sys_call(
-        service: service, handler: handler, parameter: arg,
-        key: key, idempotency_key: idempotency_key, headers: headers
-      )
-      DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
-                            output_serde: nil)
+      with_outbound_middleware(service, handler, headers) do |hdrs|
+        call_handle = @vm.sys_call(
+          service: service, handler: handler, parameter: arg,
+          key: key, idempotency_key: idempotency_key, headers: hdrs
+        )
+        DurableCallFuture.new(self, call_handle.result_handle, call_handle.invocation_id_handle,
+                              output_serde: nil)
+      end
     end
 
     # Sends a one-way invocation using raw bytes (no serialization). Useful for proxying.
     def generic_send(service, handler, arg, key: nil, delay: nil, idempotency_key: nil, headers: nil)
       delay_ms = delay ? (delay * 1000).to_i : nil
-      invocation_id_handle = @vm.sys_send(
-        service: service, handler: handler, parameter: arg,
-        key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: headers
-      )
-      SendHandle.new(self, invocation_id_handle)
+      with_outbound_middleware(service, handler, headers) do |hdrs|
+        invocation_id_handle = @vm.sys_send(
+          service: service, handler: handler, parameter: arg,
+          key: key, delay: delay_ms, idempotency_key: idempotency_key, headers: hdrs
+        )
+        SendHandle.new(self, invocation_id_handle)
+      end
     end
 
     # ── Request metadata ──
@@ -453,6 +467,25 @@ module Restate
       end
     end
 
+    # ── Outbound middleware ──
+
+    # Runs outbound middleware chain (Sidekiq client middleware pattern).
+    # Each middleware gets +call(service, handler, headers)+ and must +yield+
+    # to continue the chain. The block at the end performs the actual VM call.
+    def with_outbound_middleware(service, handler, headers, &action)
+      if @outbound_middleware.empty?
+        action.call(headers)
+      else
+        h = headers || {}
+        chain = ->(hdrs) { action.call(hdrs) }
+        @outbound_middleware.reverse_each do |mw|
+          prev = chain
+          chain = ->(hdrs) { mw.call(service, handler, hdrs) { prev.call(hdrs) } }
+        end
+        chain.call(h)
+      end
+    end
+
     # ── Call target resolution ──
 
     # Resolves a service+handler pair from class/symbol or string/string.

data/lib/restate/version.rb

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

data/lib/restate.rb

@@ -18,6 +18,7 @@ require_relative 'restate/endpoint'
 require_relative 'restate/service_proxy'
 require_relative 'restate/config'
 require_relative 'restate/client'
+require_relative 'restate/railtie' if defined?(Rails::Railtie)
 
 # Restate Ruby SDK — build resilient applications with durable execution.
 #

data/sig/restate.rbs

@@ -8,6 +8,8 @@ module Restate
   def self.configure: () { (Config) -> void } -> void
   def self.config: () -> Config
   def self.client: () -> Client
+  def self.query: (untyped arel_or_sql) -> Array[Hash[String, untyped]]
+  def self.arel_to_sql: (untyped arel) -> String
 
   # ── Durable execution ──
 
@@ -118,6 +120,7 @@ module Restate
     def reject_awakeable: (String awakeable_id, String message, ?code: Integer) -> void
     def cancel_invocation: (String invocation_id) -> void
     def kill_invocation: (String invocation_id) -> void
+    def execute_query: (String sql) -> Array[Hash[String, untyped]]
 
     private
 
@@ -138,13 +141,19 @@ module Restate
     attr_reader identity_keys: Array[String]
     attr_accessor protocol: String?
     attr_reader middleware: Array[untyped]
+    attr_reader outbound_middleware: Array[untyped]
     def initialize: () -> void
     def bind: (*untyped svcs) -> self
     def streaming_protocol: () -> self
     def request_response_protocol: () -> self
     def identity_key: (String key) -> self
     def use: (untyped klass, *untyped args, **untyped kwargs) -> self
+    def use_outbound: (untyped klass, *untyped args, **untyped kwargs) -> self
     def app: () -> untyped
+
+    private
+
+    def instantiate_middleware: (untyped klass, Array[untyped] args, Hash[Symbol, untyped] kwargs) -> untyped
   end
 
   # ── Service proxies ──

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: restate-sdk
 version: !ruby/object:Gem::Version
-  version: 0.8.0
+  version: 0.10.0
 platform: aarch64-linux
 authors:
 - Restate Developers
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2026-03-23 00:00:00.000000000 Z
+date: 2026-05-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async
@@ -54,7 +54,6 @@ files:
 - ext/restate_internal/extconf.rb
 - ext/restate_internal/src/lib.rs
 - lib/restate.rb
-- lib/restate/3.2/restate_internal.so
 - lib/restate/3.3/restate_internal.so
 - lib/restate/3.4/restate_internal.so
 - lib/restate/4.0/restate_internal.so
@@ -66,6 +65,8 @@ files:
 - lib/restate/endpoint.rb
 - lib/restate/errors.rb
 - lib/restate/handler.rb
+- lib/restate/introspection.rb
+- lib/restate/railtie.rb
 - lib/restate/serde.rb
 - lib/restate/server.rb
 - lib/restate/server_context.rb
@@ -91,7 +92,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.3'
   - - "<"
     - !ruby/object:Gem::Version
       version: 4.1.dev