Struct ValidationError 

pub struct ValidationError { /* private fields */ }

A validation error is a Serializable object that contains the path where the validation error of a certain kind ocurred, and an optional and arbitrary piece of meta-information.

Implementations

impl ValidationError

pub fn kind(&self) -> &ValidationErrorKind

pub fn message(&self) -> &str

impl ValidationError

pub fn unexpected_runtime_error(message: String) -> Self

Creates an ValidationErrorKind::UnexpectedRuntimeError kind of error when something unexpected happen at runtime after a query was properly validated by the parser against the schema.

pub fn empty_selection( selection_path: Vec<&str>, output_type_description: OutputTypeDescription, ) -> Self

Creates an ValidationErrorKind::EmptySelection kind of error, which happens when the selection of fields is empty for a query.

Example json query:

{ “action”: “findMany”, “modelName”: “User”, “query”: { “selection”: {} } }

pub fn invalid_argument_type( selection_path: Vec<&str>, argument_path: Vec<&str>, argument_description: ArgumentDescription<'_>, inferred_argument_type: String, ) -> Self

Creates an ValidationErrorKind::InvalidArgumentType kind of error, which happens when the argument is of a type that is incompatible with its definition.

Say the schema type for user.id is Int

The example json query will fail, as it’s trying to pass a string instead.

{ “action”: “findMany”, “modelName”: “User”, “query”: { “arguments”: { “where”: { “id”: “a22b8732-be32-4a30-9b38-78843aaa48f8” } }, “selection”: { “$scalars”: true } } }

pub fn invalid_argument_value( selection_path: Vec<&str>, argument_path: Vec<&str>, value: String, expected_argument_type: &str, underlying_err: Option<Box<dyn Error>>, ) -> Self

Creates an ValidationErrorKind::InvalidArgumentValue kind of error, which happens when the argument is of the correct type, but its value is invalid, said a negative number on a type that is integer but which values should be non-negative. Or a uuid which type is correctly a string, but its format is not the appropriate.

Say the schema type for user.id is Int

The example json query will fail, as it’s trying to pass a string instead.

{ “action”: “findMany”, “modelName”: “User”, “query”: { “arguments”: { “where”: { “dob”: “invalid date” } }, “selection”: { “$scalars”: true } } }

pub fn some_fields_missing( selection_path: Vec<&str>, argument_path: Vec<&str>, min_field_count: Option<usize>, max_field_count: Option<usize>, required_fields: Option<Vec<Cow<'_, str>>>, provided_field_count: usize, input_type_description: &InputTypeDescription, ) -> Self

Creates an ValidationErrorKind::SomeFieldsMissing kind of error, which happens when there are some fields missing from a query

pub fn too_many_fields_given( selection_path: Vec<&str>, argument_path: Vec<&str>, min_field_count: Option<usize>, max_field_count: Option<usize>, required_fields: Option<Vec<Cow<'_, str>>>, provided_field_count: usize, input_type_description: &InputTypeDescription, ) -> Self

Creates an ValidationErrorKind::SomeFieldsMissing kind of error, which happens when there are more fields given than the ones a type accept

pub fn required_argument_missing( selection_path: Vec<&str>, argument_path: Vec<&str>, input_type_descriptions: &[InputTypeDescription], ) -> Self

Creates an ValidationErrorKind::RequiredArgumentMissing kind of error, which happens when there is a missing argument for a field missing, like the where field below.

Example json query:

{ “action”: “findMany”, “modelName”: “User”, “query”: { “selection”: {} } }

pub fn conditionally_required_argument_missing( selection_path: &[&str], argument_path: &[&str], dependent_argument_path: &[&str], input_type_descriptions: &[InputTypeDescription], ) -> Self

Creates a ValidationErrorKind::RequiredArgumentMissing kind of error for a conditionally required argument which needs to be present in the current query because another argument which depends on it was provided.

Example json query (take requires orderBy in views):

{
    "action": "findMany",
    "modelName": "UserView",
    "query": {
        "arguments": {
            "take": "1"
        },
        "selection": {
            "$scalars": true
        }
    }
}

pub fn unknown_argument( selection_path: Vec<&str>, argument_path: Vec<&str>, valid_argument_descriptions: Vec<ArgumentDescription<'_>>, ) -> Self

Creates an ValidationErrorKind::UnknownArgument kind of error, which happens when the arguments for a query are not congruent with those expressed in the schema

Example json query:

{ “action”: “findMany”, “modelName”: “User”, “query”: { “arguments”: { “foo”: “123” }, “selection”: { “$scalars”: true } } } Todo: add the given type to the meta

pub fn unknown_input_field( selection_path: Vec<&str>, argument_path: Vec<&str>, input_type_description: InputTypeDescription, ) -> Self

Creates a ValidationErrorKind::UnknownInputField kind of error, which happens when the argument value for a query contains a field that does not exist in the schema for the input type.

TODO: how is this conceptually different from an unknown argument? This used to be a FieldNotFoundError (see old code), but the same FieldNotFoundError was used to denote what’s now an UnknownSelectionField.

Example json query:

{ “action”: “findMany”, “modelName”: “User”, “query”: { “arguments”: { “where”: { “foo”: 2 } }, “selection”: { “$scalars”: true } } }

pub fn unknown_selection_field( selection_path: Vec<&str>, output_type_description: OutputTypeDescription, ) -> Self

Creates an ValidationErrorKind::UnknownSelectionField kind of error, which happens when the selection of fields for a query contains a field that does not exist in the schema for the enclosing type

Example json query:

{ “action”: “findMany”, “modelName”: “User”, “query”: { “selection”: { “notAField”: true } }

pub fn selection_set_on_scalar( field_name: String, selection_path: Vec<&str>, ) -> Self

Creates an ValidationErrorKind::SelectionSetOnScalar kind of error, which happens when there is a nested selection block on a scalar field

Example json query:

{ “action”: “findMany”, “modelName”: “User”, “query”: { “selection”: { “email”: { “selection”: { “id”: true } } } } }

pub fn union(errors: Vec<ValidationError>) -> Self

Creates an error that is the union of different validation errors

pub fn value_too_large( selection_path: Vec<&str>, argument_path: Vec<&str>, value: String, ) -> Self

Creates an ValidationErrorKind::ValueTooLarge kind of error, which happens when the value for a float or integer coming from the JS client is larger than what can fit in an i64 (2^64 - 1 = 18446744073709550000)

Example json query

{ “action”: “findMany”, “modelName”: “User”, “query”: { “arguments”: { “where”: { “id”: 18446744073709550000 // too large } }, “selection”: { “$scalars”: true } } }

Trait Implementations

impl Debug for ValidationError

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

Formats the value using the given formatter.

impl Display for ValidationError

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

Formats the value using the given formatter.

impl Error for ValidationError

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 From<ValidationError> for Error

fn from(err: ValidationError) -> Self

Converts to this type from the input type.

impl From<ValidationError> for KnownError

fn from(err: ValidationError) -> Self

Converts to this type from the input type.

impl Serialize for ValidationError

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

where __S: Serializer,

Serialize this value into the given Serde serializer.