Embeds in schemaless changesets

Questions / Help
,
1

Hello everyone. I want to use schemaless changesets to validate external data. And I wonder how to properly use embeds with them.

Let’s assume I want to validate the nested map under the user key in my params payload. And I want my data to be a map in the end. So to get this work I managed to write this “hack”:

defmodule Params do
  import Ecto.Changeset

  @user_types %{id: :integer}

  @user_fields Map.keys(@user_types)

  @types %{
    name: :string,
    page: :integer,
    page_size: :integer,
    ages: {:array, :integer},
    user:
      {:embed,
       elem(
         Ecto.ParameterizedType.init(Ecto.Embedded,
           cardinality: :one,
           related: __MODULE__,
           field: :user
         ),
         2
       )}
  }

  @default %{
    page: 1,
    page_size: 10
  }

  @fields Map.keys(@types) -- [:user]

  def build(entity \\ @default, attrs \\ %{}) do
    entity
    |> changeset(attrs)
    |> apply_action(:insert)
  end

  def changeset(entity, attrs) do
    {entity, @types}
    |> cast(attrs, @fields)
    |> cast_embed(:user, with: &user_changeset/2)
  end

  def user_changeset(entity, attrs) do
    {entity, @user_types}
    |> cast(attrs, @user_fields)
  end

  def __schema__(:primary_key), do: []
  def __struct__, do: %{}
end

Although it’s kinda working doesn’t seems good. As I need to define __schema__/1 and __struct__/0 functons with custom behavior while setting related key to not being relation module, but parent module.

I want to know better approaches to how to validate nested data using schemaless changesets. Or maybe that’s not proper usage of schemaless changeset. And I need to use schema/embedded_schema to avoid “hacking” ?

2

You should check out Drops which seems like it would be more suited to what you’re looking for. Sorry I don’t have a direct answer. I do use Ecto for non-database-backed validation but always with a(n embedded) schema. I’m actually not sure how it would work without one as the casting functions are looking at the schema definition for the types. But again, no experience with schemaless, so I’m not saying there is not a way for sure, just recommending Drops :slight_smile:

1 Like
3

When wanting to validate external data with Ecto like this and it’s a nested data structure, I prefer using embedded_schema over schemaless changesets (which I use when validating flat data structures). I’ve also used Goal, which is a wrapper around Ecto.

I’ve also been wanting to try the aforementioned Drops library, but have not yet done so.

2 Likes
4

FWIW, embedded_schema will define a __changeset__/0 function that’s otherwise identical to this code’s @types, and the only difference for cast passing in a struct vs a map is calling that function automatically:

vs

5

The reasons why I’m looking for a solution using schemaless changesets (instead of an easy solution with embedded schemas) are:

  1. I want my success payload to be a map. So I don’t need to invoke Map.from_struct/1 function recursively or define implementation of protocols (like Enumarable);
  2. I want my success payload to contain only those keys that were sent by a user. In some scenarios it’s important whether the key was explicitly set to nil or it wasn’t included in the payload;

There’re plenty of libraries that solves this problems with building schemas under the hood. But I look for more simpler solution that doesn’t require any external deps.

One more idea that I’ve got is define key with :map type. And writing in changeset custom function to put value after applying changes. The code for this solution:

defmodule NewParams do
    import Ecto.Changeset

    @user_types %{id: :integer}

    @user_fields Map.keys(@user_types)

    @types %{
      name: :string,
      page: :integer,
      page_size: :integer,
      ages: {:array, :integer},
      user: :map
    }

    @default %{
      page: 1,
      page_size: 10
    }

    @fields Map.keys(@types)

    def build(entity \\ @default, attrs \\ %{}) do
      @default
      |> Map.merge(entity)
      |> changeset(attrs)
      |> apply_action(:insert)
    end

    def changeset(entity, attrs) do
      {entity, @types}
      |> cast(attrs, @fields)
      |> cast_user()
    end

    def cast_user(%{changes: %{user: changes_user}} = changeset) do
      data_user = changeset.data[:user] || %{}

      case build_user(data_user, changes_user) do
        {:ok, user} ->
          put_change(changeset, :user, user)

        {:error, user_changeset} ->
          changeset
          |> put_change(:user, user_changeset)
          |> Map.put(:valid?, false)
      end
    end

    def cast_user(changeset), do: changeset

    def build_user(entity, attrs) do
      entity
      |> user_changeset(attrs)
      |> apply_action(:validate)
    end

    def user_changeset(entity, attrs) do
      {entity, @user_types}
      |> cast(attrs, @user_fields)
    end
  end

But not sure whether it’s better than using schemaless embed type. Still looking for solution