Why do I feel like I’m an LLM being prompted? lol.
The winner advice is to include everything that needs to be revalidated as changes in the changeset. Something like this (untested):
defmodule Forms.Form do
use Ecto.Schema
import Ecto.Changeset
schema "forms" do
field :status, Ecto.Enum, values: [:draft, :published], default: :draft
field :title, :string
has_many :questions, Forms.Question, on_replace: :delete
end
@doc """
More relaxed changeset. While in draft we allow things to be missing/invalid. Validation will happen in publishing
"""
def draft_changeset(form \\ %__MODULE__{}, attrs) do
form
|> cast(attrs, [:title])
|> cast_assoc(:questions)
|> put_change(:status, :draft)
end
@doc """
Publish changeset validates everything again. Only complete forms can be published
"""
def publish_changeset(form \\ %__MODULE__{}, attrs) do
form
|> cast(attrs, [:title], force_changes: true) # Even if `title` is not present in `attrs`, it will be considered a change here
|> cast_assoc(:questions, with: &Forms.Question.publish_changeset/2)
|> put_change(:status, :published)
|> validate_required([:title])
|> validate_length(:questions, min: 1)
end
end
defmodule Forms.Question do
use Ecto.Schema
import Ecto.Changeset
schema "questions" do
field :prompt, :string
field :type, Ecto.Enum, values: [:short_text, :multiple_choice]
field :choices, {:array, :string}, default: []
belongs_to :form, Forms.Form
end
@doc """
More relaxed changeset. While in draft we allow things to be missing/invalid. Validation will happen in publishing
"""
def draft_changeset(question \\ %__MODULE__{}, attrs) do
question
|> cast(attrs, [:prompt, :type, :choices])
end
def publish_changeset(question \\ %__MODULE__{}, attrs) do
question
|> cast(attrs, [:prompt, :type, :choices], force_changes: true) # same thing here: force changes to make sure everything is validated even if didn't change now
|> validate_required([:prompt, :type])
|> validate_choices()
end
end
The other idea (a more verbose one) would be to split the schemas into a DraftForm/DraftQuestion and a PublishedForm/PublishedQuestion. They can both point to the same table, but have different requirements in their changesets. Also the Draft variants would have a to_published_attrs that returns the map to be fed into the published variant’s changeset, like so:
defmodule Forms.DraftForm do
use Ecto.Schema
import Ecto.Changeset
schema "forms" do
field :status, Ecto.Enum, values: [:draft, :published], default: :draft
field :title, :string
has_many :questions, Forms.DraftQuestion, foreign_key: :form_id, on_replace: :delete
end
@doc """
Relaxed changeset. While in draft we allow things to be missing/invalid.
"""
def changeset(form \\ %__MODULE__{}, attrs) do
form
|> cast(attrs, [:title])
|> cast_assoc(:questions)
|> put_change(:status, :draft)
end
@doc """
Converts a draft into the attrs map expected by `Forms.PublishedForm.changeset/2`.
Everything goes through the published changeset, so all fields get validated.
"""
def to_published_attrs(%__MODULE__{} = form) do
%{
"title" => form.title,
"questions" => Enum.map(form.questions, &Forms.DraftQuestion.to_published_attrs/1)
}
end
end
defmodule Forms.DraftQuestion do
use Ecto.Schema
import Ecto.Changeset
schema "questions" do
field :prompt, :string
field :type, Ecto.Enum, values: [:short_text, :multiple_choice]
field :choices, {:array, :string}, default: []
belongs_to :form, Forms.DraftForm
end
def changeset(question \\ %__MODULE__{}, attrs) do
question
|> cast(attrs, [:prompt, :type, :choices])
end
def to_published_attrs(%__MODULE__{} = question) do
%{
"prompt" => question.prompt,
"type" => question.type,
"choices" => question.choices
}
end
end
defmodule Forms.PublishedForm do
use Ecto.Schema
import Ecto.Changeset
schema "forms" do
field :status, Ecto.Enum, values: [:draft, :published], default: :draft
field :title, :string
has_many :questions, Forms.PublishedQuestion, foreign_key: :form_id, on_replace: :delete
end
@doc """
Strict changeset. Only complete forms can be published.
Feed it `Forms.DraftForm.to_published_attrs/1` output - since every field
arrives as an incoming change, everything is (re)validated.
"""
def changeset(form \\ %__MODULE__{}, attrs) do
form
|> cast(attrs, [:title])
|> cast_assoc(:questions)
|> put_change(:status, :published)
|> validate_required([:title])
|> validate_length(:questions, min: 1)
end
end
defmodule Forms.PublishedQuestion do
use Ecto.Schema
import Ecto.Changeset
schema "questions" do
field :prompt, :string
field :type, Ecto.Enum, values: [:short_text, :multiple_choice]
field :choices, {:array, :string}, default: []
belongs_to :form, Forms.PublishedForm
end
def changeset(question \\ %__MODULE__{}, attrs) do
question
|> cast(attrs, [:prompt, :type, :choices])
|> validate_required([:prompt, :type])
|> validate_choices()
end
defp validate_choices(changeset) do
case get_field(changeset, :type) do
:multiple_choice ->
validate_length(changeset, :choices, min: 2)
_ ->
changeset
end
end
end
Publishing then looks like:
draft
|> Forms.DraftForm.to_published_attrs()
|> then(&Forms.PublishedForm.changeset(%Forms.PublishedForm{id: draft.id}, &1))
|> Repo.update()
