STRLCPY/graphql-engine

split out RelationshipError (#445)

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

## Description

More work to break down the giant `Error` type in metadata resolve step.

Functional no-op.

V3_GIT_ORIGIN_REV_ID: 8cfa4ad0bef254e93241d254123910bf3d5357f3

Daniel Harvey committed with hasura-bot 1 month ago

9b8915b5

1 parent 2a24b306

Total 3 files Show one by one

■ ■ ■ ■ ■ ■

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

		skipped 523 lines
524	524		UnknownDataType {
525	525		data_type: Qualified<CustomTypeName>,
526	526		},
527		-	#[error("source field {field_name} in field mapping for relationship {relationship_name} on type {source_type} is unknown.")]
528		-	UnknownSourceFieldInRelationshipMapping {
529		-	source_type: Qualified<CustomTypeName>,
530		-	relationship_name: RelationshipName,
531		-	field_name: FieldName,
532		-	},
533		-	#[error("target field {field_name} in field mapping for relationship {relationship_name} on type {source_type} to model {model_name} is unknown.")]
534		-	UnknownTargetFieldInRelationshipMapping {
535		-	source_type: Qualified<CustomTypeName>,
536		-	relationship_name: RelationshipName,
537		-	model_name: Qualified<ModelName>,
538		-	field_name: FieldName,
539		-	},
540		-	#[error("target argument {argument_name} in argument mapping for relationship {relationship_name} on type {source_type} to command {command_name} is unknown.")]
541		-	UnknownTargetArgumentInRelationshipMapping {
542		-	source_type: Qualified<CustomTypeName>,
543		-	relationship_name: RelationshipName,
544		-	command_name: Qualified<CommandName>,
545		-	argument_name: ArgumentName,
546		-	},
547		-	#[error("Mapping for source field {field_name} already exists in the relationship {relationship_name} on type {type_name}")]
548		-	MappingExistsInRelationship {
549		-	type_name: Qualified<CustomTypeName>,
550		-	field_name: FieldName,
551		-	relationship_name: RelationshipName,
552		-	},
553		-	#[error("Mapping for target argument {argument_name} of command {command_name} already exists in the relationship {relationship_name} on type {type_name}")]
554		-	ArgumentMappingExistsInRelationship {
555		-	argument_name: ArgumentName,
556		-	command_name: Qualified<CommandName>,
557		-	relationship_name: RelationshipName,
558		-	type_name: Qualified<CustomTypeName>,
559		-	},
560		-	#[error("No mapping for target command argument {argument_name} in the relationship {relationship_name} on type {type_name}")]
561		-	MissingArgumentMappingInRelationship {
562		-	type_name: Qualified<CustomTypeName>,
563		-	argument_name: ArgumentName,
564		-	relationship_name: RelationshipName,
565		-	},
566		-	#[error("The target data connector {data_connector_name} for relationship {relationship_name} on type {type_name} does not support the variables capability")]
567		-	RelationshipTargetDoesNotSupportForEach {
568		-	type_name: Qualified<CustomTypeName>,
569		-	relationship_name: RelationshipName,
570		-	data_connector_name: Qualified<DataConnectorName>,
571		-	},
572		-	#[error("The target data connector {data_connector_name} for relationship {relationship_name} on type {type_name} has not defined any capabilities")]
573		-	NoRelationshipCapabilitiesDefined {
574		-	type_name: Qualified<CustomTypeName>,
575		-	relationship_name: RelationshipName,
576		-	data_connector_name: Qualified<DataConnectorName>,
577		-	},
578	527		#[error("model {model_name:} with arguments is unsupported as a global ID source")]
579	528		ModelWithArgumentsAsGlobalIdSource { model_name: Qualified<ModelName> },
580	529		#[error(
		skipped 47 lines
628	577		#[error("{graphql_config_error:}")]
629	578		GraphqlConfigError {
630	579		graphql_config_error: GraphqlConfigError,
	580	+	},
	581	+	#[error("{relationship_error:}")]
	582	+	RelationshipError {
	583	+	relationship_error: RelationshipError,
	584	+	},
	585	+	}
	586	+
	587	+	#[derive(Debug, Error)]
	588	+	pub enum RelationshipError {
	589	+	#[error("source field {field_name} in field mapping for relationship {relationship_name} on type {source_type} is unknown.")]
	590	+	UnknownSourceFieldInRelationshipMapping {
	591	+	source_type: Qualified<CustomTypeName>,
	592	+	relationship_name: RelationshipName,
	593	+	field_name: FieldName,
	594	+	},
	595	+	#[error("target field {field_name} in field mapping for relationship {relationship_name} on type {source_type} to model {model_name} is unknown.")]
	596	+	UnknownTargetFieldInRelationshipMapping {
	597	+	source_type: Qualified<CustomTypeName>,
	598	+	relationship_name: RelationshipName,
	599	+	model_name: Qualified<ModelName>,
	600	+	field_name: FieldName,
	601	+	},
	602	+	#[error("target argument {argument_name} in argument mapping for relationship {relationship_name} on type {source_type} to command {command_name} is unknown.")]
	603	+	UnknownTargetArgumentInRelationshipMapping {
	604	+	source_type: Qualified<CustomTypeName>,
	605	+	relationship_name: RelationshipName,
	606	+	command_name: Qualified<CommandName>,
	607	+	argument_name: ArgumentName,
	608	+	},
	609	+	#[error("Mapping for source field {field_name} already exists in the relationship {relationship_name} on type {type_name}")]
	610	+	MappingExistsInRelationship {
	611	+	type_name: Qualified<CustomTypeName>,
	612	+	field_name: FieldName,
	613	+	relationship_name: RelationshipName,
	614	+	},
	615	+	#[error("Mapping for target argument {argument_name} of command {command_name} already exists in the relationship {relationship_name} on type {type_name}")]
	616	+	ArgumentMappingExistsInRelationship {
	617	+	argument_name: ArgumentName,
	618	+	command_name: Qualified<CommandName>,
	619	+	relationship_name: RelationshipName,
	620	+	type_name: Qualified<CustomTypeName>,
	621	+	},
	622	+	#[error("No mapping for target command argument {argument_name} in the relationship {relationship_name} on type {type_name}")]
	623	+	MissingArgumentMappingInRelationship {
	624	+	type_name: Qualified<CustomTypeName>,
	625	+	argument_name: ArgumentName,
	626	+	relationship_name: RelationshipName,
	627	+	},
	628	+	#[error("The target data connector {data_connector_name} for relationship {relationship_name} on type {type_name} does not support the variables capability")]
	629	+	RelationshipTargetDoesNotSupportForEach {
	630	+	type_name: Qualified<CustomTypeName>,
	631	+	relationship_name: RelationshipName,
	632	+	data_connector_name: Qualified<DataConnectorName>,
	633	+	},
	634	+	#[error("The target data connector {data_connector_name} for relationship {relationship_name} on type {type_name} has not defined any capabilities")]
	635	+	NoRelationshipCapabilitiesDefined {
	636	+	type_name: Qualified<CustomTypeName>,
	637	+	relationship_name: RelationshipName,
	638	+	data_connector_name: Qualified<DataConnectorName>,
631	639		},
632	640		}
633	641
		skipped 94 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};
	4	+	use crate::metadata::resolved::error::{Error, GraphqlConfigError, RelationshipError};
