volcano-sdk 0.32.0 → 0.32.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 551cf1235bb42130cc2c2689af7b4a68bad7582d2df5dc8345df72ee8d061925
-  data.tar.gz: 579af3b2c9301b7b22662e31706752c4d4098438d7ec3c25b6bb8029d17d6f4f
+  metadata.gz: ea2aa2e1bb816dd0f4feef5c80d3dab616b24d56b54e81394fb63d5774bddae0
+  data.tar.gz: 7ce5d0819d1a808fb4ee54c63c830a2a5173b0d15449174a007ac4b03236f0ac
 SHA512:
-  metadata.gz: f3e37060a57939cf40d621880d6f9490af9912934b426d85485a37bd5ece0398d3a9adf0fc7034b211a21ef8b663fe6e2fd2aca6d4b7520cdfcc7373572b0d5f
-  data.tar.gz: f1d77ddbca839dfb7944e83cb025096dad93dd1fe846d13346e9825ec3280fede17d984b5ae14aed330ce4caa0f7a7eb0289107f985f089379da68a04095dce2
+  metadata.gz: '037199a369e46cb09775fb9e85b1396ff373d3a39b88411670ccae2b9a3494985755016b1af78f41d84cbe674ff5703c3f1cef4c49b7c8f05a3e9e7ba46b38ed'
+  data.tar.gz: d178936e2018bcad91947371b2ee56878ef5f06f42df97e5a273035ae9395a2219062efd80bad18c2d8b4f13abd5eb8eb4908d17d8e46561faa1f4a36ac77471

data/README.md

@@ -505,26 +505,32 @@ handle = client.durable.start(
   execution_name: "order-9"
 )
 
-execution = client.durable.get(project_id, "charge-order", handle.id)
+owner_client = Volcano::Client.new(
+  api_url: "https://api.volcano.dev",
+  anon_key: ENV.fetch("VOLCANO_ANON_KEY"),
+  access_token: ENV.fetch("VOLCANO_PLATFORM_TOKEN")
+)
+execution = owner_client.durable.get(project_id, "charge-order", handle.id)
 puts [execution.status, execution.terminal?, execution.result]
 
-page = client.durable.list(project_id, "charge-order", status: "running")
+page = owner_client.durable.list(project_id, "charge-order", status: "running")
 puts [page.total, page.has_more]
 
