Add diff for many associations without primary keys

lib/ecto_diff.ex

@@ -303,37 +303,47 @@ defmodule EctoDiff do
   defp diff_association(previous, current, %{cardinality: :many, field: field, related: struct}, acc) do
     primary_key_fields = struct.__schema__(:primary_key)
 
-    if primary_key_fields == [],
-      do: raise("cannot determine difference in many association with no primary key for `#{struct}`")
-
-    {previous_map, keys} =
-      Enum.reduce(previous, {%{}, []}, fn x, {map, keys} ->
-        key = Map.take(x, primary_key_fields)
-        {Map.put(map, key, x), [key | keys]}
-      end)
-
-    {current_map, keys} =
-      Enum.reduce(current, {%{}, keys}, fn x, {map, keys} ->
-        key = Map.take(x, primary_key_fields)
-        {Map.put(map, key, x), [key | keys]}
-      end)
-
-    keys = keys |> Enum.reverse() |> Enum.uniq()
-
     diffs =
-      keys
-      |> Enum.map(fn key ->
-        prev_child = Map.get(previous_map, key)
-        current_child = Map.get(current_map, key)
+      if primary_key_fields == [] do
+        from = max(length(previous), length(current)) - 1
 
-        do_diff(prev_child, current_child)
-      end)
-      |> Enum.reject(&no_changes?/1)
+        from
+        |> Range.new(0)
+        |> Enum.map(fn i ->
+          prev_child = Enum.at(previous, i)
+          current_child = Enum.at(current, i)
 
-    if diffs == [] do
-      acc
-    else
-      [{field, diffs} | acc]
+          do_diff(prev_child, current_child)
+        end)
+      else
+        {previous_map, keys} =
+          Enum.reduce(previous, {%{}, []}, fn x, {map, keys} ->
+            key = Map.take(x, primary_key_fields)
+            {Map.put(map, key, x), [key | keys]}
+          end)
+
+        {current_map, keys} =
+          Enum.reduce(current, {%{}, keys}, fn x, {map, keys} ->
+            key = Map.take(x, primary_key_fields)
+            {Map.put(map, key, x), [key | keys]}
+          end)
+
+        keys
+        |> Enum.reverse()
+        |> Enum.uniq()
+        |> Enum.map(fn key ->
+          prev_child = Map.get(previous_map, key)
+          current_child = Map.get(current_map, key)
+
+          do_diff(prev_child, current_child)
+        end)
+      end
+
+    diffs
+    |> Enum.reject(&no_changes?/1)
+    |> case do
+      [] -> acc
+      changed -> [{field, changed} | acc]
     end
   end
 

priv/repo/migrations/20220113193719_create_boxes.exs

@@ -0,0 +1,9 @@
+defmodule InventoryCore.Repo.Migrations.CreateBoxes do
+  use Ecto.Migration
+
+  def change do
+    create table(:boxes) do
+      add :shapes, {:array, :map}, default: []
+    end
+  end
+end

test/ecto_diff_test.exs

@@ -743,5 +743,149 @@ defmodule EctoDiffTest do
                }
              } = diff
     end