5	5		use crate::metadata::resolved::graphql_config::GraphqlConfig;
6	6		use crate::metadata::resolved::ndc_validation;
7	7		use crate::metadata::resolved::subgraph::{
		skipped 647 lines
655	655		target_model_source,
656	656		relationship,
657	657		)
658		-	.map_err(\|_\| Error::NoRelationshipCapabilitiesDefined {
659		-	relationship_name: relationship.name.clone(),
660		-	type_name: model.data_type.clone(),
661		-	data_connector_name: target_model_source
662		-	.data_connector
663		-	.name
664		-	.clone(),
	658	+	.map_err(\|_\| Error::RelationshipError {
	659	+	relationship_error:
	660	+	RelationshipError::NoRelationshipCapabilitiesDefined {
	661	+	relationship_name: relationship.name.clone(),
	662	+	type_name: model.data_type.clone(),
	663	+	data_connector_name: target_model_source
	664	+	.data_connector
	665	+	.name
	666	+	.clone(),
	667	+	},
665	668		})?;
666	669
667	670		let annotation = PredicateRelationshipAnnotation {
		skipped 757 lines

■ ■ ■ ■ ■ ■

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

1	1		use super::command::Command;
2	2		use super::data_connector::DataConnectorContext;
3	3		use super::data_connector::DataConnectorLink;
4		-	use super::error::Error;
	4	+	use super::error::{Error, RelationshipError};
5	5		use super::model::get_ndc_column_for_comparison;
6	6		use super::model::Model;
7	7		use super::subgraph::Qualified;
		skipped 121 lines
129	129		}),
130	130		[field_access] => {
131	131		if !source_type.fields.contains_key(&field_access.field_name) {
132		-	return Err(Error::UnknownSourceFieldInRelationshipMapping {
133		-	relationship_name: relationship_name.clone(),
134		-	source_type: source_type_name.clone(),
135		-	field_name: field_access.field_name.clone(),
	132	+	return Err(Error::RelationshipError {
	133	+	relationship_error:
	134	+	RelationshipError::UnknownSourceFieldInRelationshipMapping {
	135	+	relationship_name: relationship_name.clone(),
	136	+	source_type: source_type_name.clone(),
	137	+	field_name: field_access.field_name.clone(),
	138	+	},
136	139		});
137	140		};
138	141		Ok(field_access)
		skipped 54 lines
193	196		.type_fields
194	197		.contains_key(&resolved_relationship_target_mapping.field_name)
195	198		{
196		-	return Err(Error::UnknownTargetFieldInRelationshipMapping {
197		-	relationship_name: relationship.name.clone(),
198		-	source_type: source_type_name.clone(),
199		-	model_name: target_model.name.clone(),
200		-	field_name: resolved_relationship_source_mapping.field_name.clone(),
	199	+	return Err(Error::RelationshipError {
	200	+	relationship_error: RelationshipError::UnknownTargetFieldInRelationshipMapping {
	201	+	relationship_name: relationship.name.clone(),
	202	+	source_type: source_type_name.clone(),
	203	+	model_name: target_model.name.clone(),
	204	+	field_name: resolved_relationship_source_mapping.field_name.clone(),
	205	+	},
201	206		});
202	207		}
203	208
		skipped 27 lines
231	236		target_ndc_column,
232	237		})
233	238		} else {
234		-	Err(Error::MappingExistsInRelationship {
235		-	type_name: source_type_name.clone(),
236		-	field_name: resolved_relationship_source_mapping.field_name.clone(),
237		-	relationship_name: relationship.name.clone(),
	239	+	Err(Error::RelationshipError {
	240	+	relationship_error: RelationshipError::MappingExistsInRelationship {
	241	+	type_name: source_type_name.clone(),
	242	+	field_name: resolved_relationship_source_mapping.field_name.clone(),
	243	+	relationship_name: relationship.name.clone(),
	244	+	},
238	245		})
239	246		}
240	247		}?;
		skipped 34 lines
275	282
276	283		// Check if the target argument exists in the target command.
277	284		if !target_command.arguments.contains_key(target_argument_name) {
278		-	return Err(Error::UnknownTargetArgumentInRelationshipMapping {
279		-	relationship_name: relationship.name.clone(),
280		-	source_type: source_type_name.clone(),
281		-	command_name: target_command.name.clone(),
282		-	argument_name: target_argument_name.clone(),
	285	+	return Err(Error::RelationshipError {
	286	+	relationship_error: RelationshipError::UnknownTargetArgumentInRelationshipMapping {
	287	+	relationship_name: relationship.name.clone(),
	288	+	source_type: source_type_name.clone(),
	289	+	command_name: target_command.name.clone(),
	290	+	argument_name: target_argument_name.clone(),
	291	+	},
283	292		});
284	293		}
285	294
286	295		// Check if the target argument is already mapped to a field in the source type.
287	296		if !target_command_arguments_hashset_for_validation.insert(&target_argument_name.0) {
288		-	return Err(Error::ArgumentMappingExistsInRelationship {
289		-	argument_name: target_argument_name.clone(),
290		-	command_name: target_command.name.clone(),
291		-	relationship_name: relationship.name.clone(),
292		-	type_name: source_type_name.clone(),
	297	+	return Err(Error::RelationshipError {
	298	+	relationship_error: RelationshipError::ArgumentMappingExistsInRelationship {
	299	+	argument_name: target_argument_name.clone(),
	300	+	command_name: target_command.name.clone(),
	301	+	relationship_name: relationship.name.clone(),
	302	+	type_name: source_type_name.clone(),
	303	+	},
293	304		});
294	305		};
295	306
		skipped 7 lines
303	314		argument_name: target_argument_name.clone(),
304	315		})
305	316		} else {
306		-	Err(Error::MappingExistsInRelationship {
307		-	type_name: source_type_name.clone(),
308		-	field_name: resolved_relationship_source_mapping.field_name.clone(),
309		-	relationship_name: relationship.name.clone(),
	317	+	Err(Error::RelationshipError {
	318	+	relationship_error: RelationshipError::MappingExistsInRelationship {
	319	+	type_name: source_type_name.clone(),
	320	+	field_name: resolved_relationship_source_mapping.field_name.clone(),
	321	+	relationship_name: relationship.name.clone(),
	322	+	},
310	323		})
311	324		}
312	325		}?;
		skipped 34 lines
347	360		let capabilities = &resolved_data_connector.capabilities.capabilities;
348	361
349	362		if capabilities.query.variables.is_none() {
350		-	return Err(Error::RelationshipTargetDoesNotSupportForEach {
351		-	type_name: type_name.clone(),
352		-	relationship_name: relationship_name.clone(),
353		-	data_connector_name: data_connector.name.clone(),
	363	+	return Err(Error::RelationshipError {
	364	+	relationship_error: RelationshipError::RelationshipTargetDoesNotSupportForEach {
	365	+	type_name: type_name.clone(),
	366	+	relationship_name: relationship_name.clone(),
	367	+	data_connector_name: data_connector.name.clone(),
	368	+	},
354	369		});
355	370		};
356	371
		skipped 115 lines