JSON API response to Structs using Ecto Schema

Poison and its protocols are designed for this.

There might be alternatives available, but poison is in phoenix by default.

Thanks @NobbZ. I have written my own implementation of Poison.Decoder in the past, but thought I saw somewhere that this was possible with Ecto and was curious how it was done.

Via poison’s protocol it is yes.

Hi @jeromedoyle,

If you want to use Ecto rather than Poison’s protocols, here is an example.

I’m just casting the API response but you could also add Changeset validations if you want and only returning if valid? == true. Hope this helps!

defmodule MyApp.SmartyUSStreet.Response do
  use Ecto.Schema

  alias MyApp.Addresses.Address

  import Ecto.Changeset

  @primary_key false
  embedded_schema do
    field :input_id
    field :input_index, :integer
    field :candidate_index, :integer
    field :addressee
    field :delivery_line_1
    field :delivery_line_2
    field :last_line
    field :delivery_point_barcode

    embeds_one :components, Components do
      field :street_name
      field :city_name
      field :default_city_name
      field :state_abbreviation
      field :zipcode
      field :plus4_code
      # ...
    end

    embeds_one :metadata, Metadata do
      field :record_type
      field :zip_type
      field :county_fips
      field :county_name
      # ...
    end

    embeds_one :analysis, Analysis do
      field :dpv_match_code
      field :dpv_footnotes
      field :dpv_cmra
      # ...
    end
  end

  def list_from_json(data) when is_binary(data) do
    Poison.decode!(data) |> list_from_json()
  end

  def list_from_json(data) when is_list(data) do
    data
    |> Enum.map(fn x -> list_from_json(x) end)
    |> List.flatten()
  end

  def list_from_json(data) when is_map(data) do
    %__MODULE__{}
    |> cast(data, castable_fields(__MODULE__))
    |> cast_embed(:components, with: &embedded_changeset/2)
    |> cast_embed(:metadata, with: &embedded_changeset/2)
    |> cast_embed(:analysis, with: &embedded_changeset/2)
    |> apply_changes()
    |> List.wrap()
  end

  def castable_fields(schema_module) do
    schema_module.__schema__(:fields) -- (schema_module.__schema__(:embeds) ++ schema_module.__schema__(:associations))
  end

  def embedded_changeset(struct, data) do
    struct |> Ecto.Changeset.cast(data, castable_fields(struct.__struct__))
  end
end

Thanks for the example @tme_317. This may help me figure it out. I’m just not seeing anywhere that dictates user["_embedded"]["addresses"] would be mapped to %User{addresses: ...} instead of %User{_embedded: %{addresses: ...}} . My lack of familiarity with Ecto probably doesn’t help either.

One alternative valid way is to use Jason and plain structs with @type t :: ... definitions plus Domo for validation.

Considering MapShaper module from this example app, the structs can be defined like:

defmodule Address do
  @moduledoc false

  use Domo

  defstruct [city: "", state: ""]

  @type t :: %__MODULE__{city: String.t(), state: String.t()}
end

defmodule User do
  @moduledoc false

  use Domo

  today = NaiveDateTime.utc_now()
  defstruct [id: 0, fname: "", lname: "", email: "", createdOn: today, updatedOn: today, addresses: [%Address{}]]

  @type t :: %__MODULE__{
    id: non_neg_integer(),
    fname: String.t(),
    lname: String.t(),
    email: String.t(),
    createdOn: NaiveDateTime.t(),
    updatedOn: NaiveDateTime.t(),
    addresses: [Address.t()]
  }

  defimpl MapShaper.Target do
    def translate_source_map(_value, map) do
      addresses = get_in(map, ["_embedded", "addresses"])
      created_on = map |> get_in(["createdOn"]) |> parse_date()
      updated_on = map |> get_in(["updatedOn"]) |> parse_date()

      map
      |> Map.put("addresses", addresses)
      |> Map.put("createdOn", created_on)
      |> Map.put("updatedOn", updated_on)
    end

    defp parse_date(str) do
      str
      |> NaiveDateTime.from_iso8601()
      |> then(fn
        {:ok, date_time} -> date_time
        _ -> nil
      end)
    end
  end
end

And parsing + validation that looks like:

with {:ok, binary} <- File.read("user.json"),
      {:ok, map} <- Jason.decode(binary),
      user = MapShaper.from_map(%User{}, map),
      {:ok, user} <- User.ensure_type_ok(user) do
  user
end

Returns the following nested struct for the valid input:

%User{
  id: 283230,
  fname: "John",
  lname: "Smith",
  email: "john.smith@example.com",
  createdOn: ~N[2016-03-31 10:49:11.386],
  updatedOn: ~N[2016-10-31 16:36:12.968],
  addresses: [
    %Address{city: "Minneapolis", state: "MN"},
    %Address{city: "New Orleans", state: "LA"}
  ]
}