Convert Embedded Schema struct to persisted schema

Let’s say you have a changeset for %Signup{} in signup_changeset. You could write something like this:

  case Ecto.Changeset.apply_action(signup_changeset, :insert) do
    {:ok, signup} ->
      # use signup.email etc to populate Profile and
      #  Account records and save to the DB
    {:error, changeset} ->
      # do something to tell the caller about the errors in `changeset`
  end

Thanks for the reply - so would I do something like this for example:

case Ecto.Changeset.apply_action(signup_changeset, :insert) do
    {:ok, signup} ->
        Account.changeset(signup) |> Repo.insert()
        Profile.changeset(signup) |> Repo.insert()
    {:error, changeset} ->
      # do something to tell the caller about the errors in `changeset`
  end

Maybe - you’d need to write Account.changeset and Profile.changeset to accept a Signup struct.

The biggest thing that code is missing is the connection between Profile and Account.

A more “textbook” approach would be to build the structs explicitly:

  account = %Account{email: signup.email}

  profile =
    %Profile{
      name: signup.name,
      age: signup.age,
      account: account
    }

  Repo.insert(profile)

This assumes that the validations on Signup are the same or stricter than the expectations for Profile and Account. That way it’s not necessary to use another round of changesets.

One place that assumption will fail is changeset functionality that depends on the database, like uniqueness validation or check_constraint. Those can’t be written in Signup! For those you’ll need to build a changeset from the data in signup and pass that to Repo.insert:

  profile =
    Profile.changeset(%Profile{}, %{
      name: signup.name,
      age: signup.age,
      account: %{email: signup.email}
    })

  case Repo.insert(profile) do
    {:ok, profile} ->
      # return the created profile

    {:error, changeset} ->
      # extract errors from changeset and apply them to signup_changeset

  end

and in Profile:

def changeset(data, params) do
  data
  |> cast(params, [:name, :age])
  |> cast_assoc(:account)
  # other validations to taste
end

and in Account:

def changeset(data, params) do
  data
  |> cast(params, [:email])
  |> unique_constraint(:email)
end

Yet a third way to do this would be to break creating the Account completely apart from the creation of Profile - for instance, if you wanted to add a new Profile for an existing Account by email.