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.

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

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

This thread sparkled my curiosity, was it possible to use schemaless changesets with nested data?

It could simplify a form I’m writing that edits multiple entities at once (and they could be expressed as a multi-level map).

should be hackable according to the first message