solid_objects 0.10.3 → 0.12.0

data/lib/solid_objects/actor.rb

@@ -2,10 +2,10 @@
 
 module SolidObjects
   class Actor
-    EffectIntent = Data.define(:name, :arguments, :success_message_name, :failure_message_name)
+    EffectIntent = Data.define(:name, :arguments, :success_operation, :failure_operation)
     CommitActionIntent = Data.define(:name, :arguments)
     ReminderIntent = Data.define(:name, :at, :arguments, :interval_seconds, :missed_policy)
-    OutboundMessageIntent = Data.define(:actor_type, :actor_id, :message_name, :arguments, :available_at, :idempotency_key)
+    OutboundMessageIntent = Data.define(:actor_type, :actor_id, :operation, :arguments, :available_at, :idempotency_key)
 
     class << self
       # @rbs (Class) -> void
@@ -72,7 +72,7 @@ module SolidObjects
 
       # @rbs (from: Integer, to: Integer) { (Hash[String, untyped]) -> Hash[String, untyped] } -> ActorDefinition::StateMigration
       def migrate_state(from:, to:, &block)
-        definition.add_state_migration(from, to, block)
+        definition.add_state_migration(from:, to:, block:)
       end
 
       # @rbs () { () -> untyped } -> Proc
@@ -177,8 +177,8 @@ module SolidObjects
       EffectIntent.new(
         name: name.to_s,
         arguments: Serialization.dump(arguments),
-        success_message_name: on_success&.to_s,
-        failure_message_name: on_failure&.to_s
+        success_operation: on_success&.to_s,
+        failure_operation: on_failure&.to_s
       ).tap do |intent|
         effect_intents << intent
       end
@@ -196,8 +196,8 @@ module SolidObjects
       nil
     end
 
-    # @rbs (Symbol | String, at: Time, ?every: Numeric?, ?missed: Symbol | String, arguments: Hash[Symbol | String, untyped]) -> nil
-    def schedule(name, at:, every: nil, missed: :latest, arguments: {})
+    # @rbs (at: Time, ?every: Numeric?, ?missed: Symbol | String) -> OperationDispatcher
+    def schedule(at:, every: nil, missed: :latest)
       interval_seconds = every&.to_f
       if interval_seconds && !interval_seconds.positive?
         raise ArgumentError, "reminder interval must be positive"
@@ -207,31 +207,42 @@ module SolidObjects
         raise ArgumentError, "missed reminder policy must be all or latest"
       end
 
-      ReminderIntent.new(
-        name: name.to_s,
-        at:,
-        arguments: Serialization.dump(arguments),
-        interval_seconds:,
-        missed_policy:
-      ).tap do |intent|
-        reminder_intents << intent
+      OperationDispatcher.new(
+        actor_type: self.class.actor_type,
+        handlers: self.class.definition.messages
+      ) do |operation, arguments|
+        ReminderIntent.new(
+          name: operation.to_s,
+          at:,
+          arguments: Serialization.dump(arguments),
+          interval_seconds:,
+          missed_policy:
+        ).tap do |intent|
+          reminder_intents << intent
+        end
+        nil
       end
-      nil
     end
 
-    # @rbs (Reference, Symbol | String, ?available_at: Time?, ?idempotency_key: String?, **untyped) -> nil
-    def send_to(reference, message_name, available_at: nil, idempotency_key: nil, **arguments)
-      stage_outbound_message(reference, message_name, arguments, available_at:, idempotency_key:)
-      nil
+    # @rbs (Reference, ?available_at: Time?, ?idempotency_key: String?) -> OperationDispatcher
+    def send_to(reference, available_at: nil, idempotency_key: nil)
+      actor_class = SolidObjects.registry.fetch(reference.actor_type)
+      OperationDispatcher.new(
+        actor_type: reference.actor_type,
+        handlers: actor_class.definition.messages
+      ) do |operation, arguments|
+        stage_outbound_message(reference:, operation:, arguments:, available_at:, idempotency_key:)
+        nil
+      end
     end
 
     # @rbs (Symbol | String, Hash[String, untyped]) -> untyped
