Changeset error parsing

Questions / Help
, ,
1

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}
  end
end

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

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

  parsed_errors
end

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

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

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

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.

2

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.

3

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