# `Selecto.Error`

Standardized error structure for all Selecto operations.

Provides consistent error handling across the Selecto ecosystem with
structured error information including context, query details, and
actionable error types.

## Error Types

- `:connection_error` - Database connection failures
- `:query_error` - SQL query execution failures
- `:validation_error` - Input validation failures
- `:configuration_error` - Invalid domain or Selecto configuration
- `:no_results` - Query returned no results when one expected
- `:multiple_results` - Query returned multiple results when one expected
- `:timeout_error` - Query execution timeout

## Examples

    # Connection error
    {:error, %Selecto.Error{
      type: :connection_error,
      message: "Failed to connect to database",
      details: %{host: "localhost", port: 5432}
    }}

    # Query error with context
    {:error, %Selecto.Error{
      type: :query_error,
      message: "Column 'invalid_col' does not exist",
      query: "SELECT invalid_col FROM users",
      params: [],
      details: %{column: "invalid_col", table: "users"}
    }}

# `error_type`

```elixir
@type error_type() ::
  :connection_error
  | :query_error
  | :validation_error
  | :configuration_error
  | :no_results
  | :multiple_results
  | :timeout_error
  | :field_resolution_error
  | :transformation_error
```

# `t`

```elixir
@type t() :: %Selecto.Error{
  details: map() | nil,
  message: String.t(),
  params: [term()] | nil,
  query: String.t() | nil,
  type: error_type()
}
```

# `configuration_error`

```elixir
@spec configuration_error(String.t(), map()) :: t()
```

Creates a configuration error.

# `connection_error`

```elixir
@spec connection_error(String.t(), map()) :: t()
```

Creates a connection error.

# `field_resolution_error`

```elixir
@spec field_resolution_error(String.t(), term(), map()) :: t()
```

Creates a field resolution error with context.

# `from_reason`

```elixir
@spec from_reason(term()) :: t()
```

Converts various error types to standardized Selecto.Error.

# `multiple_results_error`

```elixir
@spec multiple_results_error(String.t()) :: t()
```

Creates a multiple results error for execute_one/2.

# `no_results_error`

```elixir
@spec no_results_error(String.t()) :: t()
```

Creates a no results error for execute_one/2.

# `query_error`

```elixir
@spec query_error(String.t(), String.t() | nil, [term()], map()) :: t()
```

Creates a query execution error with SQL context.

# `query_generation_error`

```elixir
@spec query_generation_error(String.t(), map()) :: t()
```

Creates a query generation error.

# `timeout_error`

```elixir
@spec timeout_error(String.t(), map()) :: t()
```

Creates a timeout error.

# `to_display_message`

```elixir
@spec to_display_message(t()) :: String.t()
```

Creates a user-friendly error message for display.

# `to_exception`

```elixir
@spec to_exception(t()) :: Exception.t()
```

Converts a Selecto.Error to an exception for raising.

# `transformation_error`

```elixir
@spec transformation_error(String.t(), map()) :: t()
```

Creates a transformation error for output format processing.

# `validation_error`

```elixir
@spec validation_error(String.t(), map()) :: t()
```

Creates a validation error.

---

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