solid_objects 0.11.0 → 0.12.0

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/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,

data/lib/solid_objects/effect_executor.rb

@@ -122,18 +122,18 @@ module SolidObjects
         actor_id: arguments.fetch("actor_id")
       )
       actor_class = SolidObjects.registry.fetch(reference.actor_type)
-      message_name = arguments.fetch("message_name")
-      unless actor_class.definition.messages.key?(message_name.to_sym)
-        raise UnknownMessage, "unknown actor-to-actor message #{message_name.inspect}"
+      operation = arguments.fetch("operation")
+      unless actor_class.definition.messages.key?(operation.to_sym)
+        raise UnknownMessage, "unknown actor-to-actor operation #{operation.inspect}"
       end
 
       available_at = arguments["available_at"]
       available_at = Time.iso8601(available_at) if available_at
       Mailbox.new.enqueue(
-        reference,
-        message_name,
-        arguments.fetch("arguments"),
-        kind: "internal",
+        reference:,
+        operation:,
+        arguments: arguments.fetch("arguments"),
+        delivery_mode: "internal",
         available_at:,
         idempotency_key: effect.effect_id
       ).id
@@ -150,10 +150,10 @@ module SolidObjects
         locked_effect = Effect.lock.find(effect.id)
         verify_claim!(locked_effect)
         result_message = enqueue_result_message(
-          locked_effect,
-          locked_effect.success_message_name,
-          "success",
-          { "effect_id" => locked_effect.effect_id, "result" => serialized_result }
+          effect: locked_effect,
+          operation: locked_effect.success_operation,
+          outcome: "success",
+          arguments: { "effect_id" => locked_effect.effect_id, "result" => serialized_result }
         )
         locked_effect.update!(
           status: "completed",
@@ -188,10 +188,10 @@ module SolidObjects
         }
         if dead
           result_message = enqueue_result_message(
-            locked_effect,
-            locked_effect.failure_message_name,
-            "failure",
-            { "effect_id" => locked_effect.effect_id, "error" => error_details }
+            effect: locked_effect,
+            operation: locked_effect.failure_operation,
+            outcome: "failure",
+            arguments: { "effect_id" => locked_effect.effect_id, "error" => error_details }
           )
         end
         locked_effect.update!(
@@ -216,18 +216,18 @@ module SolidObjects
       raise LostActivation, "effect claim changed"
     end
 
-    # @rbs (Effect, String?, String, Hash[String, untyped]) -> Message?
-    def enqueue_result_message(effect, message_name, outcome, arguments)
-      return unless message_name
+    # @rbs (effect: Effect, operation: String?, outcome: String, arguments: Hash[String, untyped]) -> Message?
+    def enqueue_result_message(effect:, operation:, outcome:, arguments:)
+      return unless operation
 
       Mailbox.new.enqueue_in_transaction(
-        Reference.new(
+        reference: Reference.new(
           actor_type: effect.instance.actor_type,
           actor_id: effect.instance.actor_id
         ),
-        message_name,
-        arguments,
-        kind: "internal",
+        operation:,
+        arguments:,
+        delivery_mode: "internal",
         idempotency_key: "effect:#{effect.effect_id}:#{outcome}"
       )
     end