Changeset error parsing

I want to create some kind of procedure to programmatically transform a changeset’s errors into my own error codes so that I can display them in the frontend.

I’ve come up with the following:

def create(%{} = course) do
  case Course.create(course) |> Repo.insert() do
    {:ok, course} ->
      {:ok, transform(course)}

    {:error, changeset} ->
      errors = parse_errors(changeset)
      {:error, errors}

def parse_errors(changeset) do
  errors = changeset.errors
  parsed_errors = []

  parsed_errors = parse_single_error(errors[:tag], :unique, "COURSE_TAG_TAKEN", parsed_errors)


def parse_single_error(nil, _constraint, _error_msg, error_list) do

def parse_single_error(error, constraint, error_text, error_list) do
  {_error_msg, constraints} = error

  if constraints[:constraint] == constraint do
    error_list ++ [error_text]

I’m mostly looking for feedback on this since it’s the first time I’ve tried to parse errors like this and I have no idea whether there are better ways to achieve this or not.

Without proofing the actual execution, it’s not unreasonable to do this.

You may also want to look at add_error as well as traverse_errors.

Most of my code has separate schemas for the data layer (business logic focused) and UI layer (user interface focused, may combine or obscure mulitiple data layer schemas - ex: data layer price is always cents but the ui layer changeset may accept dollars + cents), so with that in mind I would probably attach the error-code stuff to that as just another validation step. I may Enum.reduce(changeset.errors, changeset, ...) and just insert the error code into the existing errors.

I also would tend to return {:error, changeset} only because of convention, vs {:error, errors} but this is really code base specific – just be consistent.

I’m not using phoenix so I need to parse the errors anyway in the frontend. Some of the things you mention I assume are automatically handled by phoenix if you return a changeset with errors somehow to the frontend