-    def invoke(message_name, arguments)
-      handler = self.class.definition.messages[message_name.to_sym] ||
-        self.class.definition.queries[message_name.to_sym]
-      raise UnknownMessage, "unknown message #{message_name.inspect} for #{self.class.actor_type}" unless handler
+    def invoke(operation, arguments)
+      handler = self.class.definition.messages[operation.to_sym] ||
+        self.class.definition.queries[operation.to_sym]
+      raise UnknownMessage, "unknown operation #{operation.inspect} for #{self.class.actor_type}" unless handler
 
-      guard_application_writes(message_name.to_s) do
+      guard_application_writes(operation.to_s) do
         instance_exec(**keyword_arguments(arguments), &handler.block)
       end
     end
@@ -270,12 +281,12 @@ module SolidObjects
       end
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
-    def stage_outbound_message(reference, message_name, arguments, available_at: nil, idempotency_key: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, idempotency_key: String?) -> OutboundMessageIntent
+    def stage_outbound_message(reference:, operation:, arguments:, available_at: nil, idempotency_key: nil)
       OutboundMessageIntent.new(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s,
+        operation: operation.to_s,
         arguments: Serialization.dump(arguments),
         available_at:,
         idempotency_key:
@@ -333,11 +344,11 @@ module SolidObjects
     end
 
     # @rbs (Symbol | String?) -> void
-    def validate_effect_callback!(message_name)
-      return unless message_name
-      return if self.class.definition.messages.key?(message_name.to_sym)
+    def validate_effect_callback!(operation)
+      return unless operation
+      return if self.class.definition.messages.key?(operation.to_sym)
 
-      raise UnknownMessage, "unknown effect callback message #{message_name.inspect}"
+      raise UnknownMessage, "unknown effect callback operation #{operation.inspect}"
     end
   end
 end

data/lib/solid_objects/actor_channel.rb

@@ -32,9 +32,9 @@ module SolidObjects
       snapshot = ActorSnapshot.new(reference)
       scalar_observable_names(snapshot).each do |name|
         transmit TurboStreamRenderer.observable_value(
-          reference,
-          name,
-          snapshot.observable_value(name)
+          reference:,
+          name:,
+          value: snapshot.observable_value(name)
         )
       end
       refresh_outdated_components(snapshot)

data/lib/solid_objects/actor_definition.rb

@@ -45,6 +45,7 @@ module SolidObjects
     # @rbs (Symbol | String, default: untyped) -> StateDefinition::Attribute
     def add_attribute(name, default:)
       attribute_name = name.to_sym
+      OperationDispatcher.validate_operation_name!(attribute_name)
       if messages.key?(attribute_name) || queries.key?(attribute_name)
         raise InvalidActor, "#{attribute_name.inspect} is already defined"
       end
@@ -60,7 +61,7 @@ module SolidObjects
 
     # @rbs (Symbol | String, Proc) -> Handler
     def add_message(name, block)
-      add_handler(messages, name, block)
+      add_handler(collection: messages, name:, block:)
     end
 
     # @rbs (Symbol | String, Proc) -> Handler
@@ -72,7 +73,7 @@ module SolidObjects
         end
       end
 
-      add_handler(queries, name, block)
+      add_handler(collection: queries, name:, block:)
     end
 
     # @rbs (Symbol | String, Proc?) -> Handler
@@ -121,8 +122,8 @@ module SolidObjects
       @state_version = version
     end
 
-    # @rbs (Integer, Integer, Proc) -> StateMigration
-    def add_state_migration(from, to, block)
+    # @rbs (from: Integer, to: Integer, block: Proc) -> StateMigration
+    def add_state_migration(from:, to:, block:)
       unless to == from + 1
         raise InvalidActor, "state migrations must advance exactly one version"
       end
@@ -183,6 +184,7 @@ module SolidObjects
 
     # @rbs (Symbol) -> Handler
     def add_method_message(name)
+      OperationDispatcher.validate_operation_name!(name)
       if messages.key?(name) || queries.key?(name)
         raise InvalidActor, "#{name.inspect} is already defined"
       end
@@ -222,9 +224,10 @@ module SolidObjects
       end
     end
 
-    # @rbs (Hash[Symbol, Handler], Symbol | String, Proc) -> Handler
-    def add_handler(collection, name, block)
+    # @rbs (collection: Hash[Symbol, Handler], name: Symbol | String, block: Proc) -> Handler
+    def add_handler(collection:, name:, block:)
       handler_name = name.to_sym
+      OperationDispatcher.validate_operation_name!(handler_name)
       raise InvalidActor, "#{handler_name.inspect} is already defined" if messages.key?(handler_name) || queries.key?(handler_name)
 
       Handler.new(name: handler_name, block:).tap { |handler| collection[handler_name] = handler }

data/lib/solid_objects/actor_view.rb

@@ -154,7 +154,7 @@ module SolidObjects
       authorized = SolidObjects.configuration.authorize_query.call(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: name.to_s,
+        operation: name.to_s,
         arguments: {},
         authorization_context:
       )

data/lib/solid_objects/application_write_guard.rb

@@ -16,7 +16,7 @@ module SolidObjects
         raise ApplicationWriteForbidden.new(
           actor_type:,
           actor_id:,
-          message_name: operation
+          operation:
         )
       end
     end

data/lib/solid_objects/client.rb

@@ -12,50 +12,50 @@ module SolidObjects
       @mailbox = mailbox
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
-    def async(reference, message_name, arguments, available_at: nil, idempotency_key: nil, authorization_context: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> MessageReference
+    def async(reference:, operation:, arguments:, available_at: nil, idempotency_key: nil, authorization_context: nil)
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      message_symbol = message_name.to_sym
-      raise UnknownMessage, "unknown message #{message_name.inspect}" unless actor_class.definition.messages.key?(message_symbol)
+      operation_symbol = operation.to_sym
+      raise UnknownMessage, "unknown operation #{operation.inspect}" unless actor_class.definition.messages.key?(operation_symbol)
 
       authorize!(
-        SolidObjects.configuration.authorize_message,
-        reference,
-        message_name,
-        arguments,
+        hook: SolidObjects.configuration.authorize_message,
+        reference:,
+        operation:,
+        arguments:,
         authorization_context:
       )
       mailbox.enqueue(
-        reference,
-        message_name,
-        arguments,
-        kind: "async",
+        reference:,
+        operation:,
+        arguments:,
+        delivery_mode: "async",
         available_at:,
         idempotency_key:
       )
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
-    def sync(reference, message_name, arguments, timeout:, idempotency_key: nil, authorization_context: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> untyped
+    def sync(reference:, operation:, arguments:, timeout:, idempotency_key: nil, authorization_context: nil)
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      message_symbol = message_name.to_sym
-      query = actor_class.definition.queries.key?(message_symbol)
-      actor_message = actor_class.definition.messages.key?(message_symbol)
-      raise UnknownMessage, "unknown message #{message_name.inspect}" unless query || actor_message
+      operation_symbol = operation.to_sym
+      query = actor_class.definition.queries.key?(operation_symbol)
+      actor_message = actor_class.definition.messages.key?(operation_symbol)
+      raise UnknownMessage, "unknown operation #{operation.inspect}" unless query || actor_message
 
       authorize!(
-        query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
-        reference,
-        message_name,
-        arguments,
+        hook: query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
+        reference:,
+        operation:,
+        arguments:,
         authorization_context:
       )
-      reject_sync_inside_transaction!(reference, message_name)
+      reject_sync_inside_transaction!(reference, operation)
       SyncDeadline.with(timeout:) do
         message_reference = enqueue_sync(
-          reference,
-          message_name,
-          arguments,
+          reference:,
+          operation:,
+          arguments:,
           idempotency_key:,
           timeout:
         )
@@ -75,19 +75,19 @@ module SolidObjects
           actor_id: message.actor_id
         )
         actor_class = SolidObjects.registry.fetch(reference.actor_type)
-        query = actor_class.definition.queries.key?(message.message_name.to_sym)
-        actor_message = actor_class.definition.messages.key?(message.message_name.to_sym)
+        query = actor_class.definition.queries.key?(message.operation.to_sym)
+        actor_message = actor_class.definition.messages.key?(message.operation.to_sym)
         unless query || actor_message
-          raise UnknownMessage, "unknown message #{message.message_name.inspect}"
+          raise UnknownMessage, "unknown operation #{message.operation.inspect}"
         end
         authorize!(
-          query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
-          reference,
-          message.message_name,
-          message.arguments,
+          hook: query ? SolidObjects.configuration.authorize_query : SolidObjects.configuration.authorize_message,
+          reference:,
+          operation: message.operation,
+          arguments: message.arguments,
           authorization_context:
         )
-        reject_sync_inside_transaction!(reference, message.message_name)
+        reject_sync_inside_transaction!(reference, message.operation)
         SynchronousInvocation.new.call(message_reference, timeout:)
       end
     rescue DatabaseDeadlineExceeded
@@ -98,10 +98,10 @@ module SolidObjects
     def snapshot(reference, authorization_context: nil)
       SolidObjects.registry.fetch(reference.actor_type)
       authorize!(
-        SolidObjects.configuration.authorize_query,
-        reference,
-        "__snapshot__",
-        {},
+        hook: SolidObjects.configuration.authorize_query,
+        reference:,
+        operation: "__snapshot__",
+        arguments: {},
         authorization_context:
       )
       StateSnapshot.new(reference)
@@ -140,13 +140,13 @@ module SolidObjects
 
     attr_reader :mailbox
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
-    def enqueue_sync(reference, message_name, arguments, idempotency_key:, timeout:)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], idempotency_key: String?, timeout: Numeric) -> MessageReference
+    def enqueue_sync(reference:, operation:, arguments:, idempotency_key:, timeout:)
       mailbox.enqueue(
-        reference,
-        message_name,
-        arguments,
-        kind: "sync",
+        reference:,
+        operation:,
+        arguments:,
+        delivery_mode: "sync",
         idempotency_key:
       )
     rescue DatabaseDeadlineExceeded
