Nested Changes in Ecto and LiveView

I’m interested in people’s opinions on how I approached a particular problem. I’m using LiveView, and I have a complex form with 4 total associations, one of those nested 2 levels in the base struct. I needed the entire changeset because I use the actions to broadcast the results (for example, if I update the parent, and create 2 children, and update 1 child, I need to broadcast an update on the parent, and 2 children, and broadcast a create on the other child). I also needed to know the current_change AKA only the thing or thing that changed last, so that I could perform some actions only once when a field changed. Specifically to make this work with LiveView, I needed to update the params when the x_id changed`

My solution, at a high level is use the same changeset to validate changes, and to update the record (I know that’s normal, but bear with me). I had to actually change the struct and re-validate, so I use apply_action during the form validation and Repo.update when I update the record (you’ll see why in a moment). Generally, the parent record has belongs_to relationships to the child structs, so when the x_id field changes on the parent, I want to present the fields of the new record to the user. I do this by changing the params when the x_id changes. Similarly, if I change the x_id, and make changes to x I need to change the associated record before validating the changes.

Basically handle_page_id_change manages updating the data in the changeset to the new record if the parent x_id changes. maybe_replace_page_params handles updating the params when the x_id changes so that the form changes when the user selects a new x. Note that I have to recast the x_id's after changing the associated records because I used apply_action / Repo.update.

In the case of cast_assoc(:annotation ... and handle_content_id_change I’m doing the same thing for the 2nd level nested change. I could potentially clean that up and refactor it inside the annotation changeset, but since there was only one of them, and I don’t do this anywhere else (yet), I left it here.

Once the associated data and params are updated, It’s business as usual. I cast the remaining params/foreign keys/assocs, and automatically name some records.

Any questions or comments? I’m curious if anyone else has had the same problem, or has any other ways of doing this that work better. I don’t fully understand the performance cost of doing all this work every time the user hits a key, but it’s been pretty performant in testing. From a “database correctness” standpoint, this seems like the right thing to do (change the foreign key on the parent first, make any changes to the associated record second).

  def nested_changeset(step, last_step, attrs, state, action) do
    last_change = changeset(last_step, attrs)
  # |> change page
    |> cast(attrs, [ :page_id ])
    |> foreign_key_constraint(:page)
    |> Changeset.handle_page_id_change(state)
    |> Changeset.maybe_replace_page_params(last_change, state)
  # |> same_thing_for_annotation_and_element
  # |> update step fk's
    |> Changeset.cast_changeset_params([ :page_id, :annotation_id, :element_id ])
    |> Changeset.update_foreign_keys(action)
  # |> change content
    |> cast_assoc(:annotation, with: &Annotation.content_id_changeset/2)
    |> Changeset.handle_content_id_change(state)
    |> Changeset.maybe_replace_content_params(last_change, state)
  # |> update annotation fk's
    |> cast_assoc(:annotation, with: &Annotation.content_id_changeset/2)
    |> Changeset.update_foreign_keys(action)
  # |> final changes
    |> Changeset.cast_changeset_params([ :process_id, :step_type_id ])
    |> Changeset.cast_changeset_params([ :name, :order, :url, :text, :width, :height, :page_reference ])
    |> foreign_key_constraint(:process)
    |> foreign_key_constraint(:step_type)
    |> assoc_changeset()
    |> names_changeset()
    |> validate_required([:order])
  def handle_page_id_change(%{ changes: %{ page_id: page_id }} = changeset, state) do
    Logger.debug("Page id changed to #{page_id}")
    page = Web.get_page!(page_id, state, state.assigns.state_opts)
    Map.put(, :page, page)
    |> cast(changeset.params, [ ])
  def handle_page_id_change(changeset, _state), do: changeset

  def maybe_replace_page_params(changeset, %{ changes: %{ page_id: page_id }}, state) do
    Logger.debug("Replacing Page #{page_id} Params")
    page = Web.get_page!(page_id, state, state.assigns.state_opts)
    page_params = replace_params_with_fields(changeset.params["page"], page, Page)
    params =
      |> Map.put("page", page_params)
      |> Map.put("page_id", Integer.to_string(page_id))

    Map.put(changeset, :params, params)
  def maybe_replace_page_params(changeset, _last_changeset, _state), do: changeset
   def update_foreign_keys(changeset, action) do
    case action do
      :validate ->
        { :ok, step } = apply_action(changeset, :update)
        |> cast(changeset.params, [ ])
      _ ->
        { :ok, step } = UserDocs.Repo.update(changeset)
        |> cast(changeset.params, [ ])