# `Selecto.DomainValidator`

Domain validation for Selecto configurations.

Validates domain configuration to catch errors early and prevent runtime failures.
Checks for join dependency cycles, missing references, required keys for advanced
join types, and other structural integrity issues.

## Usage

    # Validate during configure (enabled by default)
    domain = %{source: ..., schemas: ..., joins: ...}
    selecto = Selecto.configure(domain, connection_input)
    
    # Disable validation for performance-critical scenarios
    selecto = Selecto.configure(domain, connection_input, validate: false)
    
    # Or validate explicitly
    Selecto.DomainValidator.validate_domain!(domain)
    {:ok, _} = Selecto.DomainValidator.validate_domain(domain)
    
## Compile-time Validation

    # Validate domain at compile time (recommended for static configurations)
    defmodule MyDomain do
      use Selecto.DomainValidator, domain: %{
        source: %{...},
        schemas: %{...},
        joins: %{...}
      }
    end

# `__using__`
*macro* 

Compile-time domain validation macro.

When used in a module, validates the provided domain configuration at compile time.
This catches domain configuration errors early and provides better error messages.

## Options

- `:domain` - The domain configuration to validate (required)

## Example

    defmodule MyApp.UserDomain do
      use Selecto.DomainValidator, domain: %{
        source: %{
          source_table: "users",
          primary_key: :id,
          fields: [:id, :name, :email],
          columns: %{
            id: %{type: :integer},
            name: %{type: :string},
            email: %{type: :string}
          }
        },
        schemas: %{}
      }
      
      def domain, do: @validated_domain
    end

# `format_errors`

# `validate_domain`

Validates a domain configuration, returning `:ok` or `{:error, errors}`.

Non-raising version of validate_domain!/1.

Options:

- `:normalize` - when `true`, validate a normalized domain projection instead
  of the authored map. Defaults to `false` to preserve existing runtime
  behavior.
- `:projection` - normalized projection to validate when `:normalize` is
  enabled. Defaults to `:api`, because it includes query metadata and current
  detail action metadata.

# `validate_domain!`

```elixir
@spec validate_domain!(
  Selecto.Types.domain(),
  keyword()
) :: :ok
```

Validates a domain configuration, raising on validation errors.

## Validations Performed

- Join dependency cycle detection
- Association existence validation  
- Schema reference validation
- Column/field existence validation
- Advanced join type required key validation
- Custom column/filter reference validation

## Examples

    iex> domain = %{source: valid_source, schemas: valid_schemas, joins: valid_joins}
    iex> Selecto.DomainValidator.validate_domain!(domain)
    :ok
    
    iex> domain = %{source: valid_source, schemas: valid_schemas, joins: cyclic_joins}
    iex> Selecto.DomainValidator.validate_domain!(domain)
    ** (Selecto.DomainValidator.ValidationError) Join dependency cycle detected: a -> b -> c -> a

---

*Consult [api-reference.md](api-reference.md) for complete listing*