Merge remote-tracking branch 'GitHub/main' into includes-duplicates

Author: 3h15

lib/ash_json_api/includes/includer.ex

@@ -38,6 +38,11 @@ defmodule AshJsonApi.Includes.Includer do
     includes_keyword
     |> Enum.reduce({preloaded, includes_map}, fn
       {relationship, further}, {preloaded_without_linkage, includes_map} ->
+        linkage_only? =
+          case further do
+            %{__linkage_only__: true} -> true
+            _ -> false
+          end
         {related, includes_map} =
           preloaded
           |> Enum.flat_map(fn record ->
@@ -62,22 +67,32 @@ defmodule AshJsonApi.Includes.Includer do
           )
 
         includes_map =
-          related
-          |> List.wrap()
-          |> Enum.reduce(includes_map, fn related_item, includes_map ->
-            type = AshJsonApi.Resource.Info.type(related_item)
-            id = AshJsonApi.Resource.encode_primary_key(related_item)
-
-            case Map.fetch(includes_map, {type, id}) do
-              {:ok, _} ->
-                Map.update!(includes_map, {type, id}, fn existing ->
-                  merge_linkages(existing, related_item)
-                end)
-
-              :error ->
-                Map.put(includes_map, {type, id}, Map.put_new(related_item, :__linkage__, %{}))
-            end
-          end)
+          if linkage_only? do
+            includes_map
+          else
+            related
+            |> List.wrap()
+            |> Enum.reduce(includes_map, fn related_item, includes_map ->
+              # On construit la clé {type, id}
+              type = AshJsonApi.Resource.Info.type(related_item)
+              id = AshJsonApi.Resource.encode_primary_key(related_item)
+
+              # On ajoute le record dans includes_map
+              case Map.fetch(includes_map, {type, id}) do
+                {:ok, _} ->
+                  # La clé existe déjà, on merge les linkages
+                  Map.update!(includes_map, {type, id}, fn existing ->
+                    # On merge les linkages en une liste
+                    merge_linkages(existing, related_item)
+                  end)
+
+                :error ->
+                  # La clé n'existe pas, on l'ajoute avec le linkage, et un linkage vide
+                  # si il n'existe pas déjà,
+                  Map.put(includes_map, {type, id}, Map.put_new(related_item, :__linkage__, %{}))
+              end
+            end)
+          end
 
         {preloaded_with_linkage, includes_map}
     end)

lib/ash_json_api/request.ex

@@ -680,11 +680,28 @@ defmodule AshJsonApi.Request do
     )
   end
 
-  defp set_include_queries(includes, fields, field_inputs, filters, sorts, resource, path \\ []) do
+  defp set_include_queries(includes, fields, field_inputs, filters, sorts, resource, path \\ [])
+
+  defp set_include_queries(:linkage_only, _, _, _, _, _, _), do: []
+
+  defp set_include_queries(includes, fields, field_inputs, filters, sorts, resource, path) do
+    includes =
+      Enum.reduce(
+        AshJsonApi.Resource.Info.always_include_linkage(resource),
+        includes,
+        fn key, includes ->
+          if Keyword.has_key?(includes, key) do
+            includes
+          else
+            Keyword.put(includes, key, :linkage_only)
+          end
+        end
+      )
+
     Enum.map(includes, fn {key, nested} ->
       related = public_related(resource, key)
 
-      nested =
+      nested_queries =
         set_include_queries(nested, fields, field_inputs, filters, sorts, related, path ++ [key])
 
       related_field_inputs = Map.get(field_inputs, related, %{})
@@ -704,12 +721,13 @@ defmodule AshJsonApi.Request do
             value -> {field, value}
           end
         end)
-        |> Kernel.++(nested)
+        |> Kernel.++(nested_queries)
 
       new_query =
         related
         |> Ash.Query.new()
         |> Ash.Query.load(load)
+        |> Map.put(:__linkage_only__, nested == :linkage_only)
 
       filtered_query =
         case Map.fetch(filters, path ++ [key]) do

lib/ash_json_api/resource/info.ex

@@ -15,6 +15,10 @@ defmodule AshJsonApi.Resource.Info do
     Extension.get_opt(resource, [:json_api], :derive_sort, true, false)
   end
 
+  def always_include_linkage(resource) do
+    Extension.get_opt(resource, [:json_api], :always_include_linkage, [], false)
+  end
+
   def includes(resource) do
     Extension.get_opt(resource, [:json_api], :includes, [], false)
   end

lib/ash_json_api/resource/resource.ex

@@ -494,6 +494,12 @@ defmodule AshJsonApi.Resource do
         type: :string,
         doc: "The resource identifier type of this resource in JSON:API"
       ],
+      always_include_linkage: [
+        type: {:list, :atom},
+        doc:
+          "A list of relationships that should always have their linkage included in the resource",
+        default: []
+      ],
       includes: [
         type: {:wrap_list, :any},
         default: [],

lib/ash_json_api/serializer.ex

@@ -577,9 +577,16 @@ defmodule AshJsonApi.Serializer do
           type: AshJsonApi.Resource.Info.type(destination)
         })
 
+      %{__linkage__: %{^name => []}} ->
+        Map.put(payload, :data, nil)
+
       # There could be another case here if a bug in the system gave us a list
       # of more than one shouldn't happen though
 
+      %{__linkage__: %{^name => other}} ->
+        IO.inspect(other, label: "Unexpected record for relationship #{name}")
+        payload
+
       _ ->
         payload
     end