solid_objects 0.11.0 → 0.12.0

data/lib/solid_objects/errors.rb

@@ -68,19 +68,19 @@ module SolidObjects
     # @rbs @timeout: Numeric
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
 
-    attr_reader :timeout, :actor_type, :actor_id, :message_name
+    attr_reader :timeout, :actor_type, :actor_id, :operation
 
-    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(timeout:, actor_type:, actor_id:, message_name:)
+    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(timeout:, actor_type:, actor_id:, operation:)
       @timeout = timeout
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       super(
         "actor invocation could not be durably enqueued within #{timeout} seconds for " \
-          "#{actor_type}(#{actor_id.inspect}).#{message_name}"
+          "#{actor_type}(#{actor_id.inspect}).#{operation}"
       )
     end
   end
@@ -89,7 +89,7 @@ module SolidObjects
     # @rbs @timeout: Numeric
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
     # @rbs @message_id: Integer
     # @rbs @request_id: String
     # @rbs @sequence: Integer
@@ -101,7 +101,7 @@ module SolidObjects
     attr_reader :timeout,
       :actor_type,
       :actor_id,
-      :message_name,
+      :operation,
       :message_id,
       :request_id,
       :sequence,
@@ -110,12 +110,12 @@ module SolidObjects
       :activation,
       :blocker
 
-    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, message_name: String, message_id: Integer, request_id: String, sequence: Integer, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> void
+    # @rbs (timeout: Numeric, actor_type: String, actor_id: String, operation: String, message_id: Integer, request_id: String, sequence: Integer, status: String, waiting_on: String, activation: Hash[String, untyped], blocker: Hash[String, untyped]?) -> void
     def initialize(
       timeout:,
       actor_type:,
       actor_id:,
-      message_name:,
+      operation:,
       message_id:,
       request_id:,
       sequence:,
@@ -127,7 +127,7 @@ module SolidObjects
       @timeout = timeout
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       @message_id = message_id
       @request_id = request_id
       @sequence = sequence
@@ -137,7 +137,7 @@ module SolidObjects
       @blocker = Serialization.readonly_copy(blocker)
       super(
         "actor invocation timed out after #{timeout} seconds for " \
-          "#{actor_type}(#{actor_id.inspect}).#{message_name} " \
+          "#{actor_type}(#{actor_id.inspect}).#{operation} " \
           "message_id=#{message_id} sequence=#{sequence} status=#{status} waiting_on=#{waiting_on}"
       )
     end
@@ -157,17 +157,17 @@ module SolidObjects
   class SyncInsideTransaction < Error
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
 
-    attr_reader :actor_type, :actor_id, :message_name
+    attr_reader :actor_type, :actor_id, :operation
 
-    # @rbs (actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(actor_type:, actor_id:, message_name:)
+    # @rbs (actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(actor_type:, actor_id:, operation:)
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       super(
-        "cannot synchronously invoke #{actor_type}(#{actor_id.inspect}).#{message_name} " \
+        "cannot synchronously invoke #{actor_type}(#{actor_id.inspect}).#{operation} " \
           "inside an open database transaction; call it before the transaction or enqueue it with async"
       )
     end
@@ -176,27 +176,27 @@ module SolidObjects
   class ApplicationWriteForbidden < NonRetryableError
     # @rbs @actor_type: String
     # @rbs @actor_id: String
-    # @rbs @message_name: String
+    # @rbs @operation: String
 
-    attr_reader :actor_type, :actor_id, :message_name
+    attr_reader :actor_type, :actor_id, :operation
 
-    # @rbs (actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(actor_type:, actor_id:, message_name:)
+    # @rbs (actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(actor_type:, actor_id:, operation:)
       @actor_type = actor_type
       @actor_id = actor_id
-      @message_name = message_name
+      @operation = operation
       super(
-        "#{actor_type}(#{actor_id.inspect}).#{message_name} attempted an Active Record write; " \
+        "#{actor_type}(#{actor_id.inspect}).#{operation} attempted an Active Record write; " \
           "mutate actor state, stage a commit action, or emit a durable effect instead"
       )
     end
   end
 
   class CommitActionUnavailable < NonRetryableError
-    # @rbs (actor_type: String, actor_id: String, message_name: String) -> void
-    def initialize(actor_type:, actor_id:, message_name:)
+    # @rbs (actor_type: String, actor_id: String, operation: String) -> void
+    def initialize(actor_type:, actor_id:, operation:)
       super(
-        "#{actor_type}(#{actor_id.inspect}).#{message_name} staged a commit action, " \
+        "#{actor_type}(#{actor_id.inspect}).#{operation} staged a commit action, " \
           "but Solid Objects uses a separate database from Active Record"
       )
     end

data/lib/solid_objects/executor.rb

@@ -55,17 +55,17 @@ module SolidObjects
     # @rbs (MessageContext) -> untyped
     def invoke_actor(message_context)
       Context.with(actor:, message: message_context) do
-        actor.invoke(message.message_name, message.arguments)
+        actor.invoke(message.operation, message.arguments)
       end
     end
 
     # @rbs (Hash[String, untyped]) -> void
     def ensure_query_did_not_mutate_state!(state_before)
-      return unless message.message_kind == "sync"
-      return unless actor.class.definition.queries.key?(message.message_name.to_sym)
+      return unless message.delivery_mode == "sync"
+      return unless actor.class.definition.queries.key?(message.operation.to_sym)
       return if actor.state.to_h == state_before
 
-      raise InvalidActor, "query #{message.message_name.inspect} mutated actor state"
+      raise InvalidActor, "query #{message.operation.inspect} mutated actor state"
     end
 
     # @rbs (Hash[String, untyped], Hash[String, untyped]) -> Hash[String, untyped]
@@ -82,7 +82,7 @@ module SolidObjects
         max_bytes: SolidObjects.configuration.max_state_bytes
       )
       serialized_result = Serialization.dump(
-        (message.message_kind == "sync") ? result : nil,
+        (message.delivery_mode == "sync") ? result : nil,
         max_bytes: SolidObjects.configuration.max_result_bytes
       )
       effect_intents = actor.drain_effect_intents
