Enum GraphQLError 

pub enum GraphQLError {
    ExecutionError(String),
    SchemaBuildError(String),
    RequestHandlingError(String),
    SerializationError(String),
    JsonError(String),
    ValidationError(String),
    ParseError(String),
    AuthenticationError(String),
    AuthorizationError(String),
    NotFound(String),
    RateLimitExceeded(String),
    InvalidInput {
        message: String,
    },
    ComplexityLimitExceeded,
    DepthLimitExceeded,
    InternalError(String),
}

Errors that can occur during GraphQL operations

These errors are compatible with async-graphql error handling and can be converted to structured HTTP responses matching the project’s error fixtures.

Variants

ExecutionError(String)

Error during schema execution

Occurs when the GraphQL executor encounters a runtime error during query execution.

SchemaBuildError(String)

Error during schema building

Occurs when schema construction fails due to invalid definitions or conflicts.

RequestHandlingError(String)

Error during request handling

Occurs when the HTTP request cannot be properly handled or parsed.

SerializationError(String)

Serialization error

Occurs during JSON serialization/deserialization of GraphQL values.

JsonError(String)

JSON parsing error

Occurs when JSON input cannot be parsed.

ValidationError(String)

GraphQL validation error

Occurs when a GraphQL query fails schema validation.

ParseError(String)

GraphQL parse error

Occurs when the GraphQL query string cannot be parsed.

AuthenticationError(String)

Authentication error

Occurs when request authentication fails.

AuthorizationError(String)

Authorization error

Occurs when user lacks required permissions.

NotFound(String)

Not found error

Occurs when a requested resource is not found.

RateLimitExceeded(String)

Rate limit error

Occurs when rate limit is exceeded.

InvalidInput

Invalid input error with validation details

Occurs during input validation with detailed error information.

Fields

message: String

Error message

ComplexityLimitExceeded

Query complexity limit exceeded

Occurs when a GraphQL query exceeds the configured complexity limit.

DepthLimitExceeded

Query depth limit exceeded

Occurs when a GraphQL query exceeds the configured depth limit.

InternalError(String)

Internal server error

Occurs when an unexpected internal error happens.

Implementations

impl GraphQLError

pub const fn status_code(&self) -> u16

Convert error to HTTP status code

Maps GraphQL error types to appropriate HTTP status codes:

• 400: Bad Request for parse/request-handling errors
• 401: Unauthorized for authentication errors
• 403: Forbidden for authorization errors
• 404: Not Found for resource not found
• 422: Unprocessable Entity for validation failures
• 429: Too Many Requests for rate limit errors
• 500: Internal Server Error for schema/serialization/internal errors
• 200: OK for GraphQL execution errors returned in GraphQL response body

Examples

use spikard_graphql::error::GraphQLError;

let error = GraphQLError::AuthenticationError("Invalid token".to_string());
assert_eq!(error.status_code(), 401);

let error = GraphQLError::ExecutionError("Query failed".to_string());
assert_eq!(error.status_code(), 200); // GraphQL spec: errors return 200 with errors in body

pub fn to_graphql_response(&self) -> Value

Convert error to GraphQL error response JSON

Returns a JSON object matching the GraphQL spec error format with structured extensions for HTTP integration.

Format

{
  "errors": [
    {
      "message": "error message",
      "extensions": {
        "code": "ERROR_CODE",
        "status": 400,
        "type": "https://spikard.dev/errors/..."
      }
    }
  ]
}

Examples

use spikard_graphql::error::GraphQLError;

let error = GraphQLError::ValidationError("Invalid query".to_string());
let json = error.to_graphql_response();
assert!(json["errors"].is_array());

pub fn to_http_response(&self) -> Value

Convert error to structured HTTP error response

Returns a JSON object matching the project’s error fixture format, suitable for direct HTTP response conversion.

Format

{
  "type": "https://spikard.dev/errors/...",
  "title": "Error Title",
  "status": 422,
  "detail": "error message",
  "errors": [
    {
      "type": "error_code",
      "message": "error message"
    }
  ]
}

Examples

use spikard_graphql::error::GraphQLError;

let error = GraphQLError::ValidationError("Invalid query".to_string());
let json = error.to_http_response();
assert_eq!(json["status"], 422);

pub const fn is_transient(&self) -> bool

Whether the error condition is transient and may succeed on retry.

Returns true for upstream/infrastructure failures (rate limit, internal error) and false for client-input errors (validation, parse, auth). Bindings forward this signal to retry/back-off logic.

pub const fn error_type(&self) -> &'static str

Stable machine-readable error type identifier (SCREAMING_SNAKE_CASE).

Public alias for the same codes returned by Self::error_code, kept available to bindings that surface the identifier alongside the human-readable message.

pub const fn error_code(&self) -> &'static str

Get the error code suitable for machine parsing

Returns a screaming SNAKE_CASE error code that identifies the error type.

Trait Implementations

impl Clone for GraphQLError

fn clone(&self) -> GraphQLError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for GraphQLError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GraphQLError

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for GraphQLError

fn fmt(&self, __formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Error for GraphQLError

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl Serialize for GraphQLError

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.