Whenever I try to use a negative number of any kind (integer, decimal, float) i get an ArgumentError.
For example:

 required(:longitude, :float,
      min: -180.0,
      max: 180.0
    )

Fails with:

** (ArgumentError) expected option `greater_than_or_equal_to` to be a decimal, integer, or float, got: {:-, [line: 33, column: 12], [180.0]}

First off, thanks so much for a wonderful library! We are currently using goal to validate params before sending to a 3rd party API and it's working great! One pain point we've run into is it's currently impossible to share enums across modules. Here's a minimal example that will error:

defmodule MyValidation do
  use Goal

  defp statuses, do: ["draft", "pending", "done"]

  defparams :index do
    optional :status, :enum, values: statuses()
  end

  defparams :update do
    optional :status, :enum, values: statuses()
  end
end

If you try to do the above, once the macro is expanded, you won't get the result of statuses() as a list of atoms. Instead it gets expanded to status: [type: :enum, values: {:{}, [], [:statuses, [line: 4], []]}].

The problem code seems to be here where the block passed to generate_schema/1 has been given a function tuple in place of statuses() instead of the result of a call to the function.

def schema(unquote(name)) do
  unquote(block |> generate_schema() |> Macro.escape())
end

Within generate_schema/1 I've tried a couple different things without luck, for example calling apply on the function tuple with __CALLER__ when values appears in the options provided. Just trying to get the function evaluated to a list of strings before later getting passed to get_types/1 and String.to_atom/1 which does not succeed.

  defp get_types(schema) do
    Enum.reduce(schema, %{}, fn {field, rules}, acc ->
      case Keyword.get(rules, :type, :any) do
        :enum ->
          values =
            rules
            |> Keyword.get(:values, [])
            |> Enum.map(&String.to_atom/1)

          Map.put(acc, field, {:parameterized, Ecto.Enum, Ecto.Enum.init(values: values)})

    # ...
  end

I'm a little out of my depth with the macros here, but any guidance or ideas would be much appreciated! Or if you have a quick solution/workaround, even better! Thanks in advance for your time!

I have some changes ready and I'd like to release the recent changes made by @LukasKnuth:

1. Release #50
2. Release #53
3. Add :any field type and set it as default 🏗️
4. Remove defschema in favor of defparams 🏗️

Defaulting to :any would allow for proponents of the "check don't validate" parameter validation methodology to omit the types and simply check for presence. This change would make a breaking change for users of the basic syntax (not for the defparams users), because the current default is :string.

defschema is an earlier version of defparams that expands to the basic syntax. I'm not sure that anybody uses it anymore, because defparams is more convenient.

We'd still keep the pre-filled format options (like email, uuid, etz), but we'd also allow just giving any %Regex{} to the :format validation.

This allows some more flexibility:

required :id, :string, trim: true, format: ~r/^[a-z0-9-]+$/i

I have a working version that I can create a PR for as soon as main is clean again after #50

Thoughts?

This would work similar to how trim works on strings. It doesn't really validate anything but modifies the input value by removing any duplicate array items.

required :options, {:array, :string}, unique: true

I'd expect this to work in order with the other defined validations, so defining rules: [trim: true], unique: true would first trim all items in the array and then remove any repeated items.

What do you think?

Would this be able to support use case like:

if param foo is true, we require param bar to be given (required) if not bar is not required

For example:

use Goal

defparams :update do
  required(:translations, :map)
end

validate(:update, %{
  "translations" => %{"en" => %{"name" => "Foo"}}
})

# Returns
%{
  translations: %{en: %{name: "Foo"}}
}

Currently it returns

%{
  "translations" => %{"en" => %{"name" => "Foo"}}
}

Currently, I can do this:

defparams :update do
  required :options, {:array, :string}
end

This will validate that the values inside the :options array are strings. I'd like to propose the following notation:

defparams :update do
  required :options, {:array, :string}, rules: [min: 1, trim: true]

This would be allowed for the inner types string, integer, float, decimal, boolean, date, and time. Not sure if it's possible/useful for enum. For maps, we already have existing notation.

It runs the validations available for the inner type on each value inside the array and adds the errors accordingly.

Ideally, this can be implemented by just using the inner type, validating it as if it where a top-level parameter and merging the result back into the nested array.

Any input/considerations/feelings towards this proposal? I'll go ahead and hack at it a bit, see what I come up with.

I really like this library and I would like to improve it.

I have the idea to add a one_of_many validation. As the name suggests it will check if only one of N fields is present.

Here's a simple example:

 defparams :login do
        optional(:email, :string)
        optional(:username, :string)
        required(:password, :string)

        one_of_many([:email, :username])
  end

Hi!

First of all, great library! Many thanks! 🙏🏻

I was wondering if there is (or will be) support for validating fields that do not occur in the defparams?

For example, suppose we have the following module:

defmodule Params do
  use Goal

  defparams :body do
    optional :field, :string
  end
end

When I run the following, I get:

iex> Params.validate(:body, %{non_existing_field: "..."})
{:ok, %{}}

I would like to have the option to return an error tuple saying something like :non_existing_field does not exist.

Thanks in advance!