STRLCPY/graphql-engine

break out BooleanExpressionError from Error (#449)

<!-- Thank you for submitting this PR! :) -->

## Description

Further breaking up the big error type. Functional no-op.

V3_GIT_ORIGIN_REV_ID: d34acb7fd6421c250c214b133b8a107e03155c70

Daniel Harvey committed with hasura-bot 1 month ago

66e012f5

1 parent 6f8470ca

Revision indexing in progress... (symbol navigation in revisions will be accurate after indexed)

Total 5 files Show one by one

■ ■ ■ ■ ■ ■

v3/crates/engine/src/metadata/resolved/error.rs

		skipped 262 lines
263	263		model_name: Qualified<ModelName>,
264	264		type_representation: TypeRepresentation,
265	265		},
266		-	#[error("unknown type used in object boolean expression: {type_name:}")]
267		-	UnknownTypeInObjectBooleanExpressionType {
268		-	type_name: Qualified<CustomTypeName>,
269		-	},
270		-	#[error("unsupported type used in object boolean expression: {type_name:}; only object types are supported")]
271		-	UnsupportedTypeInObjectBooleanExpressionType {
272		-	type_name: Qualified<CustomTypeName>,
273		-	},
274		-	#[error("unknown data connector {data_connector:} referenced in object boolean expression type {boolean_expression_type:}")]
275		-	UnknownDataConnectorInObjectBooleanExpressionType {
276		-	data_connector: Qualified<DataConnectorName>,
277		-	boolean_expression_type: Qualified<CustomTypeName>,
278		-	},
279		-	#[error("unknown data connector object type {data_connector_object_type:} (in data connector {data_connector:}) referenced in object boolean expression type {boolean_expression_type:}")]
280		-	UnknownDataConnectorTypeInObjectBooleanExpressionType {
281		-	data_connector: Qualified<DataConnectorName>,
282		-	data_connector_object_type: String,
283		-	boolean_expression_type: Qualified<CustomTypeName>,
284		-	},
285		-	#[error("unknown field '{field_name:}' used in object boolean expression type {boolean_expression_type:}")]
286		-	UnknownFieldInObjectBooleanExpressionType {
287		-	field_name: FieldName,
288		-	boolean_expression_type: Qualified<CustomTypeName>,
289		-	},
290		-	#[error("the object type '{object_type:}' used in boolean expression type {boolean_expression_type:} does not have a mapping to object {data_connector_object_type:} of data connector {data_connector:}")]
291		-	NoDataConnectorTypeMappingForObjectTypeInBooleanExpression {
292		-	object_type: Qualified<CustomTypeName>,
293		-	boolean_expression_type: Qualified<CustomTypeName>,
294		-	data_connector_object_type: String,
295		-	data_connector: Qualified<DataConnectorName>,
296		-	},
297		-	#[error("the following object boolean expression type is defined more than once: {name:}")]
298		-	DuplicateObjectBooleanExpressionTypeDefinition { name: Qualified<CustomTypeName> },
299		-	#[error("unknown object boolean expression type {name:} is used in model {model:}")]
300		-	UnknownBooleanExpressionTypeInModel {
301		-	name: Qualified<CustomTypeName>,
302		-	model: Qualified<ModelName>,
303		-	},
304		-	#[error("the boolean expression type {name:} used in model {model:} corresponds to object type {boolean_expression_object_type:} whereas the model's object type is {model_object_type:}")]
305		-	BooleanExpressionTypeForInvalidObjectTypeInModel {
306		-	name: Qualified<CustomTypeName>,
307		-	boolean_expression_object_type: Qualified<CustomTypeName>,
308		-	model: Qualified<ModelName>,
309		-	model_object_type: Qualified<CustomTypeName>,
310		-	},
311	266		#[error("a source must be defined for model {model:} in order to use filter expressions")]
312	267		CannotUseFilterExpressionsWithoutSource { model: Qualified<ModelName> },
313	268		#[error("graphql config must be defined for a filter expression to be used in a {model:}")]
		skipped 267 lines
