volcano-sdk 0.30.0 → 0.32.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 296cdb524e3552873235adccfe2d5c98b39a3da451c06777020b59d45c6a4be0
-  data.tar.gz: 9ca783889458304d91b40601f673a4f5015f117ee4f30f90c23891e351cafe3a
+  metadata.gz: 551cf1235bb42130cc2c2689af7b4a68bad7582d2df5dc8345df72ee8d061925
+  data.tar.gz: 579af3b2c9301b7b22662e31706752c4d4098438d7ec3c25b6bb8029d17d6f4f
 SHA512:
-  metadata.gz: 81067b14e84482e5dfebf935d27051c109ff14b87d144814a36db6ef5a7de6003e0cde0fe4ed4c54c1e06dcd9db79d8f5088c1aa21fbd4bbc3419da9a585f44e
-  data.tar.gz: 4346575e985ab233b5afd723f36e1044b4e9e001b1eefa461a2514977f10a240a88a73978f30d88b2b74a3ec2a6bd4565d1e1ab92968e1988069492cbae9c739
+  metadata.gz: f3e37060a57939cf40d621880d6f9490af9912934b426d85485a37bd5ece0398d3a9adf0fc7034b211a21ef8b663fe6e2fd2aca6d4b7520cdfcc7373572b0d5f
+  data.tar.gz: f1d77ddbca839dfb7944e83cb025096dad93dd1fe846d13346e9825ec3280fede17d984b5ae14aed330ce4caa0f7a7eb0289107f985f089379da68a04095dce2

data/lib/volcano/auth.rb

@@ -9,9 +9,7 @@ module Volcano
     include AuthUpdateUser
     include AuthEmailChange
     include AuthSessions
-
-    INCOMPLETE_SESSION = 'Expected a complete Volcano::Session'
-    private_constant :INCOMPLETE_SESSION
+    include AuthSessionConstruction
 
     def initialize(client, transport, api_url:)
       @client = client
@@ -27,10 +25,10 @@ module Volcano
       @client.store_session(owned_complete_session(session), event: nil)
     end
 
-    def on_auth_state_change(&callback)
-      raise ArgumentError, 'callback block required' unless callback
+    def on_auth_state_change(&)
+      raise ArgumentError, 'callback block required' unless block_given?
 
-      @client.subscribe_auth_state_change(&callback)
+      @client.subscribe_auth_state_change(&)
     end
 
     def sign_in(email:, password:)
@@ -77,47 +75,5 @@ module Volcano
         )
       end
     end
-
-    def build_session(payload)
-      owned_session(
-        access_token: payload.fetch('access_token'),
-        refresh_token: payload.fetch('refresh_token'),
-        user_id: payload.fetch('user').fetch('id'),
-        user: payload.fetch('user')
-      )
-    end
-
-    def parse_refresh_session(payload)
-      owned_complete_session(build_session(payload))
-    rescue KeyError, TypeError, NoMethodError, ArgumentError => e
-      raise Error::TransportError, INCOMPLETE_SESSION, cause: e
-    end
-
-    def complete_session?(session)
-      return false unless session.is_a?(Session)
-
-      values = [session.access_token, session.refresh_token, session.user_id]
-      values.all? { |value| value.is_a?(String) && !value.strip.empty? } &&
-        matching_session_user?(session)
-    end
-
-    def matching_session_user?(session)
-      session.user.nil? || (session.user.is_a?(Hash) && session.user['id'] == session.user_id)
-    end
-
-    def owned_complete_session(session)
-      raise ArgumentError, INCOMPLETE_SESSION unless complete_session?(session)
-
-      owned_session(**session.to_h)
-    end
-
-    def owned_session(access_token:, refresh_token:, user_id:, user: nil)
-      Session.new(
-        access_token: access_token.dup.freeze,
-        refresh_token: refresh_token.dup.freeze,
-        user_id: user_id.dup.freeze,
-        user: user
-      )
-    end
   end
 end