+
+    # Embeds Many Association without primary key
+
+    test "update with embeds_many while adding, shuffling and removing records without pk" do
+      {:ok, initial} =
+        %{shapes: [%{angles: 1}, %{angles: 2}]}
+        |> Box.new()
+        |> Repo.insert()
+
+      assert {:ok, :unchanged} = EctoDiff.diff(initial, initial)
+
+      {:ok, added} =
+        initial
+        |> Box.update(%{shapes: [%{angles: 1}, %{angles: 2}, %{angles: 3}]})
+        |> Repo.update()
+
+      assert {
+               :ok,
+               %EctoDiff{
+                 struct: Box,
+                 effect: :changed,
+                 changes: %{
+                   shapes: [
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :added,
+                       changes: %{angles: {nil, 3}}
+                     }
+                   ]
+                 }
+               }
+             } = EctoDiff.diff(initial, added)
+
+      {:ok, shuffled} =
+        added
+        |> Box.update(%{shapes: [%{angles: 3}, %{angles: 1}, %{angles: 2}]})
+        |> Repo.update()
+
+      assert {:ok,
+              %EctoDiff{
+                struct: Box,
+                effect: :changed,
+                changes: %{
+                  shapes: [
+                    %EctoDiff{
+                      struct: Shape,
+                      effect: :changed,
+                      changes: %{angles: {3, 2}}
+                    },
+                    %EctoDiff{
+                      struct: Shape,
+                      effect: :changed,
+                      changes: %{angles: {2, 1}}
+                    },
+                    %EctoDiff{
+                      struct: Shape,
+                      effect: :changed,
+                      changes: %{angles: {1, 3}}
+                    }
+                  ]
+                }
+              }} = EctoDiff.diff(added, shuffled)
+
+      {:ok, removed_first} =
+        added
+        |> Box.update(%{shapes: [%{angles: 2}, %{angles: 3}]})
+        |> Repo.update()
+
+      assert {
+               :ok,
+               %EctoDiff{
+                 struct: Box,
+                 effect: :changed,
+                 changes: %{
+                   shapes: [
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :deleted,
+                       changes: %{}
+                     },
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :changed,
+                       changes: %{angles: {2, 3}}
+                     },
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :changed,
+                       changes: %{angles: {1, 2}}
+                     }
+                   ]
+                 }
+               }
+             } = EctoDiff.diff(added, removed_first)
+
+      {:ok, removed_last} =
+        added
+        |> Box.update(%{shapes: [%{angles: 1}, %{angles: 2}]})
+        |> Repo.update()
+
+      assert {
+               :ok,
+               %EctoDiff{
+                 struct: Box,
+                 effect: :changed,
+                 changes: %{
+                   shapes: [
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :deleted,
+                       changes: %{}
+                     }
+                   ]
+                 }
+               }
+             } = EctoDiff.diff(added, removed_last)
+
+      {:ok, removed_middle} =
+        added
+        |> Box.update(%{shapes: [%{angles: 1}, %{angles: 3}]})
+        |> Repo.update()
+
+      assert {
+               :ok,
+               %EctoDiff{
+                 struct: Box,
+                 effect: :changed,
+                 changes: %{
+                   shapes: [
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :deleted,
+                       changes: %{}
+                     },
+                     %EctoDiff{
+                       struct: Shape,
+                       effect: :changed,
+                       changes: %{angles: {2, 3}}
+                     }
+                   ]
+                 }
+               }
+             } = EctoDiff.diff(added, removed_middle)
+    end
   end
 end

test/support/data_case.ex

@@ -7,7 +7,7 @@ defmodule EctoDiff.DataCase do
 
   using do
     quote do
-      alias EctoDiff.{Owner, Pet, Repo}
+      alias EctoDiff.{Box, Owner, Pet, Repo, Shape}
 
       import EctoDiff.DataCase
     end

test/support/test_schemas/box.ex

@@ -0,0 +1,19 @@
+defmodule EctoDiff.Box do
+  @moduledoc false
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  schema("boxes") do
+    embeds_many :shapes, EctoDiff.Shape, on_replace: :delete
+  end
+
+  def new(params), do: changeset(%__MODULE__{}, params)
+  def update(struct, params), do: changeset(struct, params)
+
+  defp changeset(struct, params) do
+    struct
+    |> cast(params, [])
+    |> cast_embed(:shapes)
+  end
+end

test/support/test_schemas/shape.ex

@@ -0,0 +1,13 @@
+defmodule EctoDiff.Shape do
+  @moduledoc false
+
+  use Ecto.Schema
+  import Ecto.Changeset
+
+  @primary_key false
+  embedded_schema do
+    field :angles, :integer
+  end
+
+  def changeset(struct, params), do: cast(struct, params, [:angles])
+end