581	536		#[error("{relationship_error:}")]
582	537		RelationshipError {
583	538		relationship_error: RelationshipError,
	539	+	},
	540	+	#[error("{boolean_expression_error:}")]
	541	+	BooleanExpressionError {
	542	+	boolean_expression_error: BooleanExpressionError,
	543	+	},
	544	+	}
	545	+
	546	+	impl From<BooleanExpressionError> for Error {
	547	+	fn from(val: BooleanExpressionError) -> Self {
	548	+	Error::BooleanExpressionError {
	549	+	boolean_expression_error: val,
	550	+	}
	551	+	}
	552	+	}
	553	+
	554	+	#[derive(Debug, Error)]
	555	+	pub enum BooleanExpressionError {
	556	+	#[error("unknown type used in object boolean expression: {type_name:}")]
	557	+	UnknownTypeInObjectBooleanExpressionType {
	558	+	type_name: Qualified<CustomTypeName>,
	559	+	},
	560	+	#[error("unsupported type used in object boolean expression: {type_name:}; only object types are supported")]
	561	+	UnsupportedTypeInObjectBooleanExpressionType {
	562	+	type_name: Qualified<CustomTypeName>,
	563	+	},
	564	+	#[error("unknown data connector {data_connector:} referenced in object boolean expression type {boolean_expression_type:}")]
	565	+	UnknownDataConnectorInObjectBooleanExpressionType {
	566	+	data_connector: Qualified<DataConnectorName>,
	567	+	boolean_expression_type: Qualified<CustomTypeName>,
	568	+	},
	569	+	#[error("unknown data connector object type {data_connector_object_type:} (in data connector {data_connector:}) referenced in object boolean expression type {boolean_expression_type:}")]
	570	+	UnknownDataConnectorTypeInObjectBooleanExpressionType {
	571	+	data_connector: Qualified<DataConnectorName>,
	572	+	data_connector_object_type: String,
	573	+	boolean_expression_type: Qualified<CustomTypeName>,
	574	+	},
	575	+	#[error("unknown field '{field_name:}' used in object boolean expression type {boolean_expression_type:}")]
	576	+	UnknownFieldInObjectBooleanExpressionType {
	577	+	field_name: FieldName,
	578	+	boolean_expression_type: Qualified<CustomTypeName>,
	579	+	},
	580	+	#[error("the object type '{object_type:}' used in boolean expression type {boolean_expression_type:} does not have a mapping to object {data_connector_object_type:} of data connector {data_connector:}")]
	581	+	NoDataConnectorTypeMappingForObjectTypeInBooleanExpression {
	582	+	object_type: Qualified<CustomTypeName>,
	583	+	boolean_expression_type: Qualified<CustomTypeName>,
	584	+	data_connector_object_type: String,
	585	+	data_connector: Qualified<DataConnectorName>,
	586	+	},
	587	+	#[error("the following object boolean expression type is defined more than once: {name:}")]
	588	+	DuplicateObjectBooleanExpressionTypeDefinition { name: Qualified<CustomTypeName> },
	589	+	#[error("unknown object boolean expression type {name:} is used in model {model:}")]
	590	+	UnknownBooleanExpressionTypeInModel {
	591	+	name: Qualified<CustomTypeName>,
	592	+	model: Qualified<ModelName>,
	593	+	},
	594	+	#[error("the boolean expression type {name:} used in model {model:} corresponds to object type {boolean_expression_object_type:} whereas the model's object type is {model_object_type:}")]
	595	+	BooleanExpressionTypeForInvalidObjectTypeInModel {
	596	+	name: Qualified<CustomTypeName>,
	597	+	boolean_expression_object_type: Qualified<CustomTypeName>,
	598	+	model: Qualified<ModelName>,
	599	+	model_object_type: Qualified<CustomTypeName>,
584	600		},
585	601		}
586	602
		skipped 149 lines

■ ■ ■ ■ ■ ■

v3/crates/engine/src/metadata/resolved/metadata.rs

		skipped 14 lines
15	15
16	16		use crate::metadata::resolved::command;
17	17		use crate::metadata::resolved::data_connector::DataConnectorContext;
18		-	use crate::metadata::resolved::error::Error;
	18	+	use crate::metadata::resolved::error::{BooleanExpressionError, Error};
19	19		use crate::metadata::resolved::model::{
20	20		resolve_model, resolve_model_graphql_api, resolve_model_select_permissions,
21	21		resolve_model_source, Model,
		skipped 464 lines
486	486		resolved_boolean_expression.name.clone(),
487	487		resolved_boolean_expression,
488	488		) {
489		-	return Err(Error::DuplicateObjectBooleanExpressionTypeDefinition {
490		-	name: existing.name,
491		-	});
	489	+	return Err(Error::from(
	490	+	BooleanExpressionError::DuplicateObjectBooleanExpressionTypeDefinition {
	491	+	name: existing.name,
	492	+	},
	493	+	));
492	494		}
493	495		}
494	496		Ok(boolean_expression_types)
		skipped 303 lines