data/lib/volcano/auth_session_construction.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Volcano
+  # Builds and validates owned credential snapshots for the auth facade.
+  module AuthSessionConstruction
+    INCOMPLETE_SESSION = 'Expected a complete Volcano::Session'
+    private_constant :INCOMPLETE_SESSION
+
+    private
+
+    def build_session(payload)
+      raise TypeError, INCOMPLETE_SESSION unless payload.is_a?(Hash)
+
+      user = payload.fetch('user')
+      raise TypeError, INCOMPLETE_SESSION unless user.is_a?(Hash)
+
+      owned_session(
+        access_token: required_session_string(payload.fetch('access_token')),
+        refresh_token: required_session_string(payload.fetch('refresh_token')),
+        user_id: required_session_string(user.fetch('id')),
+        user: user
+      )
+    end
+
+    def parse_refresh_session(payload)
+      owned_complete_session(build_session(payload))
+    rescue KeyError, TypeError, NoMethodError, ArgumentError => e
+      raise Error::TransportError, INCOMPLETE_SESSION, cause: e
+    end
+
+    def complete_session?(session)
+      values = [session.access_token, session.refresh_token, session.user_id]
+      values.all? { |value| value.is_a?(String) && !value.strip.empty? } &&
+        matching_session_user?(session)
+    end
+
+    def matching_session_user?(session)
+      session.user.nil? || (session.user.is_a?(Hash) && session.user['id'] == session.user_id)
+    end
+
+    def owned_complete_session(session)
+      raise ArgumentError, INCOMPLETE_SESSION unless session.is_a?(Session) && complete_session?(session)
+
+      owned_session(
+        access_token: required_session_string(session.access_token),
+        refresh_token: required_session_string(session.refresh_token),
+        user_id: required_session_string(session.user_id),
+        user: session.user
+      )
+    end
+
+    def required_session_string(value)
+      return value if value.is_a?(String) && !value.strip.empty?
+
+      raise ArgumentError, INCOMPLETE_SESSION
+    end
+
+    def owned_session(access_token:, refresh_token:, user_id:, user: nil)
+      Session.new(
+        access_token: access_token.dup.freeze,
+        refresh_token: refresh_token.dup.freeze,
+        user_id: user_id.dup.freeze,
+        user: user
+      )
+    end
+  end
+end

data/lib/volcano/auth_sign_up.rb

@@ -29,6 +29,8 @@ module Volcano
     end
 
     def build_sign_up_result(payload)
+      raise TypeError, INVALID_SIGN_UP_RESULT unless payload.is_a?(Hash)
+
       confirmation_required = payload.fetch('confirmation_required')
       message = payload.fetch('message')
       valid = [true, false].include?(confirmation_required) && message.is_a?(String)

data/lib/volcano/realtime/broadcast_delivery.rb

@@ -4,9 +4,16 @@ module Volcano
   class Realtime
     # Delivers broadcasts only while their subscription generation is current.
     module BroadcastDelivery
-      PublicationContext = Data.define(:protocol, :publication, :generation, :recovered) do
+      # @dynamic emit, with_lifecycle_lock, broadcast?
+      # Captures the subscription generation alongside an immutable publication.
+      PublicationContext = Data.define(:protocol, :publication, :generation, :recovered)
+
+      # Freezes the publication before callbacks can observe or modify it.
+      class PublicationContext
+        # @dynamic protocol, publication, generation, recovered
         def initialize(protocol:, publication:, generation:, recovered:)
-          super(protocol:, publication: Immutable.call(publication), generation:, recovered:)
+          publication = Immutable.call(publication)
+          super
         end
       end
       private_constant :PublicationContext
@@ -30,6 +37,14 @@ module Volcano
         PublicationContext.new(protocol:, publication:, generation:, recovered:)
       end
 
+      def publication_rejection(protocol, generation)
+        return unless broadcast?
+
+        lambda do |publication|
+          reject_broadcast(publication_context(protocol, publication, generation, false))
+        end
+      end
+
       def reject_broadcast(context)
         with_current_publication(context) do
           context.protocol.__send__(:drop_publication, @name, context.publication)
@@ -57,6 +72,15 @@ module Volcano
         @publication_protocol.__send__(:delete_recovery_state, @name)
         @publication_protocol = nil
       end
+
+      def clear_channel_recovery_state
+        return unless broadcast?
+
+        # @type var position: Hash[Symbol, String | Integer]
+        position = {}
+        @recovery_position = position.freeze
+        @recovery_lineage = nil
+      end
     end
     private_constant :BroadcastDelivery
   end

data/lib/volcano/realtime/channel_callbacks.rb

@@ -4,6 +4,9 @@ module Volcano
   class Realtime
     # Registers channel callbacks and connects them to protocol pushes.
     module ChannelCallbacks
