Something like this:

defmodule MapFromArray do
  use Ecto.Type

  def type, do: {:array, :map}

  def load(data) do
    with {:ok, list} <- Ecto.Type.load(type(), data) do
      {:ok, Map.new(list, &{&1["name"], &1["amount"]})}
    end
  end

  def embed_as(_), do: :dump

  […]
end

defmodule ReadParent do
  use Ecto.Schema

  schema "parents" do
    field :children, MapFromArray
  end
end
  
  
Repo.insert_all("parents", [
  %{children: [%{name: "abc", amount: 2}, %{name: "def", amount: 5}]}
])

[%{children: %{"abc" => 2, "def" => 5}}] = Repo.all(ReadParent)

Could even consider Ecto.ParameterizedType if you don’t like hardcoding key/value keys.

This is full of caveats:

• inputs_for only works for related assocs or embeds, which are one or a list of related records. There’s nothing like a map for related records.
• The :map or {:map, value_type} native types of ecto are not supported by phoenix form handling natively. You can make things work by manually creating input names and assigning values to inputs, but it’s not covered ootb. Also using an ecto type over a relationship means you forego a bunch of their features like e.g. per item errors, sort/drop support, likely a few more…
• How do you even model a “map” using form inputs in an abstract manner in the first place. There’s surely many specific examples of how to do that, but I’m not sure there’s a generic version phoenix could implement.

So really I’d treat the data like you do and let the goal of it becoming a map be an implementation detail. You could consider separating the “write model” from the “read model” here and let the read model read the data from the db in the correct format / into a :map field.

I got this to work recursively, but I think I have a more precise question now: Is there some public Ecto API to dump a whole struct?

When writing testcases for nested datasets I figured out that Ecto probably uses something along the lines of Ecto.Type.dump(MyModule.__schema__(:type, :field))to dump individual fields. So I’m now doing the same when dumping map values. The new implementation looks like this:

  def dump(data, dumper, params) when is_map(data) do
    {:ok, Map.values(data) |> Enum.map(& dump_struct(&1, dumper, params))}
  end

  # Checks whether any of the fields on the given struct are an embedded
  # map themselves. If this is the case the field is dumped with the type
  # information attached to the schema.
  defp dump_struct(data, dumper, params) when is_struct(data, params.value) do
    keys = data |> Map.from_struct() |> Map.keys()
    Enum.reduce(keys, data, fn key, data ->
      case params.value.__schema__(:type, key) do
        {:parameterized, {EctoSupport.EmbeddedMap, _params}} = t ->
          {:ok, transformed} = dumper.(t, get_in(data, [Access.key!(key)]))
          put_in(data, [Access.key!(key)], transformed)
        _ ->
          data
      end
    end)
  end

This gives me recursion on my own types and has so far passed my synthetic and practical tests. But if feels weird as I …

• enumerate over all fields instead of somehow specifically grabbing those with matching types …
• needed to jump through the Access.key! hoops to do the manipulation on the struct on the fly …
• and disregard every field that is not a EmbeddedMap.

So there is probably a nicer way to do this.