fix: catch a bare schedule call in an observable

The check for a schedule call with no operation ran directly after the
operation. An observable that called schedule only after the state
changed was read later, so the turn committed with no reminder and no
error. The open call stayed on the retained actor and made the next
turn fail, although that turn did nothing wrong.

The projection guard now counts an open schedule call as staged work.
The turn that reads the observable fails with QueryMutatedState, and
the failure path clears the open call.

Author: cardmagic

CHANGELOG.md

@@ -11,7 +11,9 @@
   does not retry that turn, and the message becomes a dead letter. Before this
   release, such a call stored no reminder and gave no error. Correct code,
   such as `schedule(at: time).expire`, does not change. The turn can keep the
-  result and call the operation later. JavaScript has the same behavior.
+  result and call the operation later. A `schedule` call with no operation in
+  an observable fails the turn with `SolidObjects::QueryMutatedState`.
+  JavaScript has the same behavior.
 - `bin/rails solid_objects:doctor` has a new `json` check, and the boot prints
   a warning, when Active Support cannot decode JSON with the installed `json`
   gem. This is the case for `json` 3.x on Rails older than 8.1.4. The check

docs/reminders.md

@@ -33,6 +33,9 @@ schedule(at: 10.minutes.from_now, key: buyer).expire(buyer:)
 
 You can keep the result and call the operation later in the same turn.
 
+An observable cannot call `schedule`, with or without an operation. The turn
+that reads the observable fails with `SolidObjects::QueryMutatedState`.
+
 ## A reminder is one named alarm per actor
 
 The uniqueness key is `(actor, reminder name)`. Scheduling a name that is

docs/roadmap.md

@@ -13,7 +13,9 @@
   [versioning](versioning.md)
 - A turn that calls `schedule` and then calls no operation on the result fails
   with `ScheduleWithoutOperation`, which is not retried, matching JavaScript.
-  Before 1.0 such a call stored no reminder and gave no error.
+  Before 1.0 such a call stored no reminder and gave no error. The projection
+  guard counts such a call in an observable as staged work, so that turn fails
+  with `QueryMutatedState`.
 - A `json` check in `solid_objects:doctor` and a warning during the boot, for
   the `json` gem 3.x on an Active Support release that cannot decode with it.
   The check decodes one document and does not compare version numbers. This

lib/solid_objects/actor.rb

@@ -586,7 +586,14 @@ def read_projection(operation)
 
     # @rbs () -> Array[Array[Hash[Symbol, Object]]]
     def intent_snapshot
-      [ effect_intents, effect_recovery_intents, commit_action_intents, reminder_intents, outbound_message_intents ].map do |intents|
+      [
+        effect_intents,
+        effect_recovery_intents,
+        commit_action_intents,
+        reminder_intents,
+        outbound_message_intents,
+        open_schedule_calls
+      ].map do |intents|
         intents.map { |intent| intent.to_h.deep_dup }
       end
     end

test/integration/schedule_without_operation_test.rb

@@ -37,6 +37,25 @@ def expire
     end
   end
 
+  class ProjectionScheduler < SolidObjects::Actor
+    actor_type "schedule-in-projection"
+
+    attribute :status, default: "open"
+
+    observable :deadline do
+      schedule(at: 10.minutes.from_now, key: "ada") if status == "held"
+      status
+    end
+
+    def hold
+      self.status = "held"
+    end
+
+    def release
+      self.status = "open"
+    end
+  end
+
   setup do
     SolidObjects.configuration.max_attempts = 3
     SolidObjects.configuration.retry_delay = ->(_) { 0 }
@@ -89,4 +108,21 @@ def expire
 
     assert_equal [ "expire" ], SolidObjects::Reminder.pluck(:operation)
   end
+
+  test "a schedule call with no operation in an observable fails the turn that reads it" do
+    error = assert_raises(SolidObjects::MessageFailed) { ProjectionScheduler.ref("one").sync.hold }
+
+    assert_equal "SolidObjects::QueryMutatedState", error.details.fetch("class")
+    assert_empty SolidObjects::Instance.find_by!(actor_id: "one").state
+    assert_equal 1, SolidObjects::Message.sole.attempt_count
+  end
+
+  test "a schedule call with no operation in an observable does not make the next turn fail" do
+    reference = ProjectionScheduler.ref("one")
+    assert_raises(SolidObjects::MessageFailed) { reference.sync.hold }
+
+    reference.sync.release
+
+    assert_equal 1, SolidObjects::DeadLetter.count
+  end
 end