+      # @dynamic presence?, postgres?, broadcast?, register_presence_handler, detach_presence_handler
+      # @dynamic deliver_broadcast, publication_context, reject_broadcast, publication_rejection
+      # @dynamic dispatch_postgres_change
       def on(event, callback = nil, &block)
         raise ArgumentError, "unsupported realtime event: #{event}" unless allowed_event?(event)
 
@@ -37,21 +40,21 @@ module Volcano
         generation = @publication_generation
         @publication_protocol = protocol if broadcast?
         @publication_handler = protocol.on_publication(
-          @name, on_rejection: publication_rejection(protocol, generation)
-        ) do |event, data, publication, recovered:|
-          next deliver_publication(event, data) unless broadcast?
-
-          context = publication_context(protocol, publication, generation, recovered)
-          deliver_broadcast(event, data, context)
-        end
+          @name, on_rejection: publication_rejection(protocol, generation),
+          &publication_callback(protocol, generation)
+        )
         @handler_registered = true
       end
 
-      def publication_rejection(protocol, generation)
-        return unless broadcast?
-
-        lambda do |publication|
-          reject_broadcast(publication_context(protocol, publication, generation, false))
+      def publication_callback(protocol, generation)
+        lambda do |event, data, publication, recovered:|
+          # @type var recovered: bool
+          if broadcast?
+            context = publication_context(protocol, publication, generation, recovered)
+            deliver_broadcast(event, data, context)
+          else
+            deliver_publication(event, data)
+          end
         end
       end
 
@@ -67,6 +70,7 @@ module Volcano
         callbacks = @callbacks[event].dup
         return if callbacks.empty?
 
+        # @type var delivery: delivery
         delivery = [event, data, callbacks, before_delivery]
         return defer_callback_delivery(delivery) if callback_dispatching?
 
@@ -109,8 +113,9 @@ module Volcano
       end
 
       def detach_publication_handler(protocol)
-        if @publication_handler
-          protocol.off_publication(@name, @publication_handler)
+        handler = @publication_handler
+        if handler
+          protocol.off_publication(@name, handler)
           @publication_generation += 1 if broadcast?
         end
         detach_presence_handler(protocol)

data/lib/volcano/realtime/channel_lifecycle.rb

@@ -4,6 +4,9 @@ module Volcano
   class Realtime
     # Coordinates a channel's protocol subscription and local lifecycle state.
     module ChannelLifecycle
+      # @dynamic end_postgres_delivery, reset_presence, detach_publication_handler, ensure_open!
+      # @dynamic broadcast?, next_presence_epoch, register_handlers, begin_postgres_delivery
+      # @dynamic invalidate_presence_subscription, clear_presence, presence?
       def mark_closed
         @closed = true
         @subscription_desired = @subscribed = false
@@ -84,14 +87,18 @@ module Volcano
         return unless broadcast?
 
         _, lineage, = @realtime.__send__(:capture_protocol_session)
-        [lineage, recovery_position(lineage)].freeze
+        # @type var binding: recovery_binding
+        binding = [lineage, recovery_position(lineage)]
+        binding.freeze
       end
 
       def recovery_position(lineage)
         return @recovery_position if @recovery_lineage == lineage
 
         @recovery_lineage = lineage
-        @recovery_position = {}.freeze
+        # @type var position: recovery_position
+        position = {}
+        @recovery_position = position.freeze
       end
 
       def validate_recovery_binding!(binding)
@@ -113,13 +120,6 @@ module Volcano
         @recovery_position = protocol.__send__(:position, @name) || @recovery_position
       end
 
-      def clear_channel_recovery_state
-        return unless broadcast?
-
-        @recovery_position = {}.freeze
-        @recovery_lineage = nil
-      end
-
       def mark_removed
         @callbacks.each_value(&:clear)
         @handler_registered = @subscription_desired = @subscribed = false

data/lib/volcano/realtime/connection.rb

@@ -4,6 +4,9 @@ module Volcano
   class Realtime
     # Opens the WebSocket transport and maps its failures to public errors.
     module Connection
+      # @dynamic protocol_connected, protocol_error, protocol_closed, protocol_error_started
+      # @dynamic protocol_failed, stop_reconnect
+
       private
 
       def connect_protocol
