Remove aalang files and update JSON handling

Author: lincolnhuls

lib/ash_json_api/controllers/helpers.ex

@@ -458,6 +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
+      relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
       values = relationship_change_values(request, relationship_name)
 
       result
@@ -469,24 +470,15 @@ 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
+          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)
 
-          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)
+          end
 
         {:error, error} ->
           Request.add_error(request, error, :add_to_relationship)
@@ -497,6 +489,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
+      relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
       values = relationship_change_values(request, relationship_name)
 
       result
@@ -508,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)
@@ -520,6 +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
+      relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
       values = relationship_change_values(request, relationship_name)
 
       result
@@ -534,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)
@@ -1110,7 +1118,7 @@ defmodule AshJsonApi.Controllers.Helpers do
     relationship = Ash.Resource.Info.relationship(request.resource, relationship_name)
 
     meta_mapping =
-      AshJsonApi.Resource.Info.relationship_meta_mapping(request.resource, relationship_name)
+      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)
@@ -1146,4 +1154,14 @@ defmodule AshJsonApi.Controllers.Helpers do
   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

@@ -80,14 +80,56 @@ defmodule AshJsonApi.Resource.Info do
     Extension.get_opt(resource, [:json_api], :relationship_meta, [], true)
   end
 
+  @doc """
+  Returns the `relationship_meta_in` config for the resource.
+  Falls back to `relationship_meta` when not set.
+  """
+  def relationship_meta_in(resource) do
+    Extension.get_opt(
+      resource,
+      [:json_api],
+      :relationship_meta_in,
+      relationship_meta(resource),
+      true
+    )
+  end
+
+  @doc """
+  Returns the `relationship_meta_out` config for the resource.
+  Falls back to `relationship_meta` when not set.
+  """
+  def relationship_meta_out(resource) do
+    Extension.get_opt(
+      resource,
+      [:json_api],
+      :relationship_meta_out,
+      relationship_meta(resource),
+      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
+
   @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] || []
+    relationship_meta_in_mapping(resource, relationship_name)
   end
 
   defp camelize(name) do

lib/ash_json_api/resource/resource.ex

@@ -561,7 +561,10 @@ defmodule AshJsonApi.Resource do
         type: :keyword_list,
         default: [],
         doc: """
-        Configures how join-table fields are exposed via JSON:API `meta` on relationship
+        Backward-compatible shorthand for setting both `relationship_meta_in` and
+        `relationship_meta_out` to the same mapping.
+
+        Configures how join-table fields are mapped 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
@@ -578,6 +581,22 @@ defmodule AshJsonApi.Resource do
         on relationship resource identifiers for that relationship.
         """
       ],
+      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.
+        """
+      ],
+      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.
+        """
+      ],
       field_names: [
         type: {:or, [{:literal, :camelize}, {:literal, :dasherize}, :keyword_list, {:fun, 1}]},
         doc: """

lib/ash_json_api/serializer.ex

@@ -12,24 +12,13 @@ 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), 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),
+        Enum.map(
+          List.wrap(records),
+          &serialize_relationship_data(&1, source_record, relationship)
+        ),
       meta: meta
     }
     |> Jason.encode!()
@@ -182,7 +171,7 @@ defmodule AshJsonApi.Serializer do
     source_resource = source_record.__struct__
 
     meta_mapping =
-      AshJsonApi.Resource.Info.relationship_meta_mapping(source_resource, relationship.name)
+      AshJsonApi.Resource.Info.relationship_meta_out_mapping(source_resource, relationship.name)
 
     if meta_mapping == [] do
       payload

test/acceptance/relationships_test.exs

@@ -87,9 +87,9 @@ defmodule AshJsonApi.Acceptance.RelationshipsTest do
     json_api do
       type("person")
 
-      relationship_meta [
-        tags: [note: :note]
-      ]
+      relationship_meta_in(tags: [note: :note])
+
+      relationship_meta_out(tags: [note_out: :note])
 
       routes do
         base("/people")
@@ -209,7 +209,7 @@ 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"}}
       ]
     }
 
@@ -229,12 +229,16 @@ defmodule AshJsonApi.Acceptance.RelationshipsTest do
                %{
                  "id" => id,
                  "type" => "tag",
-                 "meta" => %{"note" => "any"}
+                 "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