■ ■ ■ ■ ■ ■

v3/crates/engine/src/metadata/resolved/model.rs

1	1		use crate::metadata::resolved::argument::get_argument_mappings;
2	2		use crate::metadata::resolved::data_connector::get_simple_scalar;
3	3		use crate::metadata::resolved::data_connector::{DataConnectorContext, DataConnectorLink};
4		-	use crate::metadata::resolved::error::{Error, GraphqlConfigError, RelationshipError};
	4	+	use crate::metadata::resolved::error::{
	5	+	BooleanExpressionError, Error, GraphqlConfigError, RelationshipError,
	6	+	};
5	7		use crate::metadata::resolved::ndc_validation;
6	8		use crate::metadata::resolved::stages::graphql_config::GraphqlConfig;
7	9		use crate::metadata::resolved::subgraph::{
		skipped 202 lines
210	212		Qualified::new(subgraph.to_string(), filter_expression_type.clone());
211	213		let boolean_expression_type = boolean_expression_types
212	214		.get(&boolean_expression_type_name)
213		-	.ok_or_else(\|\| Error::UnknownBooleanExpressionTypeInModel {
214		-	name: boolean_expression_type_name.clone(),
215		-	model: Qualified::new(subgraph.to_string(), model.name.clone()),
	215	+	.ok_or_else(\|\| {
	216	+	Error::from(
	217	+	BooleanExpressionError::UnknownBooleanExpressionTypeInModel {
	218	+	name: boolean_expression_type_name.clone(),
	219	+	model: Qualified::new(subgraph.to_string(), model.name.clone()),
	220	+	},
	221	+	)
216	222		})?;
217	223		if boolean_expression_type.object_type != *model_data_type {
218		-	return Err(Error::BooleanExpressionTypeForInvalidObjectTypeInModel {
219		-	name: boolean_expression_type_name.clone(),
220		-	boolean_expression_object_type: boolean_expression_type.object_type.clone(),
221		-	model: Qualified::new(subgraph.to_string(), model.name.clone()),
222		-	model_object_type: model_data_type.clone(),
223		-	});
	224	+	return Err(Error::from(
	225	+	BooleanExpressionError::BooleanExpressionTypeForInvalidObjectTypeInModel {
	226	+	name: boolean_expression_type_name.clone(),
	227	+	boolean_expression_object_type: boolean_expression_type.object_type.clone(),
	228	+	model: Qualified::new(subgraph.to_string(), model.name.clone()),
	229	+	model_object_type: model_data_type.clone(),
	230	+	},
	231	+	));
224	232		}
225	233		// This is also checked in resolve_model_graphql_api, but we want to disallow this even
226	234		// if the model is not used in the graphql layer.
		skipped 1201 lines

■ ■ ■ ■ ■ ■

v3/crates/engine/src/metadata/resolved/types.rs

1		-	use crate::metadata::resolved::error::{Error, TypeMappingValidationError};
	1	+	use crate::metadata::resolved::error::{BooleanExpressionError, Error, TypeMappingValidationError};
2	2		use crate::metadata::resolved::relationship::Relationship;
3	3		use crate::metadata::resolved::subgraph::{
4	4		mk_qualified_type_reference, Qualified, QualifiedBaseType, QualifiedTypeName,
		skipped 499 lines
504	504		object_boolean_expression.object_type.to_owned(),
505	505		);
506	506		let type_representation = types.get(&qualified_object_type_name).ok_or_else(\|\| {
507		-	Error::UnknownTypeInObjectBooleanExpressionType {
508		-	type_name: qualified_object_type_name.clone(),
509		-	}
	507	+	Error::from(
	508	+	BooleanExpressionError::UnknownTypeInObjectBooleanExpressionType {
	509	+	type_name: qualified_object_type_name.clone(),
	510	+	},
	511	+	)
510	512		})?;
511	513		match type_representation {
512	514		// validate it should only be an object type
513		-	TypeRepresentation::ScalarType { .. } => {
514		-	Err(Error::UnsupportedTypeInObjectBooleanExpressionType {
	515	+	TypeRepresentation::ScalarType { .. } => Err(Error::from(
	516	+	BooleanExpressionError::UnsupportedTypeInObjectBooleanExpressionType {
515	517		type_name: qualified_name.clone(),
516		-	})
517		-	}
	518	+	},
	519	+	)),
518	520		TypeRepresentation::Object(object_type_representation) => {
519	521		let qualified_data_connector_name = Qualified::new(
520	522		subgraph.to_string(),
		skipped 3 lines
524	526		// validate data connector name
525	527		let data_connector_context = data_connectors
526	528		.get(&qualified_data_connector_name)
527		-	.ok_or_else(
528		-	\|\| Error::UnknownDataConnectorInObjectBooleanExpressionType {
529		-	data_connector: qualified_data_connector_name.clone(),
530		-	boolean_expression_type: qualified_name.clone(),
531		-	},
532		-	)?;
	529	+	.ok_or_else(\|\| {
	530	+	Error::from(
	531	+	BooleanExpressionError::UnknownDataConnectorInObjectBooleanExpressionType {
	532	+	data_connector: qualified_data_connector_name.clone(),
	533	+	boolean_expression_type: qualified_name.clone(),
	534	+	},
	535	+	)
	536	+	})?;
533	537
534	538		// validate data connector object type
535	539		if !data_connector_context
		skipped 1 lines
537	541		.object_types
538	542		.contains_key(&object_boolean_expression.data_connector_object_type)
539	543		{
540		-	return Err(
541		-	Error::UnknownDataConnectorTypeInObjectBooleanExpressionType {
	544	+	return Err(Error::from(
	545	+	BooleanExpressionError::UnknownDataConnectorTypeInObjectBooleanExpressionType {
542	546		data_connector: qualified_data_connector_name.clone(),
543	547		boolean_expression_type: qualified_name.clone(),
544	548		data_connector_object_type: object_boolean_expression
545	549		.data_connector_object_type
546	550		.clone(),
547	551		},
548		-	);
	552	+	));
549	553		}
550	554
551	555		data_connector_type_mappings
		skipped 3 lines
555	559		&object_boolean_expression.data_connector_object_type,
556	560		)
557	561		.ok_or_else(\|\| {
558		-	Error::NoDataConnectorTypeMappingForObjectTypeInBooleanExpression {
	562	+	Error::from(BooleanExpressionError::NoDataConnectorTypeMappingForObjectTypeInBooleanExpression {
559	563		object_type: qualified_object_type_name.clone(),
560	564		boolean_expression_type: qualified_name.clone(),
561	565		data_connector_object_type: object_boolean_expression
562	566		.data_connector_object_type
563	567		.clone(),
564	568		data_connector: qualified_data_connector_name.clone(),
565		-	}
	569	+	})
566	570		})?;
567	571
568	572		// validate comparable fields
		skipped 2 lines
571	575		.fields
572	576		.contains_key(&comparable_field.field_name)
573	577		{
574		-	return Err(Error::UnknownFieldInObjectBooleanExpressionType {
575		-	field_name: comparable_field.field_name.clone(),
576		-	boolean_expression_type: qualified_name.clone(),
577		-	});
	578	+	return Err(
	579	+	BooleanExpressionError::UnknownFieldInObjectBooleanExpressionType {
	580	+	field_name: comparable_field.field_name.clone(),
	581	+	boolean_expression_type: qualified_name.clone(),
	582	+	}
	583	+	.into(),
	584	+	);
578	585		}
579	586
580	587		// As of now, only `"enableAll": true` is allowed for field operators
		skipped 178 lines

■ ■ ■ ■ ■ ■

v3/crates/engine/tests/validate_metadata.rs

1	1		use std::fs;
2	2		use std::path::PathBuf;
3	3
	4	+	use engine::metadata::resolved::error::BooleanExpressionError;
4	5		use engine::metadata::resolved::error::Error as ResolveError;
5	6		use engine::schema::Error as SchemaError;
6	7		use engine::schema::GDS;
		skipped 260 lines
267	268		matches!(
268	269		gds,
269	270		Err(SchemaError::ResolveError {
270		-	error: ResolveError::BooleanExpressionTypeForInvalidObjectTypeInModel { .. }
	271	+	error: ResolveError::BooleanExpressionError {
	272	+	boolean_expression_error:
	273	+	BooleanExpressionError::BooleanExpressionTypeForInvalidObjectTypeInModel { .. }
	274	+	}
271	275		})
272	276		),
273	277		"actual: {gds:?}"
		skipped 49 lines
323	327		matches!(
324	328		gds,
325	329		Err(SchemaError::ResolveError {
326		-	error: ResolveError::NoDataConnectorTypeMappingForObjectTypeInBooleanExpression { .. }
	330	+	error: ResolveError::BooleanExpressionError { boolean_expression_error:BooleanExpressionError::NoDataConnectorTypeMappingForObjectTypeInBooleanExpression { .. }}
327	331		})
328	332		),
329	333		"actual: {gds:?}"
		skipped 33 lines