@@ -71,9 +74,9 @@ module Volcano
           socket: socket,
           secrets: realtime_secrets,
           events: Protocol::Events.new(
-            on_close: method(:protocol_closed),
-            on_error: method(:protocol_error_started),
-            on_failure: method(:protocol_failed)
+            on_close: ->(error) { protocol_closed(error) },
+            on_error: ->(error) { protocol_error_started(error) },
+            on_failure: ->(error, disconnected) { protocol_failed(error, disconnected) }
           )
         )
       end
@@ -87,7 +90,7 @@ module Volcano
       def address
         uri = URI(@api_url)
         uri.scheme = uri.scheme == 'https' ? 'wss' : 'ws'
-        uri.path = "#{uri.path.delete_suffix('/')}/realtime/v1/websocket"
+        uri.path = "#{uri.path.to_s.delete_suffix('/')}/realtime/v1/websocket"
         encoded_key = URI.encode_www_form_component(@client.anon_token).gsub('+', '%20')
         uri.query = "apikey=#{encoded_key}"
         uri.to_s
@@ -106,7 +109,8 @@ module Volcano
         return redacted unless Transport::NETWORK_ERRORS.any? { |type| error.is_a?(type) }
 
         transport_error = Error::TransportError.new(redacted.message)
-        transport_error.set_backtrace(redacted.backtrace)
+        trace = redacted.backtrace
+        transport_error.set_backtrace(trace) if trace
         transport_error
       end
     end

data/lib/volcano/realtime/connection_callbacks.rb

@@ -4,6 +4,7 @@ module Volcano
   class Realtime
     # Registers and dispatches public connection lifecycle callbacks.
     module ConnectionCallbacks
+      # @dynamic start_reconnect
       def on_connect(callback = nil, &block) = register_connection_callback(:connect, callback, block)
       def on_disconnect(callback = nil, &block) = register_connection_callback(:disconnect, callback, block)
       def on_error(callback = nil, &block) = register_connection_callback(:error, callback, block)
@@ -76,6 +77,7 @@ module Volcano
 
       def protocol_failed(error, disconnected)
         reset_after_protocol_loss if disconnected
+        # @type var events: Array[[connection_event, connection_context]]
         events = [[:error, error_context(error)]]
         events << [:disconnect, disconnect_context(error)] if disconnected
         emit_connection_events(events)
@@ -84,8 +86,10 @@ module Volcano
 
       def error_context(error)
         snapshot = immutable_exception(error)
+        code = snapshot.respond_to?(:code) ? snapshot.method(:code).call : nil
+        code = nil unless code.is_a?(String) || code.is_a?(Integer)
         ErrorContext.new(
-          code: snapshot.respond_to?(:code) ? snapshot.code : nil,
+          code: code,
           message: immutable_string(snapshot.message), error: snapshot
         )
       end

data/lib/volcano/realtime/lifecycle.rb

@@ -4,6 +4,7 @@ module Volcano
   class Realtime
     # Channel collection and connection-state lifecycle operations.
     module Lifecycle
+      # @dynamic channel_lock, normalize_channel_type
       def connected? = !@closed && (@protocol&.connected? || false)
 
       def remove_channel(name, type: :broadcast)
@@ -26,7 +27,7 @@ module Volcano
       private
 
       def remove_channel_locked(name)
-        channel = @channels[name]
+        channel = @channels.fetch(name, nil)
         return unless channel
 
         channel.__send__(:remove)

data/lib/volcano/realtime/postgres_batch.rb

@@ -2,9 +2,14 @@
 
 module Volcano
   class Realtime
+    # Immutable limits for one channel's automatic row-fetch queue.
     PostgresBatchConfig = Data.define(
       :auto_fetch, :batch_window_ms, :max_batch_size
-    ) do
+    )
+
+    # Validates the queue limits supplied to a Postgres channel.
+    class PostgresBatchConfig
+      # @dynamic auto_fetch, batch_window_ms, max_batch_size
       def initialize(auto_fetch:, batch_window_ms:, max_batch_size:)
         unless batch_window_ms.is_a?(Integer) && batch_window_ms.positive?
           raise ArgumentError, 'fetch_batch_window_ms must be a positive integer'
@@ -20,6 +25,8 @@ module Volcano
 
     # Collects compatible row lookups and preserves their callback order.
     module PostgresBatch
+      # @dynamic postgres_stop?, current_postgres_request?, expanded_postgres_changes, emit
+
       private
 
       def collect_postgres_batch(first)
