@spec with_errors(map(), keyword(), keyword()) :: t()

Returns a Flop.Meta struct with the given params, errors, and opts.

This function is used internally to build error responses in case of validation errors. You can use it to add additional parameter validation.

The given parameters parameters are normalized before being added to the struct. The errors have to be passed as a keyword list (same format as the result of Ecto.Changeset.traverse_errors(changeset, & &1)).

Example

In this list function, the given parameters are first validated with Flop.validate/2, which returns a Flop struct on success. You can then pass that struct to a custom validation function, along with the original parameters and the opts, which both are needed to call this function.

def list_pets(%{} = params) do
  opts = [for: Pet]

  with {:ok, %Flop{} = flop} <- Flop.validate(params, opts),
       {:ok, %Flop{} = flop} <- custom_validation(flop, params, opts) do
    Flop.run(Pet, flop, for: Pet)
  end
end

In your custom validation function, you can retrieve and manipulate the filter values in the Flop struct with the functions defined in the Flop.Filter module.

defp custom_validation(%Flop{} = flop, %{} = params, opts) do
  %{value: date} = Flop.Filter.get(flop.filters, :date)

  if date && Date.compare(date, Date.utc_today()) != :lt do
    errors = [filters: [{"date must be in the past", []}]]
    {:error, Flop.Meta.with_errors(params, errors, opts)}
  else
    {:ok, flop}
  end
end

Note that in this example, Flop.Filter.get/2 is used, which only returns the first filter in the given filter list. Depending on how you use Flop, the filter list may have multiple entries for the same field. In that case, you may need to either use Flop.Filter.get_all/2 and apply the validation on all returned filters, or reduce over the whole filter list. The latter has the advantage that you can attach the error to the actual list entry.

def custom_validation(%Flop{} = flop, %{} = params, opts) do
  filter_errors =
    flop.filters
    |> Enum.reduce([], &validate_filter/2)
    |> Enum.reverse()

  if Enum.any?(filter_errors, &(&1 != [])) do
    errors = [filters: filter_errors]
    {:error, Flop.Meta.with_errors(params, errors, opts)}
  else
    {:ok, flop}
  end
end

defp validate_filter(%Flop.Filter{field: :date, value: date}, acc)
     when is_binary(date) do
  date = Date.from_iso8601!(date)

  if Date.compare(date, Date.utc_today()) != :lt,
    do: [[value: [{"date must be in the past", []}]] | acc],
    else: [[] | acc]
end

defp validate_filter(%Flop.Filter{}, acc), do: [[] | acc]