fix: resolve credo strict mode violations

- Extract helper functions to reduce cyclomatic complexity in executor
- Replace length/1 checks with empty list comparisons in tests

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: kasvith

lib/durable/executor.ex

@@ -283,42 +283,66 @@ defmodule Durable.Executor do
         execute_steps_recursive(remaining_steps, exec, step_index, workflow_def, config)
 
       {:decision, target_step} ->
-        # Decision step wants to jump - find target in remaining steps
-        {:ok, exec} = save_context(repo, exec)
-
-        case find_jump_target(target_step, remaining_steps, step.name, step_index) do
-          {:ok, target_steps} ->
-            execute_steps_recursive(target_steps, exec, step_index, workflow_def, config)
-
-          {:error, reason} ->
-            handle_step_failure(
-              exec,
-              decision_error(step.name, target_step, reason),
-              workflow_def,
-              config
-            )
-        end
-
-      {:sleep, opts} ->
-        {:waiting, handle_sleep(repo, exec, opts) |> elem(1)}
+        handle_decision_result(
+          exec,
+          target_step,
+          remaining_steps,
+          step,
+          step_index,
+          workflow_def,
+          config
+        )
 
-      {:wait_for_event, opts} ->
-        {:waiting, handle_wait_for_event(repo, exec, opts) |> elem(1)}
+      {wait_type, opts}
+      when wait_type in [:sleep, :wait_for_event, :wait_for_input, :wait_for_any, :wait_for_all] ->
+        handle_wait_result(repo, exec, wait_type, opts)
 
-      {:wait_for_input, opts} ->
-        {:waiting, handle_wait_for_input(repo, exec, opts) |> elem(1)}
+      {:error, error} ->
+        handle_step_failure(exec, error, workflow_def, config)
+    end
+  end
 
-      {:wait_for_any, opts} ->
-        {:waiting, handle_wait_for_any(repo, exec, opts) |> elem(1)}
+  defp handle_decision_result(
+         exec,
+         target_step,
+         remaining_steps,
+         step,
+         step_index,
+         workflow_def,
+         config
+       ) do
+    repo = config.repo
+    {:ok, exec} = save_context(repo, exec)
 
-      {:wait_for_all, opts} ->
-        {:waiting, handle_wait_for_all(repo, exec, opts) |> elem(1)}
+    case find_jump_target(target_step, remaining_steps, step.name, step_index) do
+      {:ok, target_steps} ->
+        execute_steps_recursive(target_steps, exec, step_index, workflow_def, config)
 
-      {:error, error} ->
-        handle_step_failure(exec, error, workflow_def, config)
+      {:error, reason} ->
+        handle_step_failure(
+          exec,
+          decision_error(step.name, target_step, reason),
+          workflow_def,
+          config
+        )
     end
   end
 
+  defp handle_wait_result(repo, exec, :sleep, opts),
+    do: {:waiting, handle_sleep(repo, exec, opts) |> elem(1)}
+
+  defp handle_wait_result(repo, exec, :wait_for_event, opts),
+    do: {:waiting, handle_wait_for_event(repo, exec, opts) |> elem(1)}
+
+  defp handle_wait_result(repo, exec, :wait_for_input, opts),
+    do: {:waiting, handle_wait_for_input(repo, exec, opts) |> elem(1)}
+
+  defp handle_wait_result(repo, exec, :wait_for_any, opts),
+    do: {:waiting, handle_wait_for_any(repo, exec, opts) |> elem(1)}
+
+  defp handle_wait_result(repo, exec, :wait_for_all, opts),
+    do: {:waiting, handle_wait_for_all(repo, exec, opts) |> elem(1)}
+
   defp execute_branch(branch_step, remaining_steps, execution, step_index, workflow_def, config) do
     repo = config.repo
     {:ok, exec} = update_current_step(repo, execution, branch_step.name)

test/durable/wait_test.exs

@@ -560,7 +560,7 @@ defmodule Durable.WaitTest do
 
       inputs = Wait.list_pending_inputs()
 
-      assert length(inputs) >= 1
+      assert inputs != []
       assert Enum.any?(inputs, fn i -> i.workflow_id == execution.id end)
     end
 
@@ -593,7 +593,7 @@ defmodule Durable.WaitTest do
 
       events = Wait.list_pending_events()
 
-      assert length(events) >= 1
+      assert events != []
       assert Enum.any?(events, fn e -> e.workflow_id == execution.id end)
     end