fix: implement nested_steps/1 for Step.Switch to fix dependency resolution (#288)

Steps inside a `switch` block couldn't reference external steps via
`result(:step_name)` when running with async execution. This was because
`Step.Switch` didn't implement the `nested_steps/1` callback, so the
planner couldn't see the nested steps' dependencies and create proper
edges in the dependency graph.

Without proper dependency edges, the Switch step could run before its
nested steps' dependencies completed, causing a "step cannot be found"
error when the emitted steps were planned at runtime.

Closes #273

Author: jimsynz

lib/reactor/step/switch.ex

@@ -70,6 +70,7 @@ defmodule Reactor.Step.Switch do
   @type on_option :: {:on, atom}
 
   @doc false
+  @impl true
   @spec run(Reactor.inputs(), Reactor.context(), options) :: {:ok, any} | {:error, any}
   def run(arguments, _context, options) do
     allow_async? = Keyword.get(options, :allow_async?, true)
@@ -90,6 +91,19 @@ defmodule Reactor.Step.Switch do
   def to_mermaid(step, options),
     do: __MODULE__.Mermaid.to_mermaid(step, options)
 
+  @doc false
+  @impl true
+  def nested_steps(options) do
+    matches = Keyword.get(options, :matches, [])
+    default = Keyword.get(options, :default, [])
+
+    match_steps =
+      matches
+      |> Enum.flat_map(fn {_predicate, steps} -> steps end)
+
+    match_steps ++ default
+  end
+
   defp find_match(matches, value) do
     Enum.reduce_while(matches, :no_match, fn {predicate, steps}, :no_match ->
       if predicate.(value) do

test/reactor/dsl/switch_test.exs

@@ -123,4 +123,76 @@ defmodule Reactor.Dsl.SwitchTest do
              end) =~ ~r/amscray/
     end
   end
+
+  describe "issue #273 - nested steps can refer to external step results with async execution" do
+    defmodule SwitchExternalResultAsyncReactor do
+      @moduledoc false
+      use Reactor
+
+      input :params
+
+      step :create_personal_organization do
+        run fn _, _ ->
+          Process.sleep(10)
+          {:ok, %{org_id: "org_123"}}
+        end
+      end
+
+      step :create_session_token do
+        run fn _, _ ->
+          {:ok, "token_abc"}
+        end
+      end
+
+      switch :populate_scope do
+        on input(:params)
+
+        matches? &(Map.get(&1, "invite_token") != nil) do
+          step :populate_scope do
+            argument :user_token, result(:create_session_token)
+            wait_for :create_personal_organization
+
+            run fn %{user_token: token}, _ ->
+              {:ok, %{token: token, source: :invite}}
+            end
+          end
+        end
+
+        default do
+          step :populate_scope do
+            argument :user_token, result(:create_session_token)
+            argument :scope, result(:create_personal_organization)
+
+            run fn %{scope: scope, user_token: token}, _ ->
+              {:ok, %{token: token, org_id: scope.org_id, source: :default}}
+            end
+          end
+        end
+      end
+
+      return :populate_scope
+    end
+
+    test "when switch nested steps depend on external results, they are resolved correctly with async execution" do
+      assert {:ok, result} =
+               Reactor.run(SwitchExternalResultAsyncReactor, %{params: %{}}, %{}, async?: true)
+
+      assert result.source == :default
+      assert result.org_id == "org_123"
+      assert result.token == "token_abc"
+    end
+
+    test "when switch nested steps depend on external results via wait_for, they are resolved correctly" do
+      assert {:ok, result} =
+               Reactor.run(
+                 SwitchExternalResultAsyncReactor,
+                 %{params: %{"invite_token" => "inv_123"}},
+                 %{},
+                 async?: true
+               )
+
+      assert result.source == :invite
+      assert result.token == "token_abc"
+    end
+  end
 end

test/reactor/step/switch_test.exs

@@ -117,4 +117,41 @@ defmodule Reactor.Step.SwitchTest do
       assert error =~ ~r/no default branch/i
     end
   end
+
+  describe "nested_steps/1" do
+    test "returns all steps from matches and default", %{matches: matches, default: default} do
+      options = [matches: matches, default: default, on: :value]
+      nested = Switch.nested_steps(options)
+
+      step_names = Enum.map(nested, & &1.name)
+      assert :is_nil in step_names
+      assert :is_false in step_names
+      assert :is_other in step_names
+      assert length(nested) == 3
+    end
+
+    test "returns empty list when no matches or default", %{} do
+      assert [] == Switch.nested_steps(on: :value)
+    end
+
+    test "returns only match steps when no default", %{matches: matches} do
+      options = [matches: matches, on: :value]
+      nested = Switch.nested_steps(options)
+
+      step_names = Enum.map(nested, & &1.name)
+      assert :is_nil in step_names
+      assert :is_false in step_names
+      refute :is_other in step_names
+      assert length(nested) == 2
+    end
+
+    test "returns only default steps when no matches", %{default: default} do
+      options = [default: default, on: :value]
+      nested = Switch.nested_steps(options)
+
+      step_names = Enum.map(nested, & &1.name)
+      assert :is_other in step_names
+      assert length(nested) == 1
+    end
+  end
 end