Convert deeply nested Elixir struct into map

map_from_deep_struct.ex

defmodule MapFromDeepStruct do
  def from_deep_struct(%{} = map), do: convert(map)

  defp convert(data) when is_struct(data) do
    data |> Map.from_struct() |> convert()
  end

  defp convert(data) when is_map(data) do
    for {key, value} <- data, reduce: %{} do
      acc ->
        case key do
          :__meta__ ->
            acc

          other ->
            Map.put(acc, other, convert(value))
        end
    end
  end

  defp convert(other), do: other
end

map_from_deep_struct_test.exs

defmodule MapFromDeepStructTest do
  defmodule DummyA do
    @type t() :: %__MODULE__{
            name: String.t(),
            address: DummyB.t()
          }

    defstruct name: "", address: nil
  end

  defmodule DummyB do
    @type t() :: %__MODULE__{
            street: String.t()
          }

    defstruct street: ""
  end
  
  defmodule DummyC do
    use Ecto.Schema

    schema "dummies" do
      field :street, :string
    end
  end

  use ExUnit.Case

  setup_all do
    {:ok, expected: %{name: "John", address: %{street: "Baker"}}}
  end

  test "struct in struct", state do
    input = %DummyA{
      name: "John",
      address: %DummyB{street: "Baker"}
    }

    assert MapFromDeepStruct.from_deep_struct(input) == state.expected
  end

  test "struct in map", state do
    input = %{
      name: "John",
      address: %DummyB{street: "Baker"}
    }

    assert MapFromDeepStruct.from_deep_struct(input) == state.expected
  end

  test "map in map", state do
    input = %{
      name: "John",
      address: %{street: "Baker"}
    }

    assert MapFromDeepStruct.from_deep_struct(input) == state.expected
  end
  
  test "ecto struct" do
    input = %DummyC{street: "Baker"}

    assert Poc.MapFromDeepStruct.from_deep_struct(input) == %{id: nil, street: "Baker"}
  end
end

If anyone seeing this wants to account for lists as well, simply add:

defp convert(data) when is_list(data) do
  Enum.map(data, fn item ->
    convert(item)
  end)
end