Dynamic nested model in embeded field

drapermd · October 31, 2019, 5:57am

Hello there!

I’m having a devil of a time getting a dynamic embedded schema to save in postgres.

So I started here, basically

Comment by 1player to Stop using `schema` to resolve assocs in Ecto.Changeset

elixir-ecto:master ← AndrewDryga:schemaless-changesets

@axelson This is how I'm handling it in my project. On the schema (called Sou…rce), where `type` decides the inner type on the `options` map: ```elixir def create_changeset(params) do changeset = %__MODULE__{} |> cast(params, [:type]) |> validate_required([:type]) |> apply_options_schema_type() if changeset.valid? do cast_embed(changeset, :options, required: true) else changeset end end # Update the :options field type to be an embedded changeset, # and cast using the options_schema changeset function # From https://github.com/elixir-ecto/ecto/blob/7a165571bcb19c701e573eb1f4eb0820f2b9695b/test/ecto/changeset_test.exs#L129 defp apply_options_schema_type(changeset) do type = get_field(changeset, :type) # This returns an {:ok, module}, i.e. the schema of the inner option type, which has a `changeset` function case Sources.options_schema(type) do {:ok, options_schema} -> Map.update!(changeset, :types, &Map.put(&1, :options, options_type(options_schema))) :error -> add_error(changeset, :type, "Unknown source type") end end defp options_type(options_schema) do {:embed, %Ecto.Embedded{ cardinality: :one, field: :options, on_cast: &options_schema.changeset(&1, &2), on_replace: :update, owner: nil, related: options_schema, unique: true }} end # Helper functions for the context to convert the map to a inner schema struct when loading from the database def with_options_as_struct!(%__MODULE__{options: nil} = source), do: source def with_options_as_struct!(%__MODULE__{type: type, options: raw_options} = source) do {:ok, options_schema} = Sources.options_schema(type) {:ok, options_struct} = Ecto.Type.load(options_type(options_schema), raw_options) %__MODULE__{source | options: options_struct} end ``` And on the context: ```elixir def create_source(params) do changeset = Source.create_changeset(params) # Work around for https://github.com/elixir-ecto/ecto/pull/2113#issuecomment-361577933 with {:ok, source_from_changeset} <- Ecto.Changeset.apply_action(changeset, :insert) do workaround_changeset = case source_from_changeset.options do nil -> changeset _ -> options_as_map = Map.from_struct(source_from_changeset.options) %{source_from_changeset | options: options_as_map} end Repo.insert(workaround_changeset) end end def get_source!(id) do Source |> Repo.get!(id) |> Source.with_options_as_struct!() end ``` Hope this helps. I've adapted the code a bit for this comment, sorry if I've left something off or there's any mistake.

But my core problem is that despite several iterations, when it goes to save it to the database, it throws

(UndefinedFunctionError) function :map.schema/1 is undefined (module :map is not available)

So in my hunt, I came across this package and it slimmed down the code, but I still have the same problem :(. It’s like ecto isn’t seeing the type update before it goes into schema. With your package the changeset automatically sets the type, which is really super nice, but for some reason I can’t get this to save to postgres:

## This is the latest iteration, of many attempts.

defmodule Geeks.Activities.Activity do
  @moduledoc false

  use Ecto.Schema
  import Ecto.Changeset
  import GatheringRole
  alias Geeks.Activities.Types

  embedded_schema do
    field :type, ActivityType
    field :title, :string
    field :max_participants, :integer
    field :next_start, :utc_datetime
    embeds_one :properties, :map
    embeds_many :rsvp, Geeks.Activities.ActivityRsvp
    embeds_many :history, Geeks.Activities.ActivityHistory do
      field :history_event, :string
      timestamps([types: :utc_datetime])
    end
    timestamps([types: :utc_datetime])
  end


  @all_fields ~w(type title max_participants next_start)a
  @required_fields ~w(type title)a
  defp properties_type(props_schema) do
    {:embed,
      %Ecto.Embedded{
        cardinality: :one,
        field: :properties,
        on_cast: &props_schema.changeset(&1, &2),
        on_replace: :update,
        owner: nil,
        related: props_schema,
        unique: true
      }}
  end

  def create_changeset(%{ properties: props } = params) do
    {:ok, props_schema} = Types.get_schema(:ttrpg)
    props_cs = EctoMorph.generate_changeset(props, props_schema)
    case props_cs.valid? do
      true ->
        changeset =
          %__MODULE__{}
          |> cast(params, @required_fields)
          |> Map.update!(:types, &Map.put(&1, :properties, properties_type(props_schema)))
          |> cast_embed(:properties)
          |> validate_required(@required_fields)
      false ->
        props_cs
    end


  end

  def create_changeset(%{} = params ) do
    create_changeset(%{params | properties: %{}})
  end

end

And elsewhere, in the context:

  def add_activity(%Gathering{ activities: activities} = gathering, activity_params \\ %{properties: %{}}) do
   changeset = Ecto.Changeset.change(gathering)
   activity = Geeks.Activities.Activity.create_changeset(activity_params)
   case activity.valid? do
     true -> changeset = Ecto.Changeset.put_embed(changeset, :activities, activities ++ [activity])
             |> Geeks.Repo.update!
     false -> {:error, activity}
   end

I did see this post: How to validate dynamic fields in embedded_schema - #4 by LostKobrakai

But it just seems like I’m missing something

I’m going to try to cross-post this to the elixir forums, but man it’s a brainweaver!