@@ -112,15 +112,17 @@ module SolidObjects
           error: nil,
           completed_at: SolidObjects.database_adapter.database_now
         )
-        enqueued_effects.concat(enqueue_effects(locked_message, instance, effect_intents))
+        enqueued_effects.concat(
+          enqueue_effects(message: locked_message, instance:, intents: effect_intents)
+        )
         moved_reminders.concat(schedule_reminders(instance, reminder_intents))
         enqueued_effects.concat(
-          enqueue_actor_messages(locked_message, instance, outbound_message_intents)
+          enqueue_actor_messages(message: locked_message, instance:, intents: outbound_message_intents)
         )
         enqueue_broadcasts(
-          locked_message,
-          instance,
-          observable_changes,
+          message: locked_message,
+          instance:,
+          observable_changes:,
           state_changed:
         )
         claimed_message.destroy!
@@ -163,12 +165,12 @@ module SolidObjects
 
       intents.each do |intent|
         handler = SolidObjects.commit_action_registry.fetch(intent.name)
-        execute_commit_action(intent, handler, context)
+        execute_commit_action(intent:, handler:, context:)
       end
     end
 
-    # @rbs (Actor::CommitActionIntent, Proc, CommitActionContext) -> untyped
-    def execute_commit_action(intent, handler, context)
+    # @rbs (intent: Actor::CommitActionIntent, handler: Proc, context: CommitActionContext) -> untyped
+    def execute_commit_action(intent:, handler:, context:)
       payload = {
         commit_action_name: intent.name,
         message_id: message.id,
@@ -198,21 +200,21 @@ module SolidObjects
       raise CommitActionUnavailable.new(
         actor_type: message.actor_type,
         actor_id: message.actor_id,
-        message_name: message.message_name
+        operation: message.operation
       )
     end
 
-    # @rbs (Message, Instance, Array[Actor::EffectIntent]) -> Array[Effect]
-    def enqueue_effects(locked_message, instance, intents)
+    # @rbs (message: Message, instance: Instance, intents: Array[Actor::EffectIntent]) -> Array[Effect]
+    def enqueue_effects(message:, instance:, intents:)
       intents.map do |intent|
         Effect.create!(
-          message: locked_message,
+          message:,
           instance:,
           effect_id: SecureRandom.uuid,
           name: intent.name,
           arguments: intent.arguments,
-          success_message_name: intent.success_message_name,
-          failure_message_name: intent.failure_message_name,
+          success_operation: intent.success_operation,
+          failure_operation: intent.failure_operation,
           status: "pending",
           max_attempts: SolidObjects.configuration.max_attempts,
           available_at: SolidObjects.database_adapter.database_now
@@ -237,7 +239,7 @@ module SolidObjects
         reminder.assign_attributes(
           actor_type: instance.actor_type,
           actor_id: instance.actor_id,
-          message_name: intent.name,
+          operation: intent.name,
           arguments: intent.arguments,
           next_run_at: intent.at,
           interval_seconds: intent.interval_seconds,
@@ -268,18 +270,18 @@ module SolidObjects
       }
     end
 
-    # @rbs (Message, Instance, Array[Actor::OutboundMessageIntent]) -> Array[Effect]
-    def enqueue_actor_messages(locked_message, instance, intents)
+    # @rbs (message: Message, instance: Instance, intents: Array[Actor::OutboundMessageIntent]) -> Array[Effect]
+    def enqueue_actor_messages(message:, instance:, intents:)
       intents.map do |intent|
         Effect.create!(
-          message: locked_message,
+          message:,
           instance:,
           effect_id: SecureRandom.uuid,
           name: EffectExecutor::ACTOR_MESSAGE_EFFECT,
           arguments: {
             "actor_type" => intent.actor_type,
             "actor_id" => intent.actor_id,
-            "message_name" => intent.message_name,
+            "operation" => intent.operation,
             "arguments" => intent.arguments,
             "available_at" => intent.available_at&.iso8601(6),
             "idempotency_key" => intent.idempotency_key
@@ -291,8 +293,8 @@ module SolidObjects
       end
     end
 
-    # @rbs (Message, Instance, Hash[String, untyped], state_changed: bool) -> void
-    def enqueue_broadcasts(locked_message, instance, observable_changes, state_changed:)
+    # @rbs (message: Message, instance: Instance, observable_changes: Hash[String, untyped], state_changed: bool) -> void
+    def enqueue_broadcasts(message:, instance:, observable_changes:, state_changed:)
       broadcasts = observable_changes
       if broadcasts.empty? && state_changed && payload_broadcasts?
         broadcasts = { PayloadBroadcast::REVISION_OBSERVABLE => {} }
@@ -300,7 +302,7 @@ module SolidObjects
 
       broadcasts.each do |observable_name, value|
         Broadcast.create!(
-          message: locked_message,
+          message:,
           instance:,
           broadcast_id: SecureRandom.uuid,
           observable_name:,
@@ -332,7 +334,7 @@ module SolidObjects
 
         if error.is_a?(NonRetryableError) ||
             locked_message.attempt_count >= locked_message.max_attempts
-          create_dead_letter(locked_message, error_details, now)
+          create_dead_letter(message: locked_message, error_details:, now:)
           dead = true
         else
           ReadyMessage.create!(
@@ -410,20 +412,20 @@ module SolidObjects
       )
     end
 
-    # @rbs (Message, Hash[String, untyped], Time) -> DeadLetter
-    def create_dead_letter(locked_message, error_details, now)
+    # @rbs (message: Message, error_details: Hash[String, untyped], now: Time) -> DeadLetter
+    def create_dead_letter(message:, error_details:, now:)
       DeadLetter.create!(
-        message: locked_message,
-        instance: locked_message.instance,
-        actor_type: locked_message.actor_type,
-        actor_id: locked_message.actor_id,
-        message_name: locked_message.message_name,
-        arguments: locked_message.arguments,
-        attempts: locked_message.attempt_count,
+        message:,
+        instance: message.instance,
+        actor_type: message.actor_type,
+        actor_id: message.actor_id,
+        operation: message.operation,
+        arguments: message.arguments,
+        attempts: message.attempt_count,
         exception_class: error_details.fetch("class"),
         exception_message: error_details.fetch("message"),
         backtrace: error_details.fetch("backtrace"),
-        first_failed_at: locked_message.last_failed_at || now,
+        first_failed_at: message.last_failed_at || now,
         last_failed_at: now
       )
     end

data/lib/solid_objects/lease.rb

@@ -11,7 +11,7 @@ module SolidObjects
         now:,
         database_adapter:, duration: SolidObjects.configuration.lease_duration
       )
-        return if held_by_another_live_owner?(instance, activation_token, now)
+        return if held_by_another_live_owner?(instance:, activation_token:, now:)
 
         generation = instance.activation_generation + 1
         expires_at = now + duration
@@ -61,8 +61,8 @@ module SolidObjects
 
       private
 
-      # @rbs (Instance, String, Time) -> bool
-      def held_by_another_live_owner?(instance, activation_token, now)
+      # @rbs (instance: Instance, activation_token: String, now: Time) -> bool
+      def held_by_another_live_owner?(instance:, activation_token:, now:)
         instance.activation_owner_id.present? &&
           instance.activation_token != activation_token &&
           instance.activation_expires_at.present? &&

data/lib/solid_objects/mailbox.rb

@@ -11,8 +11,8 @@ module SolidObjects
       @database_adapter = database_adapter
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, ?available_at: Time?, idempotency_key: String?) -> MessageReference
-    def enqueue(reference, message_name, arguments, kind:, available_at: nil, idempotency_key: nil)
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], delivery_mode: String, ?available_at: Time?, idempotency_key: String?) -> MessageReference
+    def enqueue(reference:, operation:, arguments:, delivery_mode:, available_at: nil, idempotency_key: nil)
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
       normalized_arguments = Serialization.dump(
         arguments,
@@ -21,10 +21,10 @@ module SolidObjects
       message = with_instance_retry do
         database_adapter.transaction do
           enqueue_in_transaction(
-            reference,
-            message_name,
-            normalized_arguments,
-            kind:,
+            reference:,
+            operation:,
+            arguments: normalized_arguments,
+            delivery_mode:,
             available_at:,
             idempotency_key:,
             actor_class:
@@ -36,12 +36,12 @@ module SolidObjects
       MessageReference.from_message(message)
     end
 
-    # @rbs (Reference, Symbol | String, Hash[Symbol | String, untyped], kind: String, ?available_at: Time?, idempotency_key: String?, ?actor_class: Class?) -> Message
+    # @rbs (reference: Reference, operation: Symbol | String, arguments: Hash[Symbol | String, untyped], delivery_mode: String, ?available_at: Time?, idempotency_key: String?, ?actor_class: Class?) -> Message
     def enqueue_in_transaction(
-      reference,
-      message_name,
-      arguments,
-      kind:,
+      reference:,
+      operation:,
+      arguments:,
+      delivery_mode:,
       available_at: nil,
       idempotency_key: nil,
       actor_class: nil
@@ -55,15 +55,22 @@ module SolidObjects
       instance.lock!
 
       existing = find_idempotent_message(instance, idempotency_key)
-      return validate_idempotent_message!(existing, message_name, kind, normalized_arguments) if existing
+      if existing
+        return validate_idempotent_message!(
+          existing_message: existing,
+          operation:,
+          delivery_mode:,
+          arguments: normalized_arguments
+        )
+      end
 
       enforce_mailbox_limit!(instance)
       create_message(
-        instance,
-        reference,
-        message_name,
-        normalized_arguments,
-        kind:,
+        instance:,
+        reference:,
+        operation:,
+        arguments: normalized_arguments,
+        delivery_mode:,
         available_at:,
         idempotency_key:
       )
@@ -117,12 +124,12 @@ module SolidObjects
       Message.find_by(instance_id: instance.id, idempotency_key:)
     end
 
-    # @rbs (Message, Symbol | String, String, untyped) -> Message
-    def validate_idempotent_message!(message, message_name, kind, arguments)
-      matches = message.message_name == message_name.to_s &&
-        message.message_kind == kind &&
-        message.arguments == arguments
-      return message if matches
+    # @rbs (existing_message: Message, operation: Symbol | String, delivery_mode: String, arguments: untyped) -> Message
+    def validate_idempotent_message!(existing_message:, operation:, delivery_mode:, arguments:)
+      matches = existing_message.operation == operation.to_s &&
+        existing_message.delivery_mode == delivery_mode &&
+        existing_message.arguments == arguments
+      return existing_message if matches
 
       raise IdempotencyConflict, "idempotency key belongs to a different actor invocation"
     end
@@ -136,8 +143,8 @@ module SolidObjects
       raise MailboxFull, "mailbox is full for #{instance.actor_type}(#{instance.actor_id.inspect})"
     end
 
-    # @rbs (Instance, Reference, Symbol | String, untyped, kind: String, available_at: Time?, idempotency_key: String?) -> Message
-    def create_message(instance, reference, message_name, arguments, kind:, available_at:, idempotency_key:)
+    # @rbs (instance: Instance, reference: Reference, operation: Symbol | String, arguments: untyped, delivery_mode: String, available_at: Time?, idempotency_key: String?) -> Message
+    def create_message(instance:, reference:, operation:, arguments:, delivery_mode:, available_at:, idempotency_key:)
       sequence = instance.next_message_sequence
       now = database_adapter.database_now
       scheduled_at = normalize_availability(available_at, now)
@@ -146,8 +153,8 @@ module SolidObjects
         instance:,
         actor_type: reference.actor_type,
         actor_id: reference.actor_id,
-        message_name: message_name.to_s,
-        message_kind: kind,
+        operation: operation.to_s,
+        delivery_mode:,
         arguments:,
         sequence:,
         max_attempts: SolidObjects.configuration.max_attempts,

data/lib/solid_objects/operation_dispatcher.rb

@@ -0,0 +1,51 @@
+# rbs_inline: enabled
+
+module SolidObjects
+  class OperationDispatcher
+    # @rbs @actor_type: String
+    # @rbs @handlers: Hash[Symbol, ActorDefinition::Handler]
+    # @rbs @dispatch: Proc
+
+    # @rbs (actor_type: String, handlers: Hash[Symbol, ActorDefinition::Handler]) { (Symbol, Hash[Symbol, untyped]) -> untyped } -> void
+    def initialize(actor_type:, handlers:, &dispatch)
+      @actor_type = actor_type
+      @handlers = handlers.dup.freeze
+      @dispatch = dispatch
+    end
+
+    # @rbs (Symbol, *untyped, **untyped) -> untyped
+    def method_missing(name, *arguments, **keywords, &block)
+      raise UnknownMessage, "unknown message #{name.inspect} for #{actor_type}" unless handlers.key?(name)
+      if arguments.any? || block
+        raise ArgumentError, "actor operations accept keyword arguments only"
+      end
+
+      dispatch.call(name, keywords)
+    end
+
+    # @rbs (Symbol, bool) -> bool
+    def respond_to_missing?(name, include_private = false)
+      handlers.key?(name) || super
+    end
+
+    private
+
+    attr_reader :actor_type, :handlers, :dispatch
+
+    RESERVED_REFERENCE_METHOD_NAMES = %i[actor_type actor_id async sync destroy snapshot].freeze
+    RESERVED_OPERATION_NAMES = (
+      public_instance_methods(true) +
+      RESERVED_REFERENCE_METHOD_NAMES
+    ).map(&:to_sym).uniq.freeze
+
+    class << self
+      # @rbs (Symbol | String) -> void
+      def validate_operation_name!(name)
+        operation_name = name.to_sym
+        return unless RESERVED_OPERATION_NAMES.include?(operation_name)
+
+        raise InvalidActor, "#{operation_name.inspect} conflicts with actor dispatch"
+      end
+    end
+  end
+end

data/lib/solid_objects/payload_broadcast.rb

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

data/lib/solid_objects/reference.rb

@@ -16,41 +16,50 @@ module SolidObjects
       freeze
     end
 
-    # @rbs (Symbol | String, ?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> MessageReference?
-    def async(message_name, available_at: nil, idempotency_key: nil, authorization_context: nil, **arguments)
-      if (actor = Context.current_actor)
-        actor.stage_outbound_message(
-          self,
-          message_name,
-          arguments,
+    # @rbs (?available_at: Time?, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
+    def async(available_at: nil, idempotency_key: nil, authorization_context: nil)
+      OperationDispatcher.new(
+        actor_type:,
+        handlers: actor_definition.messages
+      ) do |operation, arguments|
+        if (actor = Context.current_actor)
+          actor.stage_outbound_message(
+            reference: self,
+            operation:,
+            arguments:,
+            available_at:,
+            idempotency_key:
+          )
+          next
+        end
+
+        SolidObjects.client.async(
+          reference: self,
+          operation:,
+          arguments:,
           available_at:,
-          idempotency_key:
+          idempotency_key:,
+          authorization_context:
         )
-        return
       end
-
-      SolidObjects.client.async(
-        self,
-        message_name,
-        arguments,
-        available_at:,
-        idempotency_key:,
-        authorization_context:
-      )
     end
 
-    # @rbs (Symbol | String, ?timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped, **untyped) -> untyped
-    def sync(message_name, timeout: 5.seconds, idempotency_key: nil, authorization_context: nil, **arguments)
+    # @rbs (?timeout: Numeric, ?idempotency_key: String?, ?authorization_context: untyped) -> OperationDispatcher
+    def sync(timeout: 5.seconds, idempotency_key: nil, authorization_context: nil)
       raise ActorCallCycle, "actors cannot synchronously wait for another actor" if Context.current_actor
 
-      SolidObjects.client.sync(
-        self,
-        message_name,
-        arguments,
-        timeout:,
-        idempotency_key:,
-        authorization_context:
-      )
+      OperationDispatcher.new(
+        actor_type:,
+        handlers: actor_definition.messages.merge(actor_definition.queries)
+      ) do |operation, arguments|
+        invoke_synchronously(
+          operation,
+          arguments,
+          timeout:,
+          idempotency_key:,
+          authorization_context:
+        )
+      end
     end
 
     # @rbs (?authorization_context: untyped) -> bool
@@ -66,7 +75,15 @@ module SolidObjects
     # @rbs (Symbol, *untyped, **untyped) -> untyped
     def method_missing(name, *arguments, **keywords)
       return super if arguments.any? || block_given?
-      return sync(name, **keywords) if actor_message?(name) || actor_query?(name)
+      if actor_message?(name) || actor_query?(name)
+        return invoke_synchronously(
+          name,
+          keywords,
+          timeout: 5.seconds,
+          idempotency_key: nil,
+          authorization_context: nil
+        )
+      end
 
       super
     end
@@ -83,6 +100,20 @@ module SolidObjects
 
     private
 
+    # @rbs (Symbol | String, Hash[Symbol, untyped], timeout: Numeric, idempotency_key: String?, authorization_context: untyped) -> untyped
+    def invoke_synchronously(operation, arguments, timeout:, idempotency_key:, authorization_context:)
+      raise ActorCallCycle, "actors cannot synchronously wait for another actor" if Context.current_actor
+
+      SolidObjects.client.sync(
+        reference: self,
+        operation:,
+        arguments:,
+        timeout:,
+        idempotency_key:,
+        authorization_context:
+      )
+    end
+
     # @rbs (Symbol | String) -> bool
     def actor_message?(name)
       actor_definition.messages.key?(name.to_sym)

data/lib/solid_objects/reminder_scheduler.rb

@@ -97,8 +97,8 @@ module SolidObjects
     # @rbs (Reminder) -> MessageReference?
     def enqueue(reminder)
       actor_class = SolidObjects.registry.fetch(reminder.actor_type)
-      unless actor_class.definition.messages.key?(reminder.message_name.to_sym)
-        raise UnknownMessage, "unknown reminder message #{reminder.message_name.inspect}"
+      unless actor_class.definition.messages.key?(reminder.operation.to_sym)
+        raise UnknownMessage, "unknown reminder operation #{reminder.operation.inspect}"
       end
 
       mailbox = Mailbox.new(database_adapter:)
@@ -111,10 +111,10 @@ module SolidObjects
         verify_claim!(locked_reminder)
         now = database_adapter.database_now
         message = mailbox.enqueue_in_transaction(
-          Reference.new(actor_type: instance.actor_type, actor_id: instance.actor_id),
-          locked_reminder.message_name,
-          locked_reminder.arguments,
-          kind: "internal",
+          reference: Reference.new(actor_type: instance.actor_type, actor_id: instance.actor_id),
+          operation: locked_reminder.operation,
+          arguments: locked_reminder.arguments,
+          delivery_mode: "internal",
           idempotency_key: "reminder:#{locked_reminder.id}:#{locked_reminder.occurrence}",
           actor_class:
         )