Guidance for how to render Flop validation errors

[davydog187]

I'm trying to understand the right way to traverse Flop.Meta.errors() to produce good error messages for my OpenAPI json API. The way in which errors are structured is a bit confusing, and there's not a clear way for how to combine errors and data to get a good error message.

For instance, I have this test

    test "returns error for invalid filter parameters", %{conn: conn, key: key} do
      params = %{
        filters: %{
          0 => %{field: :status, value: :invalid_status}
        }
      }

      conn =
        conn
        |> put_req_header("authorization", "Bearer #{key}")
        |> get(~p"/api/v1/sessions?#{params}")

      assert json_response(conn, 422) == %{
               "error" => "ValidationError",
               "message" => "Invalid pagination parameters",
               "details" => %{
                 "filters" => [
                   "status value \"invalid_status\" is invalid"
                 ]
               }
             }
    end

The %Flop.Meta{} looks like

%Flop.Meta{
  backend: nil,
  current_offset: nil,
  current_page: nil,
  end_cursor: nil,
  next_offset: nil,
  next_page: nil,
  page_size: nil,
  previous_offset: nil,
  previous_page: nil,
  schema: Sauron.Devices.Session,
  start_cursor: nil,
  total_count: nil,
  total_pages: nil,
  errors: [filters: [[value: [{"is invalid", []}]]]],
  flop: %Flop{
    after: nil,
    before: nil,
    first: nil,
    last: nil,
    limit: nil,
    offset: nil,
    order_by: nil,
    order_directions: nil,
    page: nil,
    page_size: nil,
    decoded_cursor: nil,
    filters: []
  },
  has_next_page?: false,
  has_previous_page?: false,
  opts: [for: Sauron.Devices.Session],
  params: %{"filters" => [%{"field" => "status", "value" => "invalid_status"}]}
}

To me, there isn't a clear way to traverse these two data structures (errors and params) to provide a coherent error message back to the user. Ideally there would be a Flop function that could help

[woylie]

The top-level fields (page_size etc.) will have top-level keys in the errors keyword list.

The filter errors can be zipped with the filter parameters:

iex> filter_errors = Keyword.get(meta.errors, :filters, [])
[[value: [{"is invalid", []}]]]
iex> filter_params = Map.get(meta.params, "filters", [])
[%{"field" => "status", "value" => "invalid_status"}]
iex> params_and_errors = Enum.zip(filter_params, filter_errors)
[
  {%{"field" => "status", "value" => "invalid_status"},
   [value: [{"is invalid", []}]]}
]

The filter params list and the filter errors list will always have the same length. If there are multiple filters and only some of them have errors, the corresponding items of error-free filters in the errors list will be an empty list.

If you want to turn the above into a flat list of errors, you could do something like this:

Enum.flat_map(params_and_errors, fn {field_params, field_errors} ->
  field = field_params["field"]
  op = field_params["op"]
  value = field_params["value"]

  Enum.flat_map(field_errors, fn {filter_field, filter_field_errors} ->
    Enum.map(filter_field_errors, fn err ->
      %{
        field: field,
        op: op,
        value: value,
        filter_field: filter_field,
        error: err
      }
    end)
  end)
end)

Which would return:

[
  %{
    error: {"is invalid", []},
    value: "invalid_status",
    op: nil,
    field: "status",
    filter_field: :value
  }
]

[davydog187]

Got it! It would be helpful to have some of these guarantees about the data structure in the docs, at the very least!

[woylie]

Yes, it would also be good to have a helper function for this. Not sure about the name and return format yet, though.

[davydog187]

I threw together something that looks like this for now. I don't love that the filter and non-filter shapes are inconsistent. I'll have to think on that

  defp flop_errors(%Flop.Meta{} = meta) do
    for {key, errors} <- meta.errors, into: %{} do
      params = Map.get(meta.params, to_string(key), [])

      {key, flop_errors(key, errors, params)}
    end
  end

  defp flop_errors(:filters, errors, params) do
    filters = Enum.zip(params, errors)

    Enum.flat_map(filters, fn {field_params, field_errors} ->
      field = field_params["field"]
      op = field_params["op"]
      value = field_params["value"]

      Enum.flat_map(field_errors, fn {filter_field, filter_field_errors} ->
        Enum.map(filter_field_errors, fn error ->
          %{
            field: field,
            op: op,
            value: value,
            filter_field: filter_field,
            error: Inputs.translate_error(error)
          }
        end)
      end)
    end)
  end

  defp flop_errors(_key, errors, params) do
    %{
      value: params,
      errors:
        for error <- errors do
          Inputs.translate_error(error)
        end
    }
  end