@@ -35,6 +42,7 @@ module Volcano
         while requests.length < @postgres_batch_config.max_batch_size
           request = dequeue_postgres_before(deadline)
           return unless request
+          return request unless request.is_a?(PostgresDeliveryRequest)
           return request unless compatible_postgres_request?(requests.first, request)
 
           requests << request
@@ -72,8 +80,8 @@ module Volcano
         return unless current_postgres_request?(requests.first)
 
         changes = expanded_postgres_changes(requests)
-        requests.zip(changes).each do |request, change|
-          deliver_expanded_postgres_change(request, change)
+        requests.each_with_index do |request, index|
+          deliver_expanded_postgres_change(request, changes.fetch(index))
         end
       end
 

data/lib/volcano/realtime/postgres_changes.rb

@@ -4,23 +4,34 @@ module Volcano
   class Realtime
     PostgresChange = Data.define(
       :type, :schema, :table, :record, :old_record, :columns, :timestamp, :id, :mode
-    ) do
-      def initialize(
-        type:, schema:, table:, timestamp:, record: nil, old_record: nil, columns: nil,
-        id: nil, mode: nil
-      )
-        super(
-          type: Immutable.call(type.to_s), schema: Immutable.call(schema.to_s),
-          table: Immutable.call(table.to_s), record: Immutable.optional(record),
-          old_record: Immutable.optional(old_record),
-          columns: Immutable.optional(columns), timestamp: Immutable.call(timestamp.to_s),
-          id: Immutable.optional(id), mode: mode && Immutable.call(mode.to_s)
-        )
+    )
+
+    # Immutable snapshot of a Postgres change publication.
+    class PostgresChange
+      # @dynamic type, schema, table, record, old_record, columns, timestamp, id, mode
+      # @dynamic members, with, to_h, deconstruct, deconstruct_keys, self.[], self.members
+      def initialize(type:, schema:, table:, timestamp:, **payload)
+        type = Immutable.call(type.to_s)
+        schema = Immutable.call(schema.to_s)
+        table = Immutable.call(table.to_s)
+        timestamp = Immutable.call(timestamp.to_s)
+        payload = snapshot_payload(payload)
+        super
+      end
+
+      private
+
+      def snapshot_payload(payload)
+        payload = { record: nil, old_record: nil, columns: nil, id: nil, mode: nil }.merge(payload)
+        %i[record old_record columns id].each { |field| payload[field] = Immutable.optional(payload[field]) }
+        payload[:mode] &&= Immutable.call(payload[:mode].to_s)
+        payload
       end
     end
 
     # Registers filtered callbacks for Postgres change publications.
     module PostgresChanges
+      # @dynamic on, enqueue_postgres_delivery
       CHANGE_EVENTS = %w[INSERT UPDATE DELETE].freeze
       EVENTS = [*CHANGE_EVENTS, '*'].freeze
 
@@ -41,7 +52,7 @@ module Volcano
       end
 
       def postgres_change(data)