-client.durable.stop(project_id, "charge-order", handle.id)
+owner_client.durable.stop(project_id, "charge-order", handle.id)
 ```
 
 `start` takes a durable function's name or its id and returns a handle, never a
-result: an execution can run for hours, so its result is read back with `get`.
+result: an execution can run for up to 366 days, so its result is read back with `get`.
 It uses the same credential `invoke` does — the active user session, then a
 configured service key, then the anonymous key — and is the only durable
 operation an application credential may perform. An `execution_name` makes the
 start idempotent: starting again under the same name returns the execution that
 already exists rather than beginning a second one.
 
-`get`, `list`, and `stop` are owner-scoped and require a platform token or a
-configured service key, because an execution is addressed by its id alone. An
-auth-user session from sign-in is not accepted. `get` carries the deeply
+`get`, `list`, and `stop` are owner-scoped and require the project owner's
+platform user token, because an execution is addressed by its id alone.
+Auth-user sessions, anonymous keys, service keys, and project access tokens are
+not accepted. `get` carries the deeply
 frozen `result` once the execution has succeeded, and `error` when it failed;
 `result_expired` separates a result the platform has discarded from a function
 that returned nothing. `terminal?` reports whether the execution has stopped

data/lib/volcano/database.rb

@@ -1,33 +1,21 @@
 # frozen_string_literal: true
 
+# Ruby SDK runtime and immutable database builders.
 module Volcano
-  # Captures caller-owned query values before storing them in immutable builders.
-  module ImmutableQueryValue
-    module_function
-
-    def capture(value)
-      case value
-      when String then value.dup.freeze
-      when Array then value.map { |item| capture(item) }.freeze
-      when Hash then capture_hash(value)
-      else value
-      end
-    end
-
-    def capture_hash(value)
-      value.to_h { |key, item| [capture(key), capture(item)] }.freeze
-    end
-  end
-  private_constant :ImmutableQueryValue
-
   QueryContext = Data.define(:client, :transport, :database_name)
   private_constant :QueryContext
   QueryState = Data.define(:columns, :filters, :order, :limit, :offset)
   private_constant :QueryState
+  # @type var empty_columns: Array[String]
+  empty_columns = []
+  empty_columns.freeze
+  # @type var empty_conditions: Array[query_condition]
+  empty_conditions = []
+  empty_conditions.freeze
   EMPTY_QUERY_STATE = QueryState.new(
-    columns: [].freeze,
-    filters: [].freeze,
-    order: [].freeze,
+    columns: empty_columns,
+    filters: empty_conditions,
+    order: empty_conditions,
     limit: nil,
     offset: nil
   )
@@ -35,6 +23,7 @@ module Volcano
 
   # Adds the shared immutable filter vocabulary to database builders.
   module FilterMethods
+    # @dynamic copy
     def eq(column, value) = add_filter(column, 'eq', value)
     def neq(column, value) = add_filter(column, 'neq', value)
     def gt(column, value) = add_filter(column, 'gt', value)
@@ -50,9 +39,9 @@ module Volcano
 
     def add_filter(column, operator, value)
       condition = {
-        'column' => ImmutableQueryValue.capture(column),
+        'column' => ImmutableRequestValue.capture(column),
         'operator' => operator,
-        'value' => ImmutableQueryValue.capture(value)
+        'value' => ImmutableRequestValue.capture(value)
       }.freeze
       copy(filters: [*@filters, condition])
     end
@@ -62,7 +51,7 @@ module Volcano
   # Creates immutable queries scoped to one project database.
   class Database
     def initialize(client, transport, name)
-      database_name = ImmutableQueryValue.capture(name)
+      database_name = ImmutableRequestValue.capture(name)
       @context = QueryContext.new(client:, transport:, database_name:)
     end
 
@@ -77,7 +66,7 @@ module Volcano
 
     def initialize(context, table, state: EMPTY_QUERY_STATE)
       @context = context
-      @table = ImmutableQueryValue.capture(table)
+      @table = ImmutableRequestValue.capture(table)
       @columns = state.columns
       @filters = state.filters
       @order = state.order
@@ -87,13 +76,13 @@ module Volcano
     end
 
     def select(*columns)
-      copy(columns: ImmutableQueryValue.capture(columns))
+      copy(columns: ImmutableRequestValue.capture(columns))
     end
 
-    def insert(values) = InsertBuilder.new(@context, @table, ImmutableQueryValue.capture(values))
+    def insert(values) = InsertBuilder.new(@context, @table, ImmutableRequestValue.capture(values))
 
     def update(values)
-      UpdateBuilder.new(@context, @table, ImmutableQueryValue.capture(values), filters: @filters)
+      UpdateBuilder.new(@context, @table, ImmutableRequestValue.capture(values), filters: @filters)
     end
 
     def delete
@@ -101,7 +90,7 @@ module Volcano
     end
 
     def order(column, ascending: true)
-      clause = { 'column' => ImmutableQueryValue.capture(column), 'ascending' => ascending }.freeze
+      clause = { 'column' => ImmutableRequestValue.capture(column), 'ascending' => ascending }.freeze
       copy(order: [*@order, clause])
     end
 
@@ -123,7 +112,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
 
     private
@@ -149,7 +138,9 @@ module Volcano
     end
 
     def query_body
-      { 'table' => @table }.tap do |body|
+      # @type var body: sdk_payload
+      body = { 'table' => @table }
+      body.tap do |body|
         add_query_selection(body)
         body['limit'] = @limit unless @limit.nil?
         body['offset'] = @offset unless @offset.nil?
@@ -184,7 +175,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
   end
 
@@ -192,7 +183,7 @@ module Volcano
   class UpdateBuilder
     include FilterMethods
 
-    def initialize(context, table, values, filters: [].freeze)
+    def initialize(context, table, values, filters: EMPTY_QUERY_STATE.filters)
       @context = context
       @table = table
       @values = values
@@ -210,7 +201,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
 
     private
@@ -224,7 +215,7 @@ module Volcano
   class DeleteBuilder
     include FilterMethods
 
-    def initialize(context, table, filters: [].freeze)
+    def initialize(context, table, filters: EMPTY_QUERY_STATE.filters)
       @context = context
       @table = table
       @filters = filters
@@ -241,7 +232,7 @@ module Volcano
           )
         end
       end
-      Transport.body(response, 200).fetch('data')
+      Transport.json_rows(Transport.body(response, 200))
     end
 
     private

data/lib/volcano/durable.rb

@@ -40,10 +40,10 @@ module Volcano
 
     # Reads an execution, including its result once it has succeeded.
     #
-    # Owner-scoped: an execution is addressed by its id alone and an anon key
-    # is held by everyone who loads the page, so this takes the project id and
-    # a platform token or service key. An auth-user session from sign-in is
-    # not enough. Poll it from a backend, not a browser.
+    # Owner-scoped: an execution is addressed by its id alone, so this takes
+    # the project id and the project owner's platform user token. Auth-user
+    # sessions, anon keys, service keys, and project access tokens are not
+    # accepted. Poll it from a backend, not a browser.
     def get(project_id, function_name, execution_id)
       project, function_id, execution = execution_path(project_id, function_name, execution_id)
       response = Transport.invoke do
@@ -100,7 +100,7 @@ module Volcano
     # An empty path segment would address the collection instead of the
     # execution, which is a different request rather than a failed one.
     def identifier(value, field)
-      raise ArgumentError, "#{field} must be a non-empty String" unless present_string?(value)
+      raise ArgumentError, "#{field} must be a non-empty String" unless value.is_a?(String) && present_string?(value)
 
       value.strip.freeze
     end
@@ -128,7 +128,7 @@ module Volcano
     end
 
     def validate_page_limit(limit)
-      return if limit.nil? || (positive_integer?(limit) && limit <= MAX_PAGE_SIZE)
+      return if limit.nil? || (limit.is_a?(Integer) && positive_integer?(limit) && limit <= MAX_PAGE_SIZE)
 
       raise ArgumentError, "limit must be an Integer between 1 and #{MAX_PAGE_SIZE}"
     end

data/lib/volcano/durable_models.rb

@@ -15,9 +15,16 @@ module Volcano
   private_constant :DURABLE_TERMINAL_STATUSES
 
   # Why a failed or timed-out execution ended.
-  DurableExecutionError = Data.define(:type, :message) do
+  DurableExecutionError = Data.define(:type, :message)
+
+  # Reopens the generated record for checked initialization.
+  class DurableExecutionError
+    # @dynamic type, message, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(type: nil, message: nil)
-      super(type: type&.dup&.freeze, message: message&.dup&.freeze)
+      type = type&.dup&.freeze
+      message = message&.dup&.freeze
+      super
     end
   end
 
@@ -27,7 +34,13 @@ module Volcano
   # once its retention lapses. That is not the same as a function that returned
   # nothing, so read `result_expired` before concluding anything from a missing
   # result.
-  DurableExecution = Data.define(*DURABLE_EXECUTION_ATTRIBUTES) do
+  DurableExecution = Data.define(*DURABLE_EXECUTION_ATTRIBUTES)
+
+  # Reopens the generated record for checked initialization.
+  class DurableExecution
+    # @dynamic id, function_id, name, status, region, created_at, result, result_expired
+    # @dynamic error, completed_at, members, with, to_h, deconstruct, deconstruct_keys
+    # @dynamic self.[], self.members
     def initialize(**attributes)
       unknown = attributes.keys - DURABLE_EXECUTION_ATTRIBUTES
       raise ArgumentError, "unknown keywords: #{unknown.join(', ')}" unless unknown.empty?
@@ -38,7 +51,8 @@ module Volcano
       values = DURABLE_EXECUTION_ATTRIBUTES.to_h do |name|
         [name, immutable_value(attributes[name])]
       end
-      super(**values)
+      attributes = values
+      super
     end
 
     # Reports whether the execution has stopped changing.
@@ -64,12 +78,15 @@ module Volcano
   end
 
   # One page of a durable function's executions, most recent first.
-  DurableExecutionPage = Data.define(:executions, :page, :limit, :total, :has_more) do
+  DurableExecutionPage = Data.define(:executions, :page, :limit, :total, :has_more)
+
+  # Reopens the generated record for checked initialization.
+  class DurableExecutionPage
+    # @dynamic executions, page, limit, total, has_more, members, with, to_h
+    # @dynamic deconstruct, deconstruct_keys, self.[], self.members
     def initialize(executions:, page:, limit:, total:, has_more:)
-      super(
-        executions: executions.to_a.dup.freeze,
-        page: page, limit: limit, total: total, has_more: has_more
-      )
+      executions = executions.to_a.dup.freeze
+      super
     end
   end
 
@@ -77,18 +94,17 @@ module Volcano
   module DurableResponses
     INCOMPLETE_EXECUTION = 'Expected a complete durable execution'
     INCOMPLETE_PAGE = 'Expected a complete durable execution page'
-    EXECUTION_FIELDS = %w[id function_id name status region].freeze
-    private_constant :INCOMPLETE_EXECUTION, :INCOMPLETE_PAGE, :EXECUTION_FIELDS
+    private_constant :INCOMPLETE_EXECUTION, :INCOMPLETE_PAGE
 
     private
 
     def durable_execution(payload)
       values = execution_payload(payload)
       DurableExecution.new(
-        id: values.fetch('id'), function_id: values.fetch('function_id'),
-        name: values.fetch('name'), status: values.fetch('status'),
-        region: values.fetch('region'), created_at: parse_time(values.fetch('created_at')),
-        result: values['result'], result_expired: values['result_expired'],
+        id: execution_text(values, 'id'), function_id: execution_text(values, 'function_id'),
+        name: execution_text(values, 'name'), status: execution_text(values, 'status'),
+        region: execution_text(values, 'region'), created_at: execution_time(values),
+        result: execution_result(values['result']), result_expired: execution_expired(values['result_expired']),
         error: execution_error(values['error']), completed_at: parse_time(values['completed_at'])
       )
     end
@@ -96,12 +112,36 @@ module Volcano
     def execution_payload(payload)
       raise TypeError, INCOMPLETE_EXECUTION unless payload.is_a?(Hash)
 
-      complete = EXECUTION_FIELDS.all? { |field| present_string?(payload[field]) }
-      raise TypeError, INCOMPLETE_EXECUTION unless complete && payload['created_at']
-
       payload
     end
 
+    def execution_text(values, field)
+      value = values[field]
+      raise TypeError, INCOMPLETE_EXECUTION unless value.is_a?(String) && !value.strip.empty?
+
+      value
+    end
+
+    def execution_time(values)
+      case (value = values['created_at'])
+      when String then Time.iso8601(value)
+      when Time then value
+      else raise TypeError, INCOMPLETE_EXECUTION
+      end
+    end
+
+    def execution_expired(value)
+      return value if value.nil? || value.is_a?(TrueClass) || value.is_a?(FalseClass)
+
+      raise TypeError, INCOMPLETE_EXECUTION
+    end
+
+    def execution_result(value)
+      Transport.json_value(value)
+    rescue TypeError
+      raise TypeError, INCOMPLETE_EXECUTION, cause: nil
+    end
+
     def execution_error(payload)
       return if payload.nil?
       raise TypeError, INCOMPLETE_EXECUTION unless payload.is_a?(Hash)
@@ -110,10 +150,10 @@ module Volcano
     end
 
     def durable_execution_page(payload)
-      data, has_more = page_payload(payload)
+      values, data, has_more = page_payload(payload)
       DurableExecutionPage.new(
         executions: data.map { |entry| durable_execution(entry) }, has_more: has_more,
-        page: count(payload['page']), limit: count(payload['limit']), total: count(payload['total'])
+        page: count(values['page']), limit: count(values['limit']), total: count(values['total'])
       )
     end
 
@@ -124,7 +164,7 @@ module Volcano
       has_more = payload['has_more']
       raise TypeError, INCOMPLETE_PAGE unless data.is_a?(Array) && [true, false].include?(has_more)
 
-      [data, has_more]
+      [payload, data, has_more]
     end
 
     def count(value)
@@ -138,7 +178,10 @@ module Volcano
     end
 
     def parse_time(value)
-      value.is_a?(String) ? Time.iso8601(value) : value
+      return Time.iso8601(value) if value.is_a?(String)
+      return value if value.nil? || value.is_a?(Time)
+
+      raise TypeError, INCOMPLETE_EXECUTION
     end
   end
   private_constant :DurableResponses

data/lib/volcano/function_auth.rb

@@ -32,7 +32,7 @@ module Volcano
 
     def refresh(original)
       # Resolution has released its cache lock before refresh callbacks run.
-      @client.auth.__send__(:refresh_captured_session, @binding)
+      @client.auth.__send__(:refresh_captured_session, active_binding)
     rescue Error::SessionChangedError
       raise
     rescue Error::VolcanoError
@@ -41,11 +41,18 @@ module Volcano
 
     def validate
       if @binding.last
-        @client.auth.__send__(:validate_read_failure, @binding)
+        @client.auth.__send__(:validate_read_failure, active_binding)
       elsif @client.capture_session_binding[1] != @binding[1]
         raise Error::SessionChangedError
       end
     end
+
+    def active_binding
+      generation, owner, session = @binding
+      raise Error::SessionChangedError unless session
+
+      [generation, owner, session]
+    end
   end
   private_constant :FunctionAuth
 end

data/lib/volcano/functions.rb

@@ -3,6 +3,9 @@
 require_relative 'function_auth'
 
 module Volcano
+  INVALID_FUNCTION_NAME = 'Function name must be DNS-safe: lowercase letters, numbers, and hyphens; 1-63 characters'
+  private_constant :INVALID_FUNCTION_NAME
+
   # Invokes deployed Volcano functions by name.
   class Functions
     FUNCTION_NAME = /\A[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\z/
@@ -21,7 +24,7 @@ module Volcano
     def invoke(name, payload = {})
       auth = FunctionAuth.new(@client)
       validate_invocation(name, payload)
-      invoke_owned(auth, name.dup.freeze, ImmutableQueryValue.capture(payload))
+      invoke_owned(auth, name.dup.freeze, ImmutableRequestValue.capture(payload))
     end
 
     private
@@ -53,9 +56,7 @@ module Volcano
     # X-Volcano-Function-Invoked only after dispatch, so its absence is what
     # separates the two. X-Volcano-Version cannot: the server stamps it on every
     # response, including errors raised before the function is reached.
-    def stale_mapping?(response)
-      response.status == 404 && header(response.headers, FUNCTION_INVOKED_HEADER).nil?
-    end
+    def stale_mapping?(response) = response.status == 404 && header(response.headers, FUNCTION_INVOKED_HEADER).nil?
 
     def invoke_resolved(authorization, resolution, payload)
       if resolution.invoke_url.nil?
@@ -77,8 +78,8 @@ module Volcano
       # Hold the name's lock across the round trip so concurrent callers wait
       # for one resolve instead of each opening their own.
       FunctionResolution.resolve_lock(@api_url, authorization, name).synchronize do
-        cached = FunctionResolution.lookup(@api_url, authorization, name)
-        next cached_resolution(cached) if cached
+        cached_under_lock = FunctionResolution.lookup(@api_url, authorization, name)
+        next cached_resolution(cached_under_lock) if cached_under_lock
 
         resolve_uncached(authorization, name)
       end
@@ -88,7 +89,7 @@ module Volcano
       resolved = Transport.invoke do
         @transport.resolve_function_for_invocation(authorization: authorization, name: name)
       end
-      payload = Transport.body(resolved, 200)
+      payload = Transport.json_object(Transport.body(resolved, 200), message: 'Expected a complete function response')
       resolution = resolved_resolution(payload)
       FunctionResolution.store(@api_url, authorization, name, resolution, cache_ttl(payload))
       resolution
@@ -98,24 +99,26 @@ module Volcano
     end
 
     def cached_resolution(cached)
-      cached.resolution || raise(FunctionResolution.error_for(cached.failure))
+      return cached.resolution if cached.resolution
+
+      failure = cached.failure || raise(TypeError, 'Expected a cached function resolution')
+      raise FunctionResolution.error_for(failure)
     end
 
     def validate_invocation(name, payload)
-      unless name.is_a?(String) && FUNCTION_NAME.match?(name)
-        raise ArgumentError,
-              'Function name must be DNS-safe: lowercase letters, numbers, and hyphens; 1-63 characters'
-      end
+      raise ArgumentError, INVALID_FUNCTION_NAME unless name.is_a?(String) && FUNCTION_NAME.match?(name)
       raise TypeError, 'Function payload must be a Hash' unless payload.is_a?(Hash)
     end
 
     def resolved_resolution(payload)
-      function_id = payload['function_id'] if payload.is_a?(Hash)
+      payload = Transport.json_object(payload)
+      function_id = payload['function_id']
       raise TypeError, 'Expected a complete function response' unless function_id.is_a?(String) && !function_id.empty?
 
       # Absent when the deployment serves no public invocation domain, as in
       # local development; the function is reached through the API instead.
-      invoke_url = FunctionResolution.valid_invoke_url(payload['invoke_url'], @api_url)
+      candidate = payload['invoke_url']
+      invoke_url = FunctionResolution.valid_invoke_url(candidate.is_a?(String) ? candidate : nil, @api_url)
       FunctionResolution::Resolution.new(function_id: function_id, invoke_url: invoke_url)
     end
 
@@ -136,7 +139,7 @@ module Volcano
       Transport.body(response, 200) unless response.status.between?(200, 299) || dispatched
 
       FunctionResponse.new(
-        data: response.body, status: response.status,
+        data: Transport.json_value(response.body), status: response.status,
         headers: response.headers || {}, version: version
       )
     end

data/lib/volcano/immutable_request_value.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+# Ruby SDK runtime and immutable caller-owned request values.
+module Volcano
+  # Copies JSON-like request values before storing them in builders or sending them.
+  module ImmutableRequestValue
+    def self.capture(value)
+      # @type var active: Hash[Integer, bool]
+      active = {}
+      capture_value(value, active)
+    rescue SystemStackError
+      raise TypeError, 'Request value nesting is too deep'
+    end
+
+    def self.capture_value(value, active)
+      case value
+      when String, Time then value.dup.freeze
+      when Array, Hash then capture_container(value, active)
+      else value
+      end
+    end
+
+    def self.capture_container(value, active)
+      id = value.object_id
+      raise TypeError, 'Request value contains a cycle' if active.key?(id)
+
+      active[id] = true
+      copy = value.is_a?(Array) ? value.map { |item| capture_value(item, active) } : capture_hash(value, active)
+      active.delete(id)
+      copy.freeze
+    end
+
+    def self.capture_hash(value, active)
+      value.to_h { |key, item| [capture_value(key, active), capture_value(item, active)] }
+    end
+  end
+  private_constant :ImmutableRequestValue
+end

data/lib/volcano/logs.rb

@@ -3,8 +3,6 @@
 module Volcano
   # Searches retained project logs and activity.
   class Logs
-    include ImmutableLogJSON
-
     def initialize(client, transport)
       @client = client
       @transport = transport
@@ -46,26 +44,27 @@ module Volcano
       end
       raise TypeError, 'Log request must be a Hash' unless request.is_a?(Hash)
 
-      [project_id.dup.freeze, immutable_json(request)]
+      [project_id.dup.freeze, ImmutableRequestValue.capture(request)]
     end
 
     def search_response(body)
-      data = response_data(body)
+      body, data = response_data(body)
       limit = body['limit']
       has_more = body['has_more']
       next_cursor = body['next_cursor']
-      unless limit.is_a?(Integer) && [true, false].include?(has_more) &&
-             (next_cursor.nil? || next_cursor.is_a?(String))
+      unless limit.is_a?(Integer) && boolean?(has_more) && (next_cursor.nil? || next_cursor.is_a?(String))
         raise TypeError, 'Expected a complete log response'
       end
 
+      has_more = has_more == true
+
       LogSearchResponse.new(
         data: data, limit: limit, has_more: has_more, next_cursor: next_cursor
       )
     end
 
     def activity_response(body)
-      data = response_data(body)
+      body, data = response_data(body)
       total = body['total']
       raise TypeError, 'Expected a complete log response' unless total.is_a?(Integer)
 
@@ -73,10 +72,16 @@ module Volcano
     end
 
     def response_data(body)
-      data = body['data'] if body.is_a?(Hash)
+      raise TypeError, 'Expected a complete log response' unless body.is_a?(Hash)
+
+      data = body['data']
       raise TypeError, 'Expected a complete log response' unless data.is_a?(Array) && data.all?(Hash)
 
-      data
+      [body, data]
+    end
+
+    def boolean?(value)
+      value.is_a?(TrueClass) || value.is_a?(FalseClass)
     end
   end
 end

data/lib/volcano/models.rb

@@ -7,7 +7,14 @@ module Volcano
   ].freeze
   private_constant :AUTH_SESSION_ATTRIBUTES
 
-  AuthSession = Data.define(*AUTH_SESSION_ATTRIBUTES) do
+  AuthSession = Data.define(*AUTH_SESSION_ATTRIBUTES)
+
+  # Reopens the generated record for checked initialization.
+  class AuthSession
+    # @dynamic id, user_id, provider, expires_at, is_active, is_current, user_agent
+    # @dynamic ip_address, last_ip_address, last_activity_at, session_started_at
+    # @dynamic created_at, updated_at, members, with, to_h, deconstruct
+    # @dynamic deconstruct_keys, self.[], self.members
     def initialize(**attributes)
       unknown = attributes.keys - AUTH_SESSION_ATTRIBUTES
       raise ArgumentError, "unknown keywords: #{unknown.join(', ')}" unless unknown.empty?
@@ -18,7 +25,8 @@ module Volcano
       values = AUTH_SESSION_ATTRIBUTES.to_h do |name|
         [name, freeze_session_value(attributes[name])]
       end
-      super(**values)
+      attributes = values
+      super
     end
 
     private
@@ -28,19 +36,28 @@ module Volcano
     end
   end
 
-  SessionPage = Data.define(:sessions, :total, :page, :limit, :total_pages) do
+  SessionPage = Data.define(:sessions, :total, :page, :limit, :total_pages)
+
+  # Reopens the generated record for checked initialization.
+  class SessionPage
+    # @dynamic sessions, total, page, limit, total_pages, members, with, to_h
+    # @dynamic deconstruct, deconstruct_keys, self.[], self.members
     def initialize(sessions:, total:, page:, limit:, total_pages:)
-      super(sessions: sessions.to_a.dup.freeze, total: total, page: page, limit: limit,
-            total_pages: total_pages)
+      sessions = sessions.to_a.dup.freeze
+      super
     end
   end
-  LinkedOAuthProvider = Data.define(:provider, :linked_at, :updated_at) do
+  LinkedOAuthProvider = Data.define(:provider, :linked_at, :updated_at)
+
+  # Reopens the generated record for checked initialization.
+  class LinkedOAuthProvider
+    # @dynamic provider, linked_at, updated_at, members, with, to_h, deconstruct
+    # @dynamic deconstruct_keys, self.[], self.members
     def initialize(provider:, linked_at:, updated_at:)
-      super(
-        provider: immutable_value(provider),
-        linked_at: immutable_value(linked_at),
-        updated_at: immutable_value(updated_at)
-      )
+      provider = immutable_value(provider)
+      linked_at = immutable_value(linked_at)
+      updated_at = immutable_value(updated_at)
+      super
     end
 
     private
@@ -49,30 +66,46 @@ module Volcano
       value.frozen? ? value : value.dup.freeze
     end
   end
-  OAuthProviderTokenStatus = Data.define(:message, :provider, :expires_in) do
+  OAuthProviderTokenStatus = Data.define(:message, :provider, :expires_in)
+
+  # Reopens the generated record for checked initialization.
+  class OAuthProviderTokenStatus
+    # @dynamic message, provider, expires_in, members, with, to_h, deconstruct
+    # @dynamic deconstruct_keys, self.[], self.members
     def initialize(message:, provider:, expires_in:)
       values = [message, provider]
       valid = values.all? { |value| value.is_a?(String) && !value.strip.empty? }
       raise TypeError, 'Expected complete OAuth provider token status' unless valid && expires_in.is_a?(Integer)
 
-      super(message: message.dup.freeze, provider: provider.dup.freeze, expires_in: expires_in)
+      message = message.dup.freeze
+      provider = provider.dup.freeze
+      super
     end
   end
   EmailChangeResult = Data.define(:message, :new_email)
-  LockLease = Data.define(:key, :token, :expires_at, :fencing_token) do
+  LockLease = Data.define(:key, :token, :expires_at, :fencing_token)
+
+  # Reopens the generated record for checked initialization.
+  class LockLease
+    # @dynamic key, token, expires_at, fencing_token, members, with, to_h
+    # @dynamic deconstruct, deconstruct_keys, self.[], self.members
     def initialize(key:, token:, expires_at:, fencing_token:)
-      super(
-        key: key.dup.freeze,
-        token: token.dup.freeze,
-        expires_at: expires_at&.dup&.freeze,
-        fencing_token: fencing_token
-      )
+      key = key.dup.freeze
+      token = token.dup.freeze
+      expires_at = expires_at&.dup&.freeze
+      super
     end
   end
-  LockState = Data.define(:held, :expires_at, :fencing_token) do
+  LockState = Data.define(:held, :expires_at, :fencing_token)
+
+  # Reopens the generated record for checked initialization.
+  class LockState
+    # @dynamic held, expires_at, fencing_token, members, with, to_h, deconstruct
+    # @dynamic deconstruct_keys, self.[], self.members
     def initialize(held:, expires_at:, fencing_token:)
       immutable_expiry = expires_at&.then { |value| value.frozen? ? value : value.dup.freeze }
-      super(held: held, expires_at: immutable_expiry, fencing_token: fencing_token)
+      expires_at = immutable_expiry
+      super
     end
   end
 end

data/lib/volcano/realtime/channel_callbacks.rb

@@ -10,7 +10,10 @@ module Volcano
       def on(event, callback = nil, &block)
         raise ArgumentError, "unsupported realtime event: #{event}" unless allowed_event?(event)
 
-        @callbacks[event] << (callback || block || raise(ArgumentError, 'callback or block is required'))
+        handler = callback || block || raise(ArgumentError, 'callback or block is required')
+        raise ArgumentError, 'callback must respond to call' unless handler.respond_to?(:call)
+
+        @callbacks[event] << handler
         self
       end
 

data/lib/volcano/realtime/postgres_changes.rb

@@ -39,6 +39,8 @@ module Volcano
         ensure_postgres!
         event = postgres_event(event)
         handler = callback || block || raise(ArgumentError, 'callback or block is required')
+        raise ArgumentError, 'callback must respond to call' unless handler.respond_to?(:call)
+
         register_postgres_listener(event, schema.to_s, table.to_s, handler)
       end
 

data/lib/volcano/session.rb

@@ -10,15 +10,26 @@ module Volcano
   private_constant :SESSION_USER_CODER
 
   # Local credentials; refresh credentials and user identity may be unknown.
-  Session = Data.define(:access_token, :refresh_token, :user_id, :user) do
+  Session = Data.define(:access_token, :refresh_token, :user_id, :user)
+
+  # Reopens the generated record for checked initialization.
+  class Session
+    # @dynamic access_token, refresh_token, user_id, user, members, with, to_h
+    # @dynamic deconstruct, deconstruct_keys, self.[], self.members
     def initialize(access_token:, refresh_token: nil, user_id: nil, user: nil)
-      super(access_token:, refresh_token:, user_id:, user: immutable_user(user))
+      user = immutable_user(user)
+      super
     end
 
     private
 
     def immutable_user(value)
-      SESSION_USER_CODER.load(SESSION_USER_CODER.dump(value))
+      return if value.nil?
+
+      snapshot = SESSION_USER_CODER.load(SESSION_USER_CODER.dump(value))
+      raise TypeError, 'Session user snapshot must be a Hash' unless snapshot.is_a?(Hash)
+
+      snapshot
     rescue JSON::GeneratorError, JSON::NestingError
       raise TypeError, 'Session user snapshot must contain JSON values or timestamps', cause: nil
     end

data/lib/volcano/transport.rb

@@ -20,21 +20,20 @@ module Volcano
 
     NETWORK_ERRORS = [IOError, SystemCallError, SocketError, Timeout::Error].freeze
 
-    module_function
-
-    def invoke
+    def self.invoke
       yield
-    rescue *NETWORK_ERRORS => e
+    rescue IOError, SystemCallError, SocketError, Timeout::Error => e
       raise Error::TransportError, e.message, cause: e
     end
 
-    def body(response, expected_status)
+    def self.body(response, expected_status)
       return response.body if response.status == expected_status
 
       raise response_error(response)
     end
 
-    def response_error(response)
+    def self.response_error(response)
+      # @type var payload: Hash[String, Object?]
       payload = response.body.is_a?(Hash) ? response.body : {}
       retry_after = integer_header(response.headers, 'Retry-After') if response.status == 429
       error_type(response.status).new(
@@ -45,20 +44,63 @@ module Volcano
       )
     end
 
-    def error_message(payload)
-      payload['error'] || payload['message'] || 'Volcano request failed'
+    def self.error_message(payload)
+      error = payload['error']
+      return error if error.is_a?(String)
+
+      message = payload['message']
+      message.is_a?(String) ? message : 'Volcano request failed'
+    end
+
+    def self.json_value(value)
+      case value
+      when Array then value.map { |entry| json_value(entry) }
+      when Hash then json_object(value)
+      else json_scalar(value)
+      end
+    end
+
+    def self.json_object(value, message: 'Expected a JSON object')
+      raise TypeError, message unless value.is_a?(Hash)
+
+      value.to_h do |key, item|
+        raise TypeError, message unless key.is_a?(String)
+
+        [key, json_value(item)]
+      end
+    end
+
+    def self.json_rows(value)
+      rows = json_object(value)['data']
+      raise TypeError, 'Expected database rows' unless rows.is_a?(Array)
+
+      rows.map { |row| json_object(row) }
+    end
+
+    def self.finite_float(value)
+      raise TypeError, 'Expected a finite JSON number' unless value.finite?
+
+      value
+    end
+
+    def self.json_scalar(value)
+      case value
+      when NilClass, TrueClass, FalseClass, Integer, String then value
+      when Float then finite_float(value)
+      else raise TypeError, 'Expected a JSON response'
+      end
     end
 
-    def error_type(status)
+    def self.error_type(status)
       ERROR_TYPES.fetch(status) do
         status.between?(500, 599) ? Error::ServerError : Error::VolcanoError
       end
     end
 
-    def integer_header(headers, name)
+    def self.integer_header(headers, name)
       value = headers&.find { |key, _| key.casecmp?(name) }&.last
       Integer(value, exception: false)
     end
-    private_class_method :error_type, :integer_header, :response_error
+    private_class_method :error_type, :integer_header, :response_error, :finite_float, :json_scalar
   end
 end

data/lib/volcano/user.rb

@@ -10,15 +10,20 @@ module Volcano
   User = Data.define(
     :id, :project_id, :email, :email_confirmed, :user_metadata, :app_metadata,
     :avatar_url, :status, :banned_until, :last_sign_in_at, :created_at, :updated_at
-  ) do
+  )
+
+  # Reopens the generated record for checked initialization.
+  class User
+    # @dynamic id, project_id, email, email_confirmed, user_metadata, app_metadata
+    # @dynamic avatar_url, status, banned_until, last_sign_in_at, created_at, updated_at
+    # @dynamic members, with, to_h, deconstruct, deconstruct_keys, self.[], self.members
     def initialize(id:, email:, status:, **attributes)
       validate_optional_attributes(attributes)
-      super(
-        id: freeze_value(id),
-        email: freeze_value(email),
-        status: freeze_value(status),
-        **USER_OPTIONAL_ATTRIBUTES.to_h { |name| [name, freeze_value(attributes[name])] }
-      )
+      id = freeze_value(id)
+      email = freeze_value(email)
+      status = freeze_value(status)
+      attributes = USER_OPTIONAL_ATTRIBUTES.to_h { |name| [name, freeze_value(attributes[name])] }
+      super
     end
 
     private

data/lib/volcano/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Volcano
-  VERSION = '0.32.0'
+  VERSION = '0.32.2'
 end

data/lib/volcano.rb

@@ -16,6 +16,7 @@ require_relative 'volcano/auth_state'
 require_relative 'volcano/errors'
 require_relative 'volcano/redaction'
 require_relative 'volcano/transport'
+require_relative 'volcano/immutable_request_value'
 require_relative 'volcano/generated_transport'
 require_relative 'volcano/auth_notification_dispatch'
 require_relative 'volcano/auth_session_binding'

data/sig/auth_credentials.rbs

@@ -1,8 +1,10 @@
 module Volcano
+  type auth_state_event = :initial_session | :signed_in | :signed_out | :token_refreshed
+
   class Auth
     def current_session: () -> Session?
     def current_session=: (Session session) -> void
-    def on_auth_state_change: () { (Symbol, Session?) -> void } -> AuthSubscription
+    def on_auth_state_change: () { (auth_state_event, Session?) -> void } -> AuthSubscription
     def sign_in: (email: String, password: String) -> Session
     def sign_up: (email: String, password: String, ?metadata: session_user_input, ?sign_in_when_allowed: bool) -> SignUpResult
     def sign_in_anonymously: (?metadata: session_user_input) -> Session

data/sig/auth_session_records.rbs

@@ -20,7 +20,7 @@ module Volcano
                | (id: String, user_id: String, provider: String, expires_at: Time, is_active: bool, is_current: bool, ?user_agent: String?, ?ip_address: String?, ?last_ip_address: String?, ?last_activity_at: Time?, ?session_started_at: Time?, ?created_at: Time?, ?updated_at: Time?) -> AuthSession
     def self.members: () -> [:id, :user_id, :provider, :expires_at, :is_active, :is_current, :user_agent, :ip_address, :last_ip_address, :last_activity_at, :session_started_at, :created_at, :updated_at]
 
-    def initialize: (id: String, user_id: String, provider: String, expires_at: Time, is_active: bool, is_current: bool, ?user_agent: String?, ?ip_address: String?, ?last_ip_address: String?, ?last_activity_at: Time?, ?session_started_at: Time?, ?created_at: Time?, ?updated_at: Time?) -> void
+    private def initialize: (**Object? attributes) -> void
     def members: () -> [:id, :user_id, :provider, :expires_at, :is_active, :is_current, :user_agent, :ip_address, :last_ip_address, :last_activity_at, :session_started_at, :created_at, :updated_at]
     def with: (?id: String, ?user_id: String, ?provider: String, ?expires_at: Time, ?is_active: bool, ?is_current: bool, ?user_agent: String?, ?ip_address: String?, ?last_ip_address: String?, ?last_activity_at: Time?, ?session_started_at: Time?, ?created_at: Time?, ?updated_at: Time?) -> AuthSession
     def to_h: () -> { id: String, user_id: String, provider: String, expires_at: Time, is_active: bool, is_current: bool, user_agent: String?, ip_address: String?, last_ip_address: String?, last_activity_at: Time?, session_started_at: Time?, created_at: Time?, updated_at: Time? }

data/sig/client.rbs

@@ -0,0 +1,15 @@
+module Volcano
+  class Client
+    attr_reader auth: Auth
+    attr_reader functions: Functions
+    attr_reader durable: Durable
+    attr_reader logs: Logs
+    attr_reader storage: Storage
+    attr_reader locks: Locks
+    attr_reader realtime: Realtime
+
+    def initialize: (anon_key: String, ?api_url: String, ?service_key: String?, ?timeout: (Integer | Float), ?access_token: String?, ?refresh_token: String?) -> void
+    def current_session: () -> Session?
+    def database: (String name) -> Database
+  end
+end

data/sig/core_facades.rbs

@@ -0,0 +1,81 @@
+module Volcano
+  type sdk_json = nil | bool | Integer | Float | String | Time | Array[sdk_json] | Hash[String | Symbol, sdk_json]
+  type sdk_payload = Hash[String | Symbol, sdk_json]
+  type database_rows = Array[Hash[String, json_value]]
+
+  class Database
+    def from: (String table) -> QueryBuilder
+  end
+
+  class QueryBuilder
+    def select: (*String columns) -> QueryBuilder
+    def insert: (sdk_payload values) -> InsertBuilder
+    def update: (sdk_payload values) -> UpdateBuilder
+    def delete: () -> DeleteBuilder
+    def order: (String column, ?ascending: bool) -> QueryBuilder
+    def limit: (Integer count) -> QueryBuilder
+    def offset: (Integer count) -> QueryBuilder
+    def execute: () -> database_rows
+
+    def eq: (String column, sdk_json value) -> QueryBuilder
+    def neq: (String column, sdk_json value) -> QueryBuilder
+    def gt: (String column, sdk_json value) -> QueryBuilder
+    def gte: (String column, sdk_json value) -> QueryBuilder
+    def lt: (String column, sdk_json value) -> QueryBuilder
+    def lte: (String column, sdk_json value) -> QueryBuilder
+    def like: (String column, String pattern) -> QueryBuilder
+    def ilike: (String column, String pattern) -> QueryBuilder
+    def is: (String column, sdk_json value) -> QueryBuilder
+    def in: (String column, Array[sdk_json] values) -> QueryBuilder
+  end
+
+  class InsertBuilder
+    def execute: () -> database_rows
+  end
+
+  class UpdateBuilder
+    def execute: () -> database_rows
+
+    def eq: (String column, sdk_json value) -> UpdateBuilder
+    def neq: (String column, sdk_json value) -> UpdateBuilder
+    def gt: (String column, sdk_json value) -> UpdateBuilder
+    def gte: (String column, sdk_json value) -> UpdateBuilder
+    def lt: (String column, sdk_json value) -> UpdateBuilder
+    def lte: (String column, sdk_json value) -> UpdateBuilder
+    def like: (String column, String pattern) -> UpdateBuilder
+    def ilike: (String column, String pattern) -> UpdateBuilder
+    def is: (String column, sdk_json value) -> UpdateBuilder
+    def in: (String column, Array[sdk_json] values) -> UpdateBuilder
+  end
+
+  class DeleteBuilder
+    def execute: () -> database_rows
+
+    def eq: (String column, sdk_json value) -> DeleteBuilder
+    def neq: (String column, sdk_json value) -> DeleteBuilder
+    def gt: (String column, sdk_json value) -> DeleteBuilder
+    def gte: (String column, sdk_json value) -> DeleteBuilder
+    def lt: (String column, sdk_json value) -> DeleteBuilder
+    def lte: (String column, sdk_json value) -> DeleteBuilder
+    def like: (String column, String pattern) -> DeleteBuilder
+    def ilike: (String column, String pattern) -> DeleteBuilder
+    def is: (String column, sdk_json value) -> DeleteBuilder
+    def in: (String column, Array[sdk_json] values) -> DeleteBuilder
+  end
+
+  class Functions
+    def invoke: (String name, ?sdk_payload payload) -> FunctionResponse
+  end
+
+  class Durable
+    def start: (String function_name, ?sdk_payload payload, ?execution_name: String?) -> DurableExecution
+    def get: (String project_id, String function_name, String execution_id) -> DurableExecution
+    def list: (String project_id, String function_name, ?status: String?, ?page: Integer?, ?limit: Integer?) -> DurableExecutionPage
+    def stop: (String project_id, String function_name, String execution_id) -> DurableExecution
+  end
+
+  class Logs
+    def search: (String project_id, sdk_payload request) -> LogSearchResponse
+    def activity: (String project_id, sdk_payload request) -> LogActivityResponse
+  end
+end

data/sig/durable_records.rbs

@@ -36,7 +36,7 @@ module Volcano
                | (id: String, function_id: String, name: String, status: String, region: String, created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?) -> DurableExecution
     def self.members: () -> [:id, :function_id, :name, :status, :region, :created_at, :result, :result_expired, :error, :completed_at]
 
-    def initialize: (id: String, function_id: String, name: String, status: String, region: String, created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?) -> void
+    private def initialize: (**(json_value | Time | DurableExecutionError) attributes) -> void
     def members: () -> [:id, :function_id, :name, :status, :region, :created_at, :result, :result_expired, :error, :completed_at]
     def with: (?id: String, ?function_id: String, ?name: String, ?status: String, ?region: String, ?created_at: Time, ?result: json_value, ?result_expired: bool?, ?error: DurableExecutionError?, ?completed_at: Time?) -> DurableExecution
     def to_h: () -> { id: String, function_id: String, name: String, status: String, region: String, created_at: Time, result: json_value, result_expired: bool?, error: DurableExecutionError?, completed_at: Time? }

data/sig/locks.rbs

@@ -0,0 +1,10 @@
+module Volcano
+  class Locks
+    def get: (String key, ?request_id: String?) -> LockState
+    def acquire: (String key, ttl: Integer, ?token: String?, ?request_id: String?) -> LockLease
+    def renew: (String key, LockLease lease, ttl: Integer, ?request_id: String?) -> LockLease
+    def release: (String key, LockLease lease, ?request_id: String?) -> nil
+    def force_release: (String key, ?request_id: String?) -> nil
+    def with_lock: [T] (String key, ttl: Integer, ?token: String?, ?request_id: String?) { (LockGuard) -> T } -> T
+  end
+end

data/sig/realtime.rbs

@@ -1,11 +1,4 @@
 module Volcano
-  class Client
-    attr_reader auth: Auth
-    attr_reader realtime: Realtime
-
-    def initialize: (anon_key: String, ?api_url: String, ?service_key: String?, ?timeout: Integer, ?access_token: String?, ?refresh_token: String?) -> void
-  end
-
   class Realtime
     def channel: (String name, ?type: String | Symbol, ?auto_fetch: bool, ?fetch_batch_window_ms: Integer, ?fetch_max_batch_size: Integer) -> Channel
     def connected?: () -> bool
@@ -30,8 +23,14 @@ module Volcano
       def unsubscribe: () -> nil
       def send: (event: String | Symbol, **json_value payload) -> nil
 
-      def on: (String event, ^(Object?) -> void callback) -> self
-            | (String event) { (Object?) -> void } -> self
+      def on: ("message" event, ^(Hash[String, json_value]) -> void callback) -> self
+            | ("message" event) { (Hash[String, json_value]) -> void } -> self
+            | ("join" | "leave" event, ^(PresenceInfo) -> void callback) -> self
+            | ("join" | "leave" event) { (PresenceInfo) -> void } -> self
+            | ("presence_sync" event, ^(Hash[String, PresenceInfo]) -> void callback) -> self
+            | ("presence_sync" event) { (Hash[String, PresenceInfo]) -> void } -> self
+            | ("INSERT" | "UPDATE" | "DELETE" | "*" event, ^(PostgresChange) -> void callback) -> self
+            | ("INSERT" | "UPDATE" | "DELETE" | "*" event) { (PostgresChange) -> void } -> self
       def on_presence_sync: (^(Hash[String, PresenceInfo]) -> void callback) -> self
                           | () { (Hash[String, PresenceInfo]) -> void } -> self
       def on_postgres_changes: (String | Symbol event, schema: String, table: String, callback: ^(PostgresChange) -> void) -> self

data/sig/user.rbs

@@ -19,7 +19,7 @@ module Volcano
                | (id: String, email: String, status: String, ?project_id: String?, ?email_confirmed: bool?, ?user_metadata: Hash[String, json_value]?, ?app_metadata: Hash[String, json_value]?, ?avatar_url: String?, ?banned_until: Time?, ?last_sign_in_at: Time?, ?created_at: Time?, ?updated_at: Time?) -> User
     def self.members: () -> [:id, :project_id, :email, :email_confirmed, :user_metadata, :app_metadata, :avatar_url, :status, :banned_until, :last_sign_in_at, :created_at, :updated_at]
 
-    def initialize: (id: String, email: String, status: String, ?project_id: String?, ?email_confirmed: bool?, ?user_metadata: Hash[String, json_value]?, ?app_metadata: Hash[String, json_value]?, ?avatar_url: String?, ?banned_until: Time?, ?last_sign_in_at: Time?, ?created_at: Time?, ?updated_at: Time?) -> void
+    private def initialize: (id: String, email: String, status: String, **Object? attributes) -> void
     def members: () -> [:id, :project_id, :email, :email_confirmed, :user_metadata, :app_metadata, :avatar_url, :status, :banned_until, :last_sign_in_at, :created_at, :updated_at]
     def with: (?id: String, ?project_id: String?, ?email: String, ?email_confirmed: bool?, ?user_metadata: Hash[String, json_value]?, ?app_metadata: Hash[String, json_value]?, ?avatar_url: String?, ?status: String, ?banned_until: Time?, ?last_sign_in_at: Time?, ?created_at: Time?, ?updated_at: Time?) -> User
     def to_h: () -> { id: String, project_id: String?, email: String, email_confirmed: bool?, user_metadata: Hash[String, json_value]?, app_metadata: Hash[String, json_value]?, avatar_url: String?, status: String, banned_until: Time?, last_sign_in_at: Time?, created_at: Time?, updated_at: Time? }

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: volcano-sdk
 version: !ruby/object:Gem::Version
-  version: 0.32.0
+  version: 0.32.2
 platform: ruby
 authors:
 - Kong
@@ -560,6 +560,7 @@ files:
 - lib/volcano/generated_transport_support.rb
 - lib/volcano/generated_transport_upload_session_api.rb
 - lib/volcano/generated_transport_upload_sessions.rb
+- lib/volcano/immutable_request_value.rb
 - lib/volcano/lock_auto_renewal.rb
 - lib/volcano/lock_guard.rb
 - lib/volcano/lock_lease_clock.rb
@@ -620,13 +621,16 @@ files:
 - sig/auth_session_records.rbs
 - sig/auth_sessions.rbs
 - sig/auth_subscription.rbs
+- sig/client.rbs
 - sig/connection_string.rbs
+- sig/core_facades.rbs
 - sig/durable_records.rbs
 - sig/email_change_result.rbs
 - sig/errors.rbs
 - sig/function_response.rbs
 - sig/lock_guard.rbs
 - sig/lock_records.rbs
+- sig/locks.rbs
 - sig/log_responses.rbs
 - sig/oauth_records.rbs
 - sig/realtime.rbs