Polymorphic embeds are not kept as changesets but are turned into structs - as opposed to what happens with ordinary embeds

[maxmarcon]

Observed behavior: When I build a changeset with ordinary embeds, these embeds stay changesets. When I build the changesets with polymorphic embeds, the embeds are turned into structs if they're valid.

Expected behavior: I would expect polymorphic embeds to be kept as changeset until I call apply_changes or apply_action on the parent changeset, just as normal embeds do.

Ecto version: 3.9.4
polymorphic_embed version: 3.0.5

Here's a working example:

Mix.install([{:ecto, "~> 3.9.4"}, {:polymorphic_embed, "~> 3.0.5"}])

defmodule ChildSchema do
  use Ecto.Schema
  import Ecto.Changeset

  embedded_schema do
    field(:name, :string)
    field(:age, :integer)
  end

  def changeset(source \\ %__MODULE__{}, changes) do
    cast(source, changes, [:name, :age])
  end
end

defmodule ParentSchema do
  use Ecto.Schema
  import Ecto.Changeset

  embedded_schema do
    embeds_many(:children, ChildSchema)
  end

  def changeset(source \\ %__MODULE__{}, changes) do
    cast(source, changes, [])
    |> cast_embed(:children)
  end
end

defmodule ParentSchemaWithPolymorphicChildren do
  use Ecto.Schema
  import PolymorphicEmbed
  import Ecto.Changeset

  embedded_schema do
    polymorphic_embeds_many(:children,
      types: [
        child_schema: ChildSchema
      ],
      on_replace: :delete,
      on_type_not_found: :raise
    )
  end

  def changeset(source \\ %__MODULE__{}, changes) do
    cast(source, changes, [])
    |> cast_polymorphic_embed(:children)
  end
end

ParentSchema.changeset(%{children: [%{name: "Tic", age: 10}, %{name: "Tac", age: 12}]})
|> IO.inspect(label: "changeset for schema with traditional embeds: embeds are still changesets")

ParentSchemaWithPolymorphicChildren.changeset(%{
  children: [
    %{name: "Tic", age: 10, __type__: "child_schema"},
    %{name: "Tac", age: 12, __type__: "child_schema"}
  ]
})
|> IO.inspect(
  label: "changeset for schema with polymorphic embeds: embeds are have already been applied"
)

Result of executing the above code:

changeset for schema with traditional embeds: embeds are still changesets

#Ecto.Changeset<
  action: nil,
  changes: %{
    children: [
      #Ecto.Changeset<
        action: :insert,
        changes: %{age: 10, name: "Tic"},
        errors: [],
        data: #ChildSchema<>,
        valid?: true
      >,
      #Ecto.Changeset<
        action: :insert,
        changes: %{age: 12, name: "Tac"},
        errors: [],
        data: #ChildSchema<>,
        valid?: true
      >
    ]
  },
  errors: [],
  data: #ParentSchema<>,
  valid?: true
>

changeset for schema with polymorphic embeds: changes in embeds have already been applied

#Ecto.Changeset<
  action: nil,
  changes: %{
    children: [
      %ChildSchema{
        id: "cd555105-4033-425f-b984-29f8c2062de9",
        name: "Tic",
        age: 10
      },
      %ChildSchema{
        id: "5c55473d-e1d5-4f76-96a9-b63685c55ca3",
        name: "Tac",
        age: 12
      }
    ]
  },
  errors: [],
  data: #ParentSchemaWithPolymorphicChildren<>,
  valid?: true
>

[mathieuprog]

This was due to a limitation with what I can do with Ecto Type, if I recall correctly. Does this behaviour cause you any issue?

[maxmarcon]

Yes. When I call Ecto.Changeset APIs like get_change, or update_change my code expects changesets not structs.
When dealing with polymorphic embeds now I have to also deal with structs.

I added a workaround in my code, but I thought you might want to know about this. It should be fixed IMO.

I can give it a try and come up with a PR unless you tell me you prefer to keep it this way.

[mathieuprog]

As far as I can recall there was no possible fix, but if you you think you can find a way to make that work it'd be awesome.

The idea of the project is to have the same behavior as embeds_one and embeds_many, so this is ideally fixed.

[maxmarcon]

Ok I've taken a look and I think I understand why you're doing this.

You're applying the changes as soon as the polymorphic embedded changeset is valid here (in the case of single embeds) because otherwise, if you keep it as a changeset, Ecto would never apply the changes.

That's because in Ecto.Changeset.apply_changes/1, Ecto treats embeds and associations as special cases where changes are recursively applied. In all other cases, the change is simply copied over to the data.

Is this accurate?

[tmjoen]

This could be important towards change tracking with Live View IIRC? If we replace with structs on every pass through the cast function, everything will be marked as a new change and sent over the wire for each run through phx_change.

If it is impossible to fix, maybe we could float this to Ecto and see if there is anything to do on that end?

[Miradorn]

I think this behaviour also leads to another bug I'm encountering: If you have a "normal" embed inside a polymorphic_embed, the "normal" embedded one no longer gets automatically generated ids from ecto.
I think this is due to Ecto expecting the data to be changesets (see here), but my ecto knowledge is not good enough to actually verify this.

If you think this is unrelated i can open up another issue!

[mathieuprog]

Adding this here:
https://elixirforum.com/t/63854
https://groups.google.com/g/elixir-ecto/c/Sl6jdoVzHLw/m/9Zjj0_f_BQAJ

[tanguilp]

@mathieuprog Bonjour, do you still maintain this library?

I discovered this issue because I'm using some trick to change the background of inputs to green when the value is different than the initial value (by comparing get_in(field.form.data, [Access.key(field.field)]) with field.value in input components). Of course because of the problem mentioned in this issue it no longer works for polymorphic embeds as soon as the changeset becomes valid (initial data is replaced with the result of Ecto.Changeset.apply_changes/1).

That said, I followed the white rabbit (@maxmarcon ) and indeed, in Ecto apply_changes works only for fixed embed and assocs.

However, it came upon an blog article Polymorphic embeds in Ecto in which the author uses a trick to make it work like an embed:

    # We must modify the type so Ecto will handle this field as an embed.
    changeset = %{changeset | types: Map.put(changeset.types, name, {:embed, relation})}

What do you think, could it be used by this library? After all structurally polymorphic embeds have the same inherent structure as normal embeds.

Cheers, and thanks for the library!