Fix relationship issue 28

Author: lincolnhuls

lib/ash_json_api/controllers/helpers.ex

@@ -458,7 +458,7 @@ defmodule AshJsonApi.Controllers.Helpers do
   def add_to_relationship(request, relationship_name) do
     chain(request, fn %{assigns: %{result: result}} ->
       action = Ash.Resource.Info.primary_action!(request.resource, :update).name
-      values = normalize_relationship_identifiers(request)
+      values = relationship_change_values(request, relationship_name)
 
       result
       |> Ash.Changeset.new()
@@ -469,8 +469,24 @@ defmodule AshJsonApi.Controllers.Helpers do
       |> Ash.update(Request.opts(request))
       |> case do
         {:ok, updated} ->
+          identifier_meta =
+            case request.resource_identifiers do
+              list when is_list(list) ->
+                Enum.reduce(list, %{}, fn
+                  {%{id: id}, meta}, acc when is_map(meta) ->
+                    Map.put(acc, id, meta)
+
+                  _, acc ->
+                    acc
+                end)
+
+              _ ->
+                %{}
+            end
+
           request
           |> Request.assign(:result, Map.get(updated, relationship_name))
+          |> Request.assign(:relationship_identifier_meta, identifier_meta)
 
         {:error, error} ->
           Request.add_error(request, error, :add_to_relationship)
@@ -481,7 +497,7 @@ defmodule AshJsonApi.Controllers.Helpers do
   def replace_relationship(request, relationship_name) do
     chain(request, fn %{assigns: %{result: result}} ->
       action = Ash.Resource.Info.primary_action!(request.resource, :update).name
-      values = normalize_relationship_identifiers(request)
+      values = relationship_change_values(request, relationship_name)
 
       result
       |> Ash.Changeset.new()
@@ -504,7 +520,7 @@ defmodule AshJsonApi.Controllers.Helpers do
   def delete_from_relationship(request, relationship_name) do
     chain(request, fn %{assigns: %{result: result}} ->
       action = Ash.Resource.Info.primary_action!(request.resource, :update).name
-      values = normalize_relationship_identifiers(request)
+      values = relationship_change_values(request, relationship_name)
 
       result
       |> Ash.Changeset.new()
@@ -1089,4 +1105,45 @@ defmodule AshJsonApi.Controllers.Helpers do
         id
     end
   end
+
+  defp relationship_change_values(request, relationship_name) do
+    relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
+
+    meta_mapping =
+      AshJsonApi.Resource.Info.relationship_meta_mapping(request.resource, relationship_name)
+
+    if match?(%Ash.Resource.Relationships.ManyToMany{}, relationship) and meta_mapping != [] do
+      build_many_to_many_values(request.resource_identifiers, relationship, meta_mapping)
+    else
+      normalize_relationship_identifiers(request)
+    end
+  end
+
+  defp build_many_to_many_values(nil, _relationship, _meta_mapping), do: nil
+
+  defp build_many_to_many_values(list, relationship, meta_mapping) when is_list(list) do
+    destination_field = relationship.destination_attribute
+
+    Enum.map(list, fn
+      {%{id: id}, meta} ->
+        attrs =
+          Enum.reduce(meta_mapping, %{}, fn {meta_key, join_attr}, acc ->
+            case Map.fetch(meta, to_string(meta_key)) do
+              {:ok, value} -> Map.put(acc, join_attr, value)
+              :error -> acc
+            end
+          end)
+
+        if map_size(attrs) == 0 do
+          id
+        else
+          Map.put(attrs, destination_field, id)
+        end
+
+      %{id: id} ->
+        id
+    end)
+  end
+
+  defp build_many_to_many_values(%{id: id}, _relationship, _meta_mapping), do: id
 end

lib/ash_json_api/resource/info.ex

@@ -70,6 +70,26 @@ defmodule AshJsonApi.Resource.Info do
     Extension.get_opt(resource, [:json_api], :default_fields, nil, true)
   end
 
+  @doc """
+  Returns the `relationship_meta` config for the resource.
+
+  This is a keyword list keyed by relationship name, where each value is
+  another keyword list mapping JSON:API meta keys to join resource attributes.
+  """
+  def relationship_meta(resource) do
+    Extension.get_opt(resource, [:json_api], :relationship_meta, [], true)
+  end
+
+  @doc """
+  Returns the meta-to-join-attribute mapping for the given relationship name.
+
+  The result is a keyword list like `[note: :note_on_join]`, where the key is the
+  JSON:API meta key (as an atom) and the value is the join resource attribute.
+  """
+  def relationship_meta_mapping(resource, relationship_name) do
+    relationship_meta(resource)[relationship_name] || []
+  end
+
   defp camelize(name) do
     camelized = name |> to_string() |> Macro.camelize()
     {first, rest} = String.split_at(camelized, 1)

lib/ash_json_api/resource/resource.ex

@@ -557,6 +557,27 @@ defmodule AshJsonApi.Resource do
           "Whether or not to derive a filter parameter based on the sortable fields of the resource",
         default: true
       ],
+      relationship_meta: [
+        type: :keyword_list,
+        default: [],
+        doc: """
+        Configures how join-table fields are exposed via JSON:API `meta` on relationship
+        resource identifiers for many_to_many relationships.
+
+        The value is a keyword list keyed by relationship name, where each value is
+        another keyword list mapping JSON:API meta keys to join resource attributes.
+
+        For example, to expose a `:note` attribute on the join resource for the
+        `:tags` relationship:
+
+            relationship_meta [
+              tags: [note: :note]
+            ]
+
+        This enables both reading and writing join-table fields via the `meta` object
+        on relationship resource identifiers for that relationship.
+        """
+      ],
       field_names: [
         type: {:or, [{:literal, :camelize}, {:literal, :dasherize}, :keyword_list, {:fun, 1}]},
         doc: """

lib/ash_json_api/serializer.ex

@@ -12,13 +12,24 @@ defmodule AshJsonApi.Serializer do
       %{self: at_host(request, request.url)}
       |> add_related_link(request, source_record, relationship)
 
+    identifier_meta =
+      Map.get(request.assigns, :relationship_identifier_meta, %{})
+
     %{
       links: links,
       data:
-        Enum.map(
-          List.wrap(records),
-          &serialize_relationship_data(&1, source_record, relationship)
-        ),
+        Enum.map(List.wrap(records), fn record ->
+          payload = serialize_relationship_data(record, source_record, relationship)
+
+          case Map.fetch(identifier_meta, AshJsonApi.Resource.encode_primary_key(record)) do
+            {:ok, meta_for_identifier} when is_map(meta_for_identifier) and
+                                             map_size(meta_for_identifier) > 0 ->
+              Map.put(payload, :meta, meta_for_identifier)
+
+            _ ->
+              payload
+          end
+        end),
       meta: meta
     }
     |> Jason.encode!()
@@ -162,6 +173,56 @@ defmodule AshJsonApi.Serializer do
     |> add_relationship_meta(record, source_record, relationship)
   end
 
+  defp add_relationship_meta(
+         payload,
+         row,
+         source_record,
+         %Ash.Resource.Relationships.ManyToMany{} = relationship
+       ) do
+    source_resource = source_record.__struct__
+
+    meta_mapping =
+      AshJsonApi.Resource.Info.relationship_meta_mapping(source_resource, relationship.name)
+
+    if meta_mapping == [] do
+      payload
+    else
+      join_rows = Map.get(source_record, relationship.join_relationship)
+
+      if match?(%Ash.NotLoaded{}, join_rows) do
+        payload
+      else
+        destination_value = Map.get(row, relationship.destination_attribute)
+
+        meta =
+          join_rows
+          |> List.wrap()
+          |> Enum.find(fn join_row ->
+            Map.get(join_row, relationship.destination_attribute_on_join_resource) ==
+              destination_value
+          end)
+          |> case do
+            nil ->
+              %{}
+
+            join_row ->
+              Enum.reduce(meta_mapping, %{}, fn {meta_key, join_attr}, acc ->
+                case Map.fetch(join_row, join_attr) do
+                  {:ok, value} -> Map.put(acc, meta_key, value)
+                  :error -> acc
+                end
+              end)
+          end
+
+        if map_size(meta) == 0 do
+          payload
+        else
+          Map.put(payload, :meta, meta)
+        end
+      end
+    end
+  end
+
   defp add_relationship_meta(payload, _row, _source_record, _relationship) do
     payload
     # case relationship.join_attributes do

test/acceptance/relationships_test.exs

@@ -5,6 +5,8 @@
 defmodule AshJsonApi.Acceptance.RelationshipsTest do
   use ExUnit.Case, async: true
 
+  require Ash.Query
+
   defmodule Tag do
     use Ash.Resource,
       domain: AshJsonApi.Acceptance.RelationshipsTest.Domain,
@@ -55,10 +57,15 @@ defmodule AshJsonApi.Acceptance.RelationshipsTest do
 
     actions do
       defaults([:create, :read, :destroy])
+
+      update :update do
+        accept([:note])
+      end
     end
 
     attributes do
       uuid_primary_key(:id)
+      attribute(:note, :string)
     end
 
     relationships do
@@ -80,6 +87,10 @@ defmodule AshJsonApi.Acceptance.RelationshipsTest do
     json_api do
       type("person")
 
+      relationship_meta [
+        tags: [note: :note]
+      ]
+
       routes do
         base("/people")
         relationship :tags, :read
@@ -202,22 +213,28 @@ defmodule AshJsonApi.Acceptance.RelationshipsTest do
       ]
     }
 
-    @domain
-    |> post(
-      "/people/#{person.id}/relationships/tags",
-      body,
-      router: @router,
-      status: 200
-    )
-    |> assert_valid_resource_objects("tag", [tag.id])
-
-    @domain
-    |> get(
-      "/people/#{person.id}/relationships/tags",
-      router: @router,
-      status: 200
-    )
-    |> assert_valid_resource_objects("tag", [tag.id])
+    response =
+      @domain
+      |> post(
+        "/people/#{person.id}/relationships/tags",
+        body,
+        router: @router,
+        status: 200
+      )
+
+    assert_valid_resource_objects(response, "tag", [tag.id])
+
+    assert %{
+             "data" => [
+               %{
+                 "id" => id,
+                 "type" => "tag",
+                 "meta" => %{"note" => "any"}
+               }
+             ]
+           } = response.resp_body
+
+    assert id == tag.id
   end
 
   test "post_to_relationship accepts multiple identifiers" do