feat: validate field types in AshDynamo.EmbeddedType cast_input and cast_stored

Author: rauann

lib/ash_dynamo/embedded_type.ex

@@ -56,6 +56,13 @@ defmodule AshDynamo.EmbeddedType do
   3. Dumping the struct back to a plain map for DynamoDB storage (`dump_to_native/2`)
   4. Returning `cast_in_query?: false` to prevent Ash from loading through the type
 
+  ## Type Validation
+
+  Both `cast_input/2` and `cast_stored/2` validate each field through their respective
+  `Ash.Type` casting functions. If any field fails validation, the entire cast returns
+  `:error`. This ensures invalid data is caught on both writes and reads — a corrupted
+  DynamoDB record will raise an error immediately rather than propagating bad data.
+
   ## ExAws.Dynamo.Encodable
 
   The macro automatically implements the `ExAws.Dynamo.Encodable` protocol for the
@@ -77,7 +84,8 @@ defmodule AshDynamo.EmbeddedType do
       alias unquote(resource), as: Resource
 
       @resource unquote(resource)
-      @fields @resource |> Ash.Resource.Info.attributes() |> Enum.map(& &1.name)
+      @attributes Ash.Resource.Info.attributes(@resource)
+      @fields Enum.map(@attributes, & &1.name)
 
       @impl Ash.Type
       def storage_type(_constraints), do: :map
@@ -87,12 +95,7 @@ defmodule AshDynamo.EmbeddedType do
       def cast_input(%Resource{} = value, _constraints), do: {:ok, value}
 
       def cast_input(%{} = map, _constraints) do
-        attrs =
-          Map.new(@fields, fn field ->
-            {field, map[field] || map[to_string(field)]}
-          end)
-
-        {:ok, struct!(Resource, attrs)}
+        cast_fields(map, &Ash.Type.cast_input/3)
       end
 
       def cast_input(_value, _constraints), do: :error
@@ -102,12 +105,7 @@ defmodule AshDynamo.EmbeddedType do
       def cast_stored(%Resource{} = value, _constraints), do: {:ok, value}
 
       def cast_stored(%{} = map, _constraints) do
-        attrs =
-          Map.new(@fields, fn field ->
-            {field, map[field] || map[to_string(field)]}
-          end)
-
-        {:ok, struct!(Resource, attrs)}
+        cast_fields(map, &Ash.Type.cast_stored/3)
       end
 
       def cast_stored(_value, _constraints), do: :error
@@ -125,6 +123,27 @@ defmodule AshDynamo.EmbeddedType do
       @impl Ash.Type
       def cast_in_query?(_constraints), do: false
 
+      defp cast_fields(map, cast_fn) do
+        @attributes
+        |> Enum.reduce_while(%{}, fn attr, acc ->
+          raw =
+            case Map.fetch(map, attr.name) do
+              {:ok, value} -> value
+              :error -> map[to_string(attr.name)]
+            end
+
+          case cast_fn.(attr.type, raw, attr.constraints) do
+            {:ok, value} -> {:cont, Map.put(acc, attr.name, value)}
+            :error -> {:halt, :error}
+            {:error, _reason} -> {:halt, :error}
+          end
+        end)
+        |> case do
+          :error -> :error
+          attrs -> {:ok, struct!(Resource, attrs)}
+        end
+      end
+
       unless Enumerable.impl_for(struct!(Resource, %{})) do
         defimpl ExAws.Dynamo.Encodable, for: Resource do
           def encode(value, options) do

test/embedded_type_test.exs

@@ -7,6 +7,44 @@ defmodule AshDynamo.EmbeddedTypeTest do
 
   setup :migrate!
 
+  alias AshDynamo.Test.Types.Tag, as: TagType
+
+  describe "type casting" do
+    test "when map has valid values, casts successfully" do
+      assert {:ok, %Tag{name: "elixir", color: "purple"}} =
+               TagType.cast_input(%{name: "elixir", color: "purple"}, [])
+    end
+
+    test "when map has string keys, casts successfully" do
+      assert {:ok, %Tag{name: "elixir", color: "purple"}} =
+               TagType.cast_stored(%{"name" => "elixir", "color" => "purple"}, [])
+    end
+
+    test "when map has invalid type for a field, returns error" do
+      assert :error = TagType.cast_input(%{name: 123, color: "purple"}, [])
+    end
+
+    test "when map has invalid type from storage, returns error" do
+      assert :error = TagType.cast_stored(%{"name" => 123, "color" => "purple"}, [])
+    end
+
+    test "when value is nil, returns ok nil" do
+      assert {:ok, nil} = TagType.cast_input(nil, [])
+      assert {:ok, nil} = TagType.cast_stored(nil, [])
+    end
+
+    test "when value is already a struct, returns it as-is" do
+      tag = %Tag{name: "elixir", color: "purple"}
+      assert {:ok, ^tag} = TagType.cast_input(tag, [])
+      assert {:ok, ^tag} = TagType.cast_stored(tag, [])
+    end
+
+    test "when value is not a map, returns error" do
+      assert :error = TagType.cast_input("not a map", [])
+      assert :error = TagType.cast_stored("not a map", [])
+    end
+  end
+
   describe "embedded type with AshDynamo.EmbeddedType" do
     test "when creating with embedded structs, persists and reads back correctly" do
       tags = [
@@ -69,5 +107,31 @@ defmodule AshDynamo.EmbeddedTypeTest do
       assert tag.name == "test"
       assert tag.color == "red"
     end
+
+    test "when creating with invalid embedded field type, returns error" do
+      result =
+        Article
+        |> Ash.Changeset.for_create(:create, %{
+          slug: "invalid-tag",
+          title: "Invalid Tag",
+          tags: [%{name: 123, color: "red"}]
+        })
+        |> Ash.create()
+
+      assert {:error, %Ash.Error.Invalid{}} = result
+    end
+
+    test "when DynamoDB contains corrupted embedded data, reading raises error" do
+      ExAws.Dynamo.put_item("articles", %{
+        "slug" => "corrupted",
+        "title" => "Corrupted",
+        "tags" => [%{"name" => 123, "color" => "red"}]
+      })
+      |> ExAws.request!()
+
+      assert_raise Ash.Error.Unknown, fn ->
+        Ash.get!(Article, "corrupted")
+      end
+    end
   end
 end