-        return unless valid_postgres_change?(data)
+        return unless data.is_a?(Hash) && valid_postgres_change?(data)
 
         PostgresChange.new(
           type: data.fetch('type'), schema: data.fetch('schema'), table: data.fetch('table'),
@@ -58,7 +69,10 @@ module Volcano
       end
 
       def register_postgres_listener(event, schema, table, handler)
-        filtered = proc { |change| handler.call(change) if change.schema == schema && change.table == table }
+        # @type var filtered: ^(Object?) -> void
+        filtered = lambda do |change|
+          handler.call(change) if change.is_a?(PostgresChange) && change.schema == schema && change.table == table
+        end
         @postgres_filters[filtered] = [event, schema, table]
         on(event, filtered)
       end
@@ -77,7 +91,7 @@ module Volcano
       end
 
       def valid_postgres_change?(data)
-        valid_postgres_identity?(data) && valid_postgres_payload?(data)
+        data.is_a?(Hash) && valid_postgres_identity?(data) && valid_postgres_payload?(data)
       end
 
       def valid_postgres_identity?(data)
@@ -87,8 +101,9 @@ module Volcano
       end
 
       def valid_postgres_payload?(data)
+        mode = data['mode']
         optional_hash?(data['record']) && optional_hash?(data['old_record']) &&
-          optional_array?(data['columns']) && [nil, 'lightweight'].include?(data['mode'])
+          optional_array?(data['columns']) && (mode.nil? || mode == 'lightweight')
       end
 
       def optional_hash?(value) = value.nil? || value.is_a?(Hash)

data/lib/volcano/realtime/postgres_database.rb

@@ -10,6 +10,8 @@ module Volcano
 
       attr_reader :database_name
 
+      # @dynamic database_name
+
       def database_name=(name)
         unless valid_database_name?(name)
           raise ArgumentError,
@@ -48,12 +50,23 @@ module Volcano
 
       def fetch_postgres_rows(change, ids, database_name, access_token)
         table = change.schema == 'public' ? change.table : "#{change.schema}.#{change.table}"
-        postgres_fetch_semaphore.acquire do
+        rows = postgres_fetch_semaphore.acquire do
           BlockingCall.call do
             @client.__send__(:database_with_token, database_name, access_token)
                    .from(table).select('*').in('id', ids).execute
           end
         end
+        validate_postgres_rows(rows)
+      end
+
+      def validate_postgres_rows(rows)
+        raise TypeError, 'Postgres row lookup must return an array' unless rows.is_a?(Array)
+
+        rows.map do |row|
+          raise TypeError, 'Postgres row lookup must return objects' unless row.is_a?(Hash)
+
+          row
+        end
       end
 
       def postgres_fetch_semaphore

data/lib/volcano/realtime/postgres_delivery.rb

@@ -9,6 +9,7 @@ module Volcano
 
     # Serializes Postgres publications and expands lightweight row identities.
     module PostgresDelivery
+      # @dynamic postgres?, collect_postgres_batch, deliver_postgres_batch
       QUEUE_LIMIT = 128
       STOP = Object.new.freeze
       private_constant :QUEUE_LIMIT, :STOP
@@ -18,7 +19,9 @@ module Volcano
       def initialize_postgres_delivery(batch_config)
         require 'async/queue'
         @postgres_batch_config = batch_config
-        @postgres_filters = {}
+        # @type var empty_filters: Hash[^(Object?) -> void, [String, String, String]]
+        empty_filters = {}
+        @postgres_filters = empty_filters
         @postgres_queue = Async::LimitedQueue.new(QUEUE_LIMIT)
         @postgres_worker = nil
         @postgres_epoch = 0
@@ -88,10 +91,12 @@ module Volcano
       end
 
       def run_postgres_worker
+        # @type var pending: Object?
         pending = nil
         loop do
           request = pending || @postgres_queue.dequeue
           break if postgres_stop?(request)
+          raise TypeError, 'invalid Postgres delivery request' unless request.is_a?(PostgresDeliveryRequest)
 
           requests, pending = collect_postgres_batch(request)
           deliver_postgres_batch(requests)

data/lib/volcano/realtime/postgres_expansion.rb

@@ -4,6 +4,8 @@ module Volcano
   class Realtime
     # Expands lightweight Postgres identities into callback-ready changes.
     module PostgresExpansion
+      # @dynamic current_postgres_request?, postgres_batch_key
+
       private
 
       def expanded_postgres_changes(requests)
@@ -26,12 +28,16 @@ module Volcano
 
       def fetch_postgres_records(requests)
         request = requests.first
+        database_name = request.database_name
+        lineage = request.session_lineage
+        raise TypeError, 'invalid Postgres fetch request' unless database_name && lineage.is_a?(SessionOperations)
+
         access_token = @realtime.__send__(
-          :access_token_for_protocol_lineage, request.session_lineage
+          :access_token_for_protocol_lineage, lineage
         )
         rows = @realtime.__send__(
           :fetch_postgres_rows, request.change, postgres_ids(requests),
-          request.database_name, access_token
+          database_name, access_token
         )
         rows.to_h { |row| [row.fetch('id').to_s, row] }
       end
@@ -41,7 +47,7 @@ module Volcano
       end
 
       def expanded_postgres_record(request, records)
-        record = records[request.change.id.to_s]
+        record = records.fetch(request.change.id.to_s, nil)
         unless record
           report_postgres_fetch_error(request, Error::NotFoundError.new('Postgres row not found'))
           return request.change
@@ -55,7 +61,7 @@ module Volcano
       end
 
       def delete_postgres_change(change)
-        old_record = change.old_record || (change.id && { 'id' => change.id })
+        old_record = change.old_record || (change.id ? { 'id' => change.id } : nil)
         change.with(old_record:, id: nil, mode: nil)
       end