defmodule Localize.Inputs.Date.Validator do
@moduledoc """
Server-side validation for parsed date and date-range values.
Pure Elixir, no Ecto dependency. The Ecto changeset bridge is
in `Localize.Inputs.Date.Changeset`.
"""
alias Localize.Inputs.ValidationError
@doc """
Validates a parsed `t:Date.t/0` against bounds, weekday
restrictions, and required-ness.
### Arguments
* `value` is a `t:Date.t/0` or `nil`.
* `options` is a keyword list of options.
### Options
* `:required` — when `true`, `nil` is rejected.
* `:min` — minimum allowed date (`Date` or ISO-8601 string).
* `:max` — maximum allowed date.
* `:not_weekend` — when `true`, rejects Saturday and Sunday.
To customise which weekdays count as "weekend" per
locale, pass `:weekend_days` as a list of
1..7 (1 = Monday).
* `:on_or_after` — alias for `:min`. When both are given,
the stricter (later) bound wins.
* `:on_or_before` — alias for `:max`. When both are given,
the stricter (earlier) bound wins.
* `:business_days_only` — when `true`, rejects any date
falling on the locale's weekend (per `:weekend_days` or
the default `[6, 7]` = Sat/Sun). Equivalent to
`:not_weekend` but with the more business-domain
naming. Future extensions may also reject locale-aware
public holidays via a `:holidays` option (not yet
wired).
### Returns
* `:ok` when every check passes.
* `{:error, %Localize.Inputs.ValidationError{errors: [{atom(),
String.t()}]}}` with one entry per failing check, in the
order `:required`, `:min`, `:max`, `:weekend`.
### Examples
iex> Localize.Inputs.Date.Validator.validate_date(~D[2026-05-16], min: ~D[2026-01-01])
:ok
iex> {:error, %Localize.Inputs.ValidationError{errors: errors}} =
...> Localize.Inputs.Date.Validator.validate_date(~D[2025-01-01], min: ~D[2026-01-01])
iex> Keyword.get(errors, :min) =~ "2026-01-01"
true
iex> {:error, %Localize.Inputs.ValidationError{errors: errors}} =
...> Localize.Inputs.Date.Validator.validate_date(nil, required: true)
iex> errors
[{:required, "is required"}]
"""
@spec validate_date(term(), Keyword.t()) :: :ok | {:error, ValidationError.t()}
def validate_date(value, options \\ []) do
options = normalize_date_options(options)
errors =
[]
|> check_date_required(value, options)
|> check_date_range(value, options)
|> check_date_weekend(value, options)
|> Enum.reverse()
if errors == [], do: :ok, else: {:error, ValidationError.exception(errors: errors)}
end
# Fold `:on_or_after` / `:on_or_before` aliases into
# `:min` / `:max`, preferring the stricter bound when
# both are present. `:business_days_only` is a synonym for
# `:not_weekend`.
defp normalize_date_options(options) do
options
|> merge_bound(:on_or_after, :min, &keep_later/2)
|> merge_bound(:on_or_before, :max, &keep_earlier/2)
|> alias_weekend()
end
defp merge_bound(options, alias_key, canonical_key, merger) do
case Keyword.pop(options, alias_key) do
{nil, options} ->
options
{alias_value, options} ->
Keyword.update(options, canonical_key, alias_value, fn existing ->
merger.(existing, alias_value)
end)
end
end
defp keep_later(a, b), do: pick_date(a, b, :gt)
defp keep_earlier(a, b), do: pick_date(a, b, :lt)
defp pick_date(a, b, preferred_cmp) do
with {:ok, a_date} <- to_date(a),
{:ok, b_date} <- to_date(b) do
if Date.compare(a_date, b_date) == preferred_cmp, do: a, else: b
else
_ -> a
end
end
defp alias_weekend(options) do
case Keyword.pop(options, :business_days_only) do
{true, options} -> Keyword.put_new(options, :not_weekend, true)
{_, options} -> options
end
end
@doc """
Validates a parsed `t:Date.Range.t/0` against bounds, span,
weekend restrictions, and required-ness.
### Arguments
* `value` is a `t:Date.Range.t/0` or `nil`.
* `options` is a keyword list of options.
### Options
* `:required` — when `true`, `nil` is rejected.
* `:min`, `:max` — bounds that both endpoints must satisfy.
* `:min_span` — minimum span in days (inclusive of both
endpoints, so `~D[2026-01-01]..~D[2026-01-03]` has span 3).
* `:max_span` — maximum span in days.
* `:disallow_inverted` — when `true`, rejects descending
ranges. The range parser already rejects inverted ranges
by default; this is here for direct validator use.
### Returns
* `:ok` when every check passes.
* `{:error, ValidationError.t()}` with errors keyed by
`:required`, `:min`, `:max`, `:min_span`, `:max_span`,
`:inverted`.
### Examples
iex> range = Date.range(~D[2026-05-01], ~D[2026-05-07])
iex> Localize.Inputs.Date.Validator.validate_date_range(range, min_span: 5, max_span: 10)
:ok
iex> range = Date.range(~D[2026-05-01], ~D[2026-05-03])
iex> {:error, %Localize.Inputs.ValidationError{errors: errors}} =
...> Localize.Inputs.Date.Validator.validate_date_range(range, min_span: 5)
iex> Keyword.get(errors, :min_span) =~ "5"
true
"""
@spec validate_date_range(term(), Keyword.t()) :: :ok | {:error, ValidationError.t()}
def validate_date_range(value, options \\ []) do
errors =
[]
|> check_range_required(value, options)
|> check_range_inversion(value, options)
|> check_range_endpoints(value, options)
|> check_range_span(value, options)
|> Enum.reverse()
if errors == [], do: :ok, else: {:error, ValidationError.exception(errors: errors)}
end
# ── Date checks ─────────────────────────────────────────────
defp check_date_required(errors, nil, options) do
if Keyword.get(options, :required, false) do
[{:required, "is required"} | errors]
else
errors
end
end
defp check_date_required(errors, _value, _options), do: errors
defp check_date_range(errors, nil, _options), do: errors
defp check_date_range(errors, %Date{} = value, options) do
errors
|> maybe_check_date_min(value, Keyword.get(options, :min))
|> maybe_check_date_max(value, Keyword.get(options, :max))
end
defp check_date_range(errors, _, _), do: errors
defp maybe_check_date_min(errors, _value, nil), do: errors
defp maybe_check_date_min(errors, value, min) do
case to_date(min) do
{:ok, min_date} ->
if Date.compare(value, min_date) == :lt do
[{:min, "must be on or after #{Date.to_iso8601(min_date)}"} | errors]
else
errors
end
:error ->
errors
end
end
defp maybe_check_date_max(errors, _value, nil), do: errors
defp maybe_check_date_max(errors, value, max) do
case to_date(max) do
{:ok, max_date} ->
if Date.compare(value, max_date) == :gt do
[{:max, "must be on or before #{Date.to_iso8601(max_date)}"} | errors]
else
errors
end
:error ->
errors
end
end
defp check_date_weekend(errors, nil, _options), do: errors
defp check_date_weekend(errors, %Date{} = value, options) do
if Keyword.get(options, :not_weekend, false) do
weekend = Keyword.get(options, :weekend_days, [6, 7])
if Date.day_of_week(value) in weekend do
[{:weekend, "must not fall on a weekend"} | errors]
else
errors
end
else
errors
end
end
defp check_date_weekend(errors, _, _), do: errors
# ── Range checks ────────────────────────────────────────────
defp check_range_required(errors, nil, options) do
if Keyword.get(options, :required, false) do
[{:required, "is required"} | errors]
else
errors
end
end
defp check_range_required(errors, _value, _options), do: errors
defp check_range_inversion(errors, nil, _options), do: errors
defp check_range_inversion(errors, %Date.Range{step: step}, options) do
disallow = Keyword.get(options, :disallow_inverted, false)
if disallow and step < 0 do
[{:inverted, "range start must be on or before range end"} | errors]
else
errors
end
end
defp check_range_inversion(errors, _, _), do: errors
defp check_range_endpoints(errors, nil, _options), do: errors
defp check_range_endpoints(errors, %Date.Range{first: first, last: last}, options) do
errors
|> maybe_check_date_min(first, Keyword.get(options, :min))
|> maybe_check_date_max(last, Keyword.get(options, :max))
end
defp check_range_endpoints(errors, _, _), do: errors
defp check_range_span(errors, nil, _options), do: errors
defp check_range_span(errors, %Date.Range{first: first, last: last}, options) do
span = abs(Date.diff(last, first)) + 1
errors
|> maybe_check_min_span(span, Keyword.get(options, :min_span))
|> maybe_check_max_span(span, Keyword.get(options, :max_span))
end
defp check_range_span(errors, _, _), do: errors
defp maybe_check_min_span(errors, _span, nil), do: errors
defp maybe_check_min_span(errors, span, min_span) when is_integer(min_span) do
if span < min_span do
[{:min_span, "must span at least #{min_span} days"} | errors]
else
errors
end
end
defp maybe_check_max_span(errors, _span, nil), do: errors
defp maybe_check_max_span(errors, span, max_span) when is_integer(max_span) do
if span > max_span do
[{:max_span, "must span at most #{max_span} days"} | errors]
else
errors
end
end
# Accept Date structs, ISO-8601 strings, or anything we can
# coerce. Returns `:error` for nil/garbage rather than
# raising so the caller can silently skip the bound.
defp to_date(%Date{} = date), do: {:ok, date}
defp to_date(string) when is_binary(string) do
case Date.from_iso8601(string) do
{:ok, date} -> {:ok, date}
_ -> :error
end
end
defp to_date(_), do: :error
end
