Struct user_facing_errors::query_engine::validation::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 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 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 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.