support index queries with generic actions (#363)

Author: barnabasJ

lib/ash_json_api/controllers/helpers.ex

@@ -56,14 +56,7 @@ defmodule AshJsonApi.Controllers.Helpers do
         request = Request.assign(request, :action_input, action_input)
 
         with {:ok, result} <- Ash.run_action(action_input),
-             {:ok, result} <-
-               Ash.load(
-                 result,
-                 fields(request, request.resource),
-                 Request.load_opts(request, reuse_values?: true)
-               ),
-             {:ok, result} <-
-               Ash.load(result, request.includes_keyword, Request.load_opts(request)) do
+             {:ok, result} <- load_action_data(result, request) do
           Request.assign(request, :result, result)
         else
           {:error, error} ->
@@ -103,6 +96,30 @@ defmodule AshJsonApi.Controllers.Helpers do
     end)
   end
 
+  defp load_action_data(result, request) do
+    # If the resouce has no primary read action, we can skip loading
+    if is_nil(Ash.Resource.Info.primary_action(request.resource, :read)) do
+      {:ok, result}
+    else
+      with {:ok, result} <-
+             Ash.load(
+               result,
+               fields(
+                 request,
+                 request.resource
+               ),
+               Request.load_opts(request, reuse_values?: true)
+             ),
+           {:ok, result} <-
+             Ash.load(result, request.includes_keyword, Request.load_opts(request)) do
+        {:ok, result}
+      else
+        {:error, error} ->
+          {:error, error}
+      end
+    end
+  end
+
   def run_action(request) do
     chain(request, fn request ->
       case path_args_and_filter(

lib/ash_json_api/request.ex

@@ -114,7 +114,7 @@ defmodule AshJsonApi.Request do
     |> parse_sort()
     |> parse_attributes()
     |> parse_query_params()
-    |> parse_read_arguments()
+    |> parse_action_arguments()
     |> parse_relationships()
     |> parse_resource_identifiers()
   end
@@ -840,7 +840,7 @@ defmodule AshJsonApi.Request do
 
   defp parse_attributes(request), do: %{request | attributes: %{}, arguments: %{}}
 
-  defp parse_read_arguments(%{action: %{type: :read} = action} = request) do
+  defp parse_action_arguments(%{action: %{type: :read} = action} = request) do
     action.arguments
     |> Enum.filter(& &1.public?)
     |> Enum.reduce(request, fn argument, request ->
@@ -856,7 +856,23 @@ defmodule AshJsonApi.Request do
     end)
   end
 
-  defp parse_read_arguments(request), do: request
+  defp parse_action_arguments(%{action: %{type: :action} = action} = request) do
+    action.arguments
+    |> Enum.filter(& &1.public?)
+    |> Enum.reduce(request, fn argument, request ->
+      name = to_string(argument.name)
+
+      with :error <- Map.fetch(request.query_params, name),
+           :error <- Map.fetch(request.path_params, name) do
+        request
+      else
+        {:ok, value} ->
+          %{request | arguments: Map.put(request.arguments, argument.name, value)}
+      end
+    end)
+  end
+
+  defp parse_action_arguments(request), do: request
 
   defp parse_relationships(
          %{

lib/ash_json_api/resource/resource.ex

@@ -591,11 +591,15 @@ defmodule AshJsonApi.Resource do
     case primary_key_fields(resource) do
       [] ->
         # Expect resource to have only 1 primary key if :primary_key section is not used
-        [key] = Ash.Resource.Info.primary_key(resource)
-
-        case Map.get(record, key) do
-          nil -> nil
-          value -> to_string(value)
+        case Ash.Resource.Info.primary_key(resource) do
+          [] ->
+            nil
+
+          [key] ->
+            case Map.get(record, key) do
+              nil -> nil
+              value -> to_string(value)
+            end
         end
 
       keys ->

test/acceptance/generic_action_index_test.exs

@@ -0,0 +1,144 @@
+defmodule Test.Acceptance.GenericActionIndexTest do
+  use ExUnit.Case, async: true
+
+  defmodule SearchResult do
+    use Ash.Resource,
+      domain: Test.Acceptance.GenericActionIndexTest.Domain,
+      extensions: [AshJsonApi.Resource]
+
+    resource do
+      require_primary_key?(false)
+    end
+
+    json_api do
+      type("search_result")
+
+      routes do
+        base("/search")
+        route(:get, "/", :search, query_params: [:query, :category])
+      end
+    end
+
+    actions do
+      action :search, {:array, :struct} do
+        constraints(items: [instance_of: __MODULE__])
+        argument(:query, :string, allow_nil?: false)
+        argument(:category, :string, allow_nil?: true)
+
+        run(fn input, _ ->
+          query = input.arguments.query
+          category = Map.get(input.arguments, :category)
+
+          results =
+            case category do
+              nil ->
+                [
+                  %__MODULE__{title: "Result 1 for #{query}", content: "Content 1"},
+                  %__MODULE__{title: "Result 2 for #{query}", content: "Content 2"}
+                ]
+
+              category ->
+                [
+                  %__MODULE__{
+                    title: "#{category} Result 1 for #{query}",
+                    content: "Category content 1"
+                  },
+                  %__MODULE__{
+                    title: "#{category} Result 2 for #{query}",
+                    content: "Category content 2"
+                  }
+                ]
+            end
+
+          {:ok, results}
+        end)
+      end
+    end
+
+    attributes do
+      attribute(:title, :string, public?: true)
+      attribute(:content, :string, public?: true)
+    end
+  end
+
+  defmodule Domain do
+    use Ash.Domain,
+      otp_app: :ash_json_api,
+      extensions: [
+        AshJsonApi.Domain
+      ]
+
+    json_api do
+      log_errors?(false)
+    end
+
+    resources do
+      resource(SearchResult)
+    end
+  end
+
+  defmodule Router do
+    use AshJsonApi.Router, domain: Domain
+  end
+
+  import AshJsonApi.Test
+
+  setup do
+    Application.put_env(:ash_json_api, Domain, json_api: [test_router: Router])
+
+    :ok
+  end
+
+  test "generic action index route with required argument" do
+    response =
+      Domain
+      |> get("/search?query=elixir", status: 200)
+
+    assert response.resp_body == [
+             %{
+               "title" => "Result 1 for elixir",
+               "content" => "Content 1"
+             },
+             %{
+               "title" => "Result 2 for elixir",
+               "content" => "Content 2"
+             }
+           ]
+  end
+
+  test "generic action index route with optional argument" do
+    response =
+      Domain
+      |> get("/search?query=elixir&category=tutorial", status: 200)
+
+    assert response.resp_body == [
+             %{
+               "title" => "tutorial Result 1 for elixir",
+               "content" => "Category content 1"
+             },
+             %{
+               "title" => "tutorial Result 2 for elixir",
+               "content" => "Category content 2"
+             }
+           ]
+  end
+
+  test "generic action index route with missing required argument returns error" do
+    response =
+      Domain
+      |> get("/search", status: 400)
+
+    assert %{"errors" => errors} = response.resp_body
+    assert is_list(errors)
+    assert length(errors) > 0
+
+    required_error = Enum.find(errors, &(&1["code"] == "required"))
+    assert required_error, "Expected to find a 'required' error"
+
+    source_pointer = get_in(required_error, ["source", "pointer"])
+    assert source_pointer, "Expected source pointer to be present"
+
+    assert String.contains?(source_pointer, "query"),
+           "Expected source pointer '#{source_pointer}' to contain field name 'query'"
+  end
+end