STRLCPY/graphql-engine

resolve ValueExpression (#436)

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

## Description

We'll shortly be adding `BooleanExpression` to `ValueExpression`, which
will require resolving the internal `ModelPredicate`. This PR adds a
resolving step for `ValueExpression` to simplify that later step. It is
essentially a no-op to introduce a new type.

V3_GIT_ORIGIN_REV_ID: 8bfe4a180e12ae50d8f131072886054c0e618ec4

Daniel Harvey committed with hasura-bot 2 months ago

c53c581a

1 parent 46cb1bfe

Total 6 files Show one by one

■ ■ ■ ■ ■ ■

v3/crates/engine/src/execute/ir/permissions.rs

		skipped 3 lines
4	4		use lang_graphql::normalized_ast;
5	5		use ndc_client::models as ndc_models;
6	6
7		-	use open_dds::{permissions::ValueExpression, types::InbuiltType};
	7	+	use open_dds::types::InbuiltType;
8	8
9	9		use crate::execute::error::{Error, InternalDeveloperError, InternalEngineError, InternalError};
10	10		use crate::execute::model_tracking::{count_model, UsagesCounts};
		skipped 178 lines
189	189		ndc_column: String,
190	190		argument_type: &QualifiedTypeReference,
191	191		operator: &str,
192		-	value_expression: &ValueExpression,
	192	+	value_expression: &resolved::permission::ValueExpression,
193	193		session_variables: &SessionVariables,
194	194		relationship_paths: &Vec<NDCRelationshipName>,
195	195		) -> Result<ndc_models::Expression, Error> {
		skipped 28 lines
224	224		}
225	225
226	226		pub(crate) fn make_value_from_value_expression(
227		-	val_expr: &ValueExpression,
	227	+	val_expr: &resolved::permission::ValueExpression,
228	228		value_type: &QualifiedTypeReference,
229	229		session_variables: &SessionVariables,
230	230		) -> Result<serde_json::Value, Error> {
231	231		match val_expr {
232		-	ValueExpression::Literal(val) => Ok(val.clone()),
233		-	ValueExpression::SessionVariable(session_var) => {
	232	+	resolved::permission::ValueExpression::Literal(val) => Ok(val.clone()),
	233	+	resolved::permission::ValueExpression::SessionVariable(session_var) => {
234	234		let value = session_variables.get(session_var).ok_or_else(\|\| {
235	235		InternalDeveloperError::MissingSessionVariable {
236	236		session_variable: session_var.clone(),
		skipped 65 lines

■ ■ ■ ■ ■ ■

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

		skipped 14 lines
15	15		self, CommandName, CommandV1, DataConnectorCommand, GraphQlRootFieldKind,
16	16		};
17	17		use open_dds::data_connector::DataConnectorName;
18		-	use open_dds::permissions::{CommandPermissionsV1, Role, ValueExpression};
	18	+	use open_dds::permissions::{CommandPermissionsV1, Role};
19	19		use open_dds::types::{BaseType, CustomTypeName, Deprecated, TypeName, TypeReference};
20	20		use serde::{Deserialize, Serialize};
21	21		use std::collections::{BTreeMap, HashMap};
22	22
23	23		use super::metadata::DataConnectorTypeMappings;
	24	+	use super::permission::{resolve_value_expression, ValueExpression};
24	25		use super::typecheck;
25	26		use super::types::{
26	27		collect_type_mapping_for_source, TypeMappingCollectionError, TypeMappingToCollect,
		skipped 277 lines
304	305		Some(argument) => {
305	306		// if our value is a literal, typecheck it against expected type
306	307		match &argument_preset.value {
307		-	ValueExpression::SessionVariable(_) => Ok(()),
308		-	ValueExpression::Literal(json_value) => {
	308	+	open_dds::permissions::ValueExpression::SessionVariable(_) => Ok(()),
	309	+	open_dds::permissions::ValueExpression::Literal(json_value) => {
309	310		typecheck::typecheck_qualified_type_reference(
310	311		&argument.argument_type,
311	312		json_value,
		skipped 11 lines
323	324		argument_preset.argument.clone(),
324	325		(
325	326		argument.argument_type.clone(),
326		-	argument_preset.value.clone(),
	327	+	resolve_value_expression(argument_preset.value.clone()),
327	328		),
328	329		);
329	330		}
		skipped 18 lines

■ ■ ■ ■ ■ ■

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

		skipped 25 lines
26	26		models::{
27	27		self, EnableAllOrSpecific, ModelGraphQlDefinition, ModelName, ModelV1, OrderableField,
28	28		},
29		-	permissions::{self, ModelPermissionsV1, Role, ValueExpression},
	29	+	permissions::{self, ModelPermissionsV1, Role},
30	30		types::{CustomTypeName, FieldName, OperatorName},
31	31		};
32	32		use serde::{Deserialize, Serialize};
		skipped 1 lines
34	34		use std::iter;
35	35
36	36		use super::metadata::DataConnectorTypeMappings;
	37	+	use super::permission::{resolve_value_expression, ValueExpression};
37	38		use super::relationship::RelationshipTarget;
38	39		use super::typecheck;
39	40		use super::types::{
		skipped 532 lines
572	573		ndc_column: field_mapping.column.clone(),
573	574		operator: resolved_operator,
574	575		argument_type,
575		-	value: value.clone(),
	576	+	value: resolve_value_expression(value.clone()),
576	577		})
577	578		} else {
578	579		Err(Error::ModelSourceRequiredForPredicate {
		skipped 218 lines
797	798		Some(argument) => {
798	799		// if our value is a literal, typecheck it against expected type
799	800		match &argument_preset.value {
800		-	ValueExpression::SessionVariable(_) => Ok(()),
801		-	ValueExpression::Literal(json_value) => {
	801	+	open_dds::permissions::ValueExpression::SessionVariable(_) => Ok(()),
	802	+	open_dds::permissions::ValueExpression::Literal(json_value) => {
802	803		typecheck::typecheck_qualified_type_reference(
803	804		&argument.argument_type,
804	805		json_value,
		skipped 8 lines
813	814		}
814	815		})?;
815	816
	817	+	let resolved_argument_value =
	818	+	resolve_value_expression(argument_preset.value.clone());
	819	+
816	820		argument_presets.insert(
817	821		argument_preset.argument.clone(),
818		-	(
819		-	argument.argument_type.clone(),
820		-	argument_preset.value.clone(),
821		-	),
	822	+	(argument.argument_type.clone(), resolved_argument_value),
822	823		);
823	824		}
824	825		None => {
		skipped 599 lines

■ ■ ■ ■ ■ ■

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

1	+	use serde::{Deserialize, Serialize};
2	+
3	+	#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
4	+	pub enum ValueExpression {
5	+	Literal(serde_json::Value),
6	+	SessionVariable(open_dds::session_variables::SessionVariable),
7	+	}
8	+
9	+	/// resolve a ValueExpression. This is currently a no-op but will be more involved
10	+	/// once we add BooleanExpression
11	+	pub(crate) fn resolve_value_expression(
12	+	value_expression: open_dds::permissions::ValueExpression,
13	+	) -> ValueExpression {
14	+	match value_expression {
15	+	open_dds::permissions::ValueExpression::Literal(literal) => {
16	+	ValueExpression::Literal(literal)
17	+	}
18	+	open_dds::permissions::ValueExpression::SessionVariable(session_variable) => {
19	+	ValueExpression::SessionVariable(session_variable)
20	+	}
21	+	}
22	+	}
23	+

■ ■ ■ ■ ■ ■

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

		skipped 5 lines
6	6		pub mod metadata;
7	7		pub mod model;
8	8		pub mod ndc_validation;
	9	+	pub mod permission;
9	10		pub mod relationship;
10	11		pub mod subgraph;
11	12		mod typecheck;
		skipped 2 lines

■ ■ ■ ■ ■ ■

v3/crates/engine/src/schema/types.rs

		skipped 14 lines
15	15		metadata::resolved::{
16	16		self,
17	17		data_connector::DataConnectorLink,
	18	+	permission::ValueExpression,
18	19		subgraph::{Qualified, QualifiedTypeReference},
19	20		types::NdcColumnForComparison,
20	21		},
		skipped 244 lines
265	266		#[derive(Serialize, Deserialize, Clone, Debug, PartialEq, Eq)]
266	267		/// Preset arguments for models or commands
267	268		pub struct ArgumentPresets {
268		-	pub argument_presets: BTreeMap<
269		-	ArgumentName,
270		-	(
271		-	QualifiedTypeReference,
272		-	open_dds::permissions::ValueExpression,
273		-	),
274		-	>,
	269	+	pub argument_presets: BTreeMap<ArgumentName, (QualifiedTypeReference, ValueExpression)>,
275	270		}
276	271
277	272		impl Display for ArgumentPresets {
		skipped 129 lines