improvement: support mapping join resource keys to meta (#419)

Author: lincolnhuls

lib/ash_json_api/controllers/helpers.ex

@@ -458,7 +458,8 @@ 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)
+      relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
+      values = relationship_change_values(request, relationship_name)
 
       result
       |> Ash.Changeset.new()
@@ -469,8 +470,15 @@ defmodule AshJsonApi.Controllers.Helpers do
       |> Ash.update(Request.opts(request))
       |> case do
         {:ok, updated} ->
-          request
-          |> Request.assign(:result, Map.get(updated, relationship_name))
+          case load_result_for_relationship_meta(updated, relationship, request) do
+            {:ok, updated_with_join_rows} ->
+              request
+              |> Request.assign(:result, Map.get(updated_with_join_rows, relationship_name))
+              |> Request.assign(:record_from_path, updated_with_join_rows)
+
+            {:error, error} ->
+              Request.add_error(request, error, :add_to_relationship)
+          end
 
         {:error, error} ->
           Request.add_error(request, error, :add_to_relationship)
@@ -481,7 +489,8 @@ 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)
+      relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
+      values = relationship_change_values(request, relationship_name)
 
       result
       |> Ash.Changeset.new()
@@ -492,8 +501,15 @@ defmodule AshJsonApi.Controllers.Helpers do
       |> Ash.update(Request.opts(request))
       |> case do
         {:ok, updated} ->
-          request
-          |> Request.assign(:result, Map.get(updated, relationship_name))
+          case load_result_for_relationship_meta(updated, relationship, request) do
+            {:ok, updated_with_join_rows} ->
+              request
+              |> Request.assign(:result, Map.get(updated_with_join_rows, relationship_name))
+              |> Request.assign(:record_from_path, updated_with_join_rows)
+
+            {:error, error} ->
+              Request.add_error(request, error, :replace_relationship)
+          end
 
         {:error, error} ->
           Request.add_error(request, error, :replace_relationship)
@@ -504,7 +520,8 @@ 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)
+      relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
+      values = relationship_change_values(request, relationship_name)
 
       result
       |> Ash.Changeset.new()
@@ -518,8 +535,15 @@ defmodule AshJsonApi.Controllers.Helpers do
           |> Ash.load(fields(request, request.resource), Request.load_opts(request))
           |> case do
             {:ok, updated} ->
-              request
-              |> Request.assign(:result, Map.get(updated, relationship_name))
+              case load_result_for_relationship_meta(updated, relationship, request) do
+                {:ok, updated_with_join_rows} ->
+                  request
+                  |> Request.assign(:result, Map.get(updated_with_join_rows, relationship_name))
+                  |> Request.assign(:record_from_path, updated_with_join_rows)
+
+                {:error, error} ->
+                  Request.add_error(request, error, :delete_from_relationship)
+              end
 
             {:error, error} ->
               Request.add_error(request, error, :delete_from_relationship)
@@ -1089,4 +1113,55 @@ 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_in_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
+
+  defp load_result_for_relationship_meta(updated, relationship, request) do
+    case relationship do
+      %Ash.Resource.Relationships.ManyToMany{join_relationship: join_relationship} ->
+        Ash.load(updated, [join_relationship], Request.load_opts(request))
+
+      _ ->
+        {:ok, updated}
+    end
+  end
 end

lib/ash_json_api/resource/info.ex

@@ -70,6 +70,34 @@ defmodule AshJsonApi.Resource.Info do
     Extension.get_opt(resource, [:json_api], :default_fields, nil, true)
   end
 
+  @doc """
+  Returns the `relationship_meta_in` config for the resource.
+  """
+  def relationship_meta_in(resource) do
+    Extension.get_opt(resource, [:json_api], :relationship_meta_in, [], true)
+  end
+
+  @doc """
+  Returns the `relationship_meta_out` config for the resource.
+  """
+  def relationship_meta_out(resource) do
+    Extension.get_opt(resource, [:json_api], :relationship_meta_out, [], true)
+  end
+
+  @doc """
+  Returns the incoming meta-to-join-attribute mapping for the given relationship name.
+  """
+  def relationship_meta_in_mapping(resource, relationship_name) do
+    relationship_meta_in(resource)[relationship_name] || []
+  end
+
+  @doc """
+  Returns the outgoing meta-to-join-attribute mapping for the given relationship name.
+  """
+  def relationship_meta_out_mapping(resource, relationship_name) do
+    relationship_meta_out(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,28 @@ defmodule AshJsonApi.Resource do
           "Whether or not to derive a filter parameter based on the sortable fields of the resource",
         default: true
       ],
+      relationship_meta_in: [
+        type: :keyword_list,
+        default: [],
+        doc: """
+        Configures how incoming JSON:API `meta` keys on relationship resource identifiers
+        map to join resource attributes for many_to_many relationship writes.
+
+        Use together with `relationship_meta_out` for reads. Each relationship you want to
+        support must declare both mappings explicitly.
+        """
+      ],
+      relationship_meta_out: [
+        type: :keyword_list,
+        default: [],
+        doc: """
+        Configures how join resource attributes map to outgoing JSON:API `meta` keys on
+        relationship resource identifiers for many_to_many relationship reads.
+
+        Use together with `relationship_meta_in` for writes. Each relationship you want to
+        support must declare both mappings explicitly.
+        """
+      ],
       field_names: [
         type: {:or, [{:literal, :camelize}, {:literal, :dasherize}, :keyword_list, {:fun, 1}]},
         doc: """

lib/ash_json_api/serializer.ex

@@ -162,6 +162,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_out_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_in(tags: [note: :note])
+
+      relationship_meta_out(tags: [note_out: :note])
+
       routes do
         base("/people")
         relationship :tags, :read
@@ -198,26 +209,36 @@ defmodule AshJsonApi.Acceptance.RelationshipsTest do
 
     body = %{
       "data" => [
-        %{"type" => "tag", "id" => tag.id, "meta" => %{"note" => "any"}}
+        %{"type" => "tag", "id" => tag.id, "meta" => %{"note" => "any", "ignored" => "value"}}
       ]
     }
 
-    @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" => meta
+               }
+             ]
+           } = response.resp_body
+
+    assert id == tag.id
+    assert Map.has_key?(meta, "note_out")
+    refute Map.get(meta, "note_out") == "any"
+    refute Map.has_key?(meta, "ignored")
+    refute Map.has_key?(meta, "note")
   end
 
   test "post_to_relationship accepts multiple identifiers" do