@@ -154,13 +154,13 @@ module SolidObjects
         :"sync.enqueue_timeout",
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
       raise SyncEnqueueTimeout.new(
         timeout:,
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
     end
 
@@ -176,28 +176,28 @@ module SolidObjects
     end
 
     # @rbs (Reference, Symbol | String) -> void
-    def reject_sync_inside_transaction!(reference, message_name)
+    def reject_sync_inside_transaction!(reference, operation)
       return unless SolidObjects::Record.connection.transaction_open?
 
       SolidObjects.instrument(
         :"sync.transaction_rejected",
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
       raise SyncInsideTransaction.new(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s
+        operation: operation.to_s
       )
     end
 
-    # @rbs (Proc, Reference, Symbol | String, Hash[Symbol | String, untyped], authorization_context: untyped) -> void
-    def authorize!(hook, reference, message_name, arguments, authorization_context:)
+    # @rbs (hook: Proc, reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], authorization_context: untyped) -> void
+    def authorize!(hook:, reference:, operation:, arguments:, authorization_context:)
       authorized = hook.call(
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s,
+        operation: operation.to_s,
         arguments:,
         authorization_context:
       )

data/lib/solid_objects/component_registration.rb

@@ -156,8 +156,8 @@ module SolidObjects
       locals.merge("component_key" => component_key).freeze
     end
 
-    # @rbs (Array[ComponentRegistration], Integer, Integer) -> String
-    def batch_refresh_url(registrations, instance_id, revision)
+    # @rbs (registrations: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> String
+    def batch_refresh_url(registrations:, instance_id:, revision:)
       query = URI.encode_www_form(
         [
           [ "instance_id", instance_id ],

data/lib/solid_objects/component_renderer.rb

@@ -60,7 +60,7 @@ module SolidObjects
       authorized = SolidObjects.configuration.authorize_query.call(
         actor_type: snapshot.reference.actor_type,
         actor_id: snapshot.reference.actor_id,
-        message_name: observable_name,
+        operation: observable_name,
         arguments: registration.authorization_arguments,
         authorization_context:
       )

data/lib/solid_objects/component_subscriptions.rb

@@ -50,21 +50,21 @@ module SolidObjects
       revision = invalidation.fetch("revision")
       changed = registrations.select do |registration|
         registration.dependencies.include?(observable_name) &&
-          newer_revision?(registration.dom_id, instance_id, revision)
+          newer_revision?(dom_id: registration.dom_id, instance_id:, revision:)
       end
-      refresh_streams(changed, instance_id, revision)
+      refresh_streams(changed:, instance_id:, revision:)
     end
 
     # @rbs (ActorSnapshot) -> Array[String]
     def reconnect_refreshes(snapshot)
       stale = registrations.select do |registration|
         newer_revision?(
-          registration.dom_id,
-          snapshot.instance_id,
-          snapshot.revision
+          dom_id: registration.dom_id,
+          instance_id: snapshot.instance_id,
+          revision: snapshot.revision
         )
       end
-      refresh_streams(stale, snapshot.instance_id, snapshot.revision)
+      refresh_streams(changed: stale, instance_id: snapshot.instance_id, revision: snapshot.revision)
     end
 
     class << self
@@ -86,36 +86,36 @@ module SolidObjects
 
     # Live invalidations and reconnect replays share this, so a reconnecting
     # client pays the same number of requests a connected one does.
-    # @rbs (Array[ComponentRegistration], Integer, Integer) -> Array[String]
-    def refresh_streams(changed, instance_id, revision)
+    # @rbs (changed: Array[ComponentRegistration], instance_id: Integer, revision: Integer) -> Array[String]
+    def refresh_streams(changed:, instance_id:, revision:)
       batched, individual = changed.partition(&:batch)
       streams = individual.map do |registration|
-        refresh(registration, instance_id, revision)
+        refresh(registration:, instance_id:, revision:)
       end
       batched.group_by(&:batch).each_value do |group|
-        group.each { |registration| record_revision(registration, instance_id, revision) }
-        streams << TurboStreamRenderer.batch_refresh(group, instance_id, revision)
+        group.each { |registration| record_revision(registration:, instance_id:, revision:) }
+        streams << TurboStreamRenderer.batch_refresh(registrations: group, instance_id:, revision:)
       end
       streams
     end
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> void
-    def record_revision(registration, instance_id, revision)
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> void
+    def record_revision(registration:, instance_id:, revision:)
       revisions[registration.dom_id] = [ instance_id, revision ]
     end
 
-    # @rbs (ComponentRegistration, Integer, Integer) -> String
-    def refresh(registration, instance_id, revision)
-      record_revision(registration, instance_id, revision)
+    # @rbs (registration: ComponentRegistration, instance_id: Integer, revision: Integer) -> String
+    def refresh(registration:, instance_id:, revision:)
+      record_revision(registration:, instance_id:, revision:)
       TurboStreamRenderer.component_refresh(
-        registration,
-        instance_id,
-        revision
+        registration:,
+        instance_id:,
+        revision:
       )
     end
 
-    # @rbs (String, Integer, Integer) -> bool
-    def newer_revision?(dom_id, instance_id, revision)
+    # @rbs (dom_id: String, instance_id: Integer, revision: Integer) -> bool
+    def newer_revision?(dom_id:, instance_id:, revision:)
       current = revisions.fetch(dom_id)
       (current <=> [ instance_id, revision ]) == -1
     end

data/lib/solid_objects/configuration.rb

@@ -92,6 +92,9 @@ module SolidObjects
       :authorize_subscription,
       :authorize_administration
 
+    # @rbs @additional_components: Array[untyped]
+    attr_reader :additional_components
+
     # @rbs () -> void
     def initialize
       @table_name_prefix = "solid_objects_"
@@ -142,6 +145,45 @@ module SolidObjects
       @authorize_destroy = ->(**) { false }
       @authorize_subscription = ->(**) { false }
       @authorize_administration = ->(**) { false }
+      @additional_components = []
+    end
+
+    # Registers a long running component that the supervisor runs beside its own
+    # workers. An extension gem uses this to share one process, rather than ask
+    # an operator to run and monitor a second one.
+    #
+    # The block must return an object that answers `run`, `request_shutdown`,
+    # `stopped?`, and `stop`, which is the contract the built in components
+    # already keep. The supervisor calls the block once for each supervisor it
+    # builds, and again when it replaces a crashed component, so two
+    # supervisors never share one component instance.
+    #
+    # @rbs (?count: Integer) { () -> untyped } -> void
+    def register_component(count: 1, &factory)
+      raise ArgumentError, "register_component requires a block" unless factory
+      raise ArgumentError, "count must be positive" unless count.positive?
+
+      count.times { @additional_components << factory }
+    end
+
+    # The supervisor checks the contract here rather than at registration,
+    # because a component often needs a database connection to exist, and
+    # registration happens while the application boots.
+    # @rbs () -> Array[untyped]
+    def build_additional_components
+      additional_components.map { |factory| factory.call.tap { |component| validate_component!(component) } }
+    end
+
+    # A component that misses part of the contract would hang the supervisor at
+    # shutdown, or crash the moment it starts. The build fails instead, where
+    # the caller can read the reason.
+    # @rbs (untyped) -> void
+    def validate_component!(component)
+      %i[run request_shutdown stopped? stop].each do |method_name|
+        next if component.respond_to?(method_name)
+
+        raise ArgumentError, "a registered component must respond to #{method_name}"
+      end
     end
 
     # @rbs () -> self

data/lib/solid_objects/database_adapters/sqlite.rb

@@ -141,7 +141,13 @@ module SolidObjects
       def deadline_error?(error)
         return false unless SyncDeadline.active?
 
-        busy_error?(error)
+        busy_error?(error) || reconnect_blocked_error?(error)
+      end
+
+      # @rbs (Exception) -> bool
+      def reconnect_blocked_error?(error)
+        error.message.include?("SQLite3::CantOpenException") &&
+          error.message.include?("PRAGMA journal_mode='wal'")
       end
 
       # @rbs (Exception) -> bool

data/lib/solid_objects/dead_letter_manager.rb

@@ -16,13 +16,13 @@ module SolidObjects
 
       original_message = dead_letter.message
       message_reference = Mailbox.new.enqueue(
-        Reference.new(
+        reference: Reference.new(
           actor_type: dead_letter.actor_type,
           actor_id: dead_letter.actor_id
         ),
-        dead_letter.message_name,
-        dead_letter.arguments,
-        kind: original_message.message_kind,
+        operation: dead_letter.operation,
+        arguments: dead_letter.arguments,
+        delivery_mode: original_message.delivery_mode,
         idempotency_key: "dead-letter:#{dead_letter.id}"
       )
       dead_letter.update!(retried_message_id: message_reference.id)

data/lib/solid_objects/doctor.rb

@@ -68,7 +68,7 @@ module SolidObjects
         activation_generation
       ],
       messages: %w[
-        id instance_id message_kind arguments sequence attempt_count request_id
+        id instance_id delivery_mode arguments sequence attempt_count request_id
         result error rejection completed_at rejected_at
       ],
       ready_messages: %w[id message_id instance_id sequence available_at],
@@ -76,7 +76,7 @@ module SolidObjects
         id message_id instance_id process_id activation_token
         activation_generation claimed_at
       ],
-      reminders: %w[id instance_id message_name next_run_at status],
+      reminders: %w[id instance_id operation next_run_at status],
       effects: %w[id message_id instance_id effect_id status available_at],
       broadcasts: %w[id message_id instance_id broadcast_id status available_at],
       dead_letters: %w[id message_id instance_id actor_type actor_id attempts]
@@ -247,10 +247,10 @@ module SolidObjects
       probe_registry.register(kind: "caller", metadata: { execution: "doctor" })
       value = SecureRandom.hex(8)
       message_reference = Mailbox.new.enqueue(
-        ProbeActor.ref(actor_id),
-        :ping,
-        { value: },
-        kind: "sync"
+        reference: ProbeActor.ref(actor_id),
+        operation: :ping,
+        arguments: { value: },
+        delivery_mode: "sync"
       )
       result = SynchronousInvocation
         .new(process_registry: probe_registry)
@@ -314,11 +314,11 @@ module SolidObjects
       }
       {
         authorize_message: actor_arguments.merge(
-          message_name: "ping",
+          operation: "ping",
           arguments: { "value" => "doctor" }
         ),
         authorize_query: actor_arguments.merge(
-          message_name: "value",
+          operation: "value",
           arguments: {}
         ),
         authorize_destroy: actor_arguments,