Move annotation type back into metadata resolve (hasura#540)

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

## Description

We'd like to split metadata resolve into it's own crate to enforce
module boundaries better. In doing so, discovered that it's using a type
from the later schema stage called `PredicateRelationshipAnnotation`,
which isn't really an annotation type at all, just a data structure for
a resolved predicate.

This moves that types back into metadata resolve, renaming it to
`PredicateRelationshipInfo`.

Functional no-op.

V3_GIT_ORIGIN_REV_ID: 5b37ca77fb4ddf17093277e6727360d6077c4e06

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

@@ -24,9 +24,7 @@ use super::{
 
 use crate::execute::model_tracking::{count_model, UsagesCounts};
 use crate::metadata::resolved::{serialize_qualified_btreemap, Qualified};
-use crate::schema::types::output_type::relationship::{
-    ModelRelationshipAnnotation, ModelTargetSource,
-};
+use crate::schema::types::output_type::relationship::ModelRelationshipAnnotation;
 use crate::{
     execute::{ir::error, model_tracking::count_command},
     schema::types::output_type::relationship::{
@@ -49,7 +47,7 @@ pub(crate) struct LocalModelRelationshipInfo<'s> {
     pub source_data_connector: &'s resolved::DataConnectorLink,
     #[serde(serialize_with = "serialize_qualified_btreemap")]
     pub source_type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
-    pub target_source: &'s ModelTargetSource,
+    pub target_source: &'s resolved::ModelTargetSource,
     pub target_type: &'s Qualified<CustomTypeName>,
     pub mappings: &'s Vec<resolved::RelationshipModelMapping>,
 }
@@ -257,7 +255,7 @@ pub(crate) fn build_local_model_relationship<'s>(
     annotation: &'s ModelRelationshipAnnotation,
     data_connector: &'s resolved::DataConnectorLink,
     type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
-    target_source: &'s ModelTargetSource,
+    target_source: &'s resolved::ModelTargetSource,
     filter_clause: ResolvedFilterExpression<'s>,
     limit: Option<u32>,
     offset: Option<u32>,
@@ -344,7 +342,7 @@ pub(crate) fn build_remote_relationship<'n, 's>(
     field_call: &'n normalized_ast::FieldCall<'s, GDS>,
     annotation: &'s ModelRelationshipAnnotation,
     type_mappings: &'s BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
-    target_source: &'s ModelTargetSource,
+    target_source: &'s resolved::ModelTargetSource,
     filter_clause: ResolvedFilterExpression<'s>,
     limit: Option<u32>,
     offset: Option<u32>,

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

@@ -14,7 +14,9 @@ pub use stages::boolean_expressions::{
 pub use stages::command_permissions::CommandWithPermissions;
 pub use stages::commands::Command;
 pub use stages::data_connectors::DataConnectorLink;
-pub use stages::model_permissions::{FilterPermission, ModelPredicate, ModelWithPermissions};
+pub use stages::model_permissions::{
+    FilterPermission, ModelPredicate, ModelTargetSource, ModelWithPermissions,
+};
 pub use stages::models::{
     Model, ModelOrderByExpression, ModelSource, SelectManyGraphQlDefinition,
     SelectUniqueGraphQlDefinition,

v3/crates/engine/src/metadata/resolved/stages/model_permissions/mod.rs

@@ -7,7 +7,10 @@ use crate::metadata::resolved::types::permission::ValueExpression;
 use indexmap::IndexMap;
 use open_dds::{models::ModelName, types::CustomTypeName};
 use std::collections::{BTreeMap, HashMap};
-pub use types::{FilterPermission, ModelPredicate, ModelWithPermissions, SelectPermission};
+pub use types::{
+    FilterPermission, ModelPredicate, ModelTargetSource, ModelWithPermissions,
+    PredicateRelationshipInfo, SelectPermission,
+};
 
 use crate::metadata::resolved::helpers::argument::resolve_value_expression_for_argument;
 use crate::metadata::resolved::types::error::{Error, RelationshipError};
@@ -16,9 +19,6 @@ use crate::metadata::resolved::helpers::types::mk_name;
 use crate::metadata::resolved::types::subgraph::{
     mk_qualified_type_name, Qualified, QualifiedBaseType, QualifiedTypeReference,
 };
-use crate::schema::types::output_type::relationship::{
-    ModelTargetSource, PredicateRelationshipAnnotation,
-};
 
 use ndc_models;
 use open_dds::permissions::{FieldIsNullPredicate, NullableModelPredicate, RelationshipPredicate};
@@ -329,7 +329,7 @@ fn resolve_model_predicate(
                                         },
                                 })?;
 
-                                let annotation = PredicateRelationshipAnnotation {
+                                let annotation = PredicateRelationshipInfo {
                                     source_type: relationship.source.clone(),
                                     relationship_name: relationship.name.clone(),
                                     target_model_name: model_name.clone(),

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

@@ -1,11 +1,18 @@
-use crate::metadata::resolved::stages::models;
+use crate::metadata::resolved::stages::{data_connectors, models, object_types, relationships};
+use crate::metadata::resolved::types::error::{Error, RelationshipError};
 use crate::metadata::resolved::types::permission::ValueExpression;
+use crate::metadata::resolved::types::subgraph::{
+    deserialize_qualified_btreemap, serialize_qualified_btreemap,
+};
+use open_dds::{
+    models::ModelName,
+    relationships::{RelationshipName, RelationshipType},
+    types::CustomTypeName,
+};
 
 use std::collections::{BTreeMap, HashMap};
 
-use crate::metadata::resolved::types::subgraph::QualifiedTypeReference;
-
-use crate::schema::types::output_type::relationship::PredicateRelationshipAnnotation;
+use crate::metadata::resolved::types::subgraph::{Qualified, QualifiedTypeReference};
 
 use ndc_models;
 
@@ -46,10 +53,67 @@ pub enum ModelPredicate {
         value: ValueExpression,
     },
     Relationship {
-        relationship_info: PredicateRelationshipAnnotation,
+        relationship_info: PredicateRelationshipInfo,
         predicate: Box<ModelPredicate>,
     },
     And(Vec<ModelPredicate>),
     Or(Vec<ModelPredicate>),
     Not(Box<ModelPredicate>),
 }
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct PredicateRelationshipInfo {
+    pub relationship_name: RelationshipName,
+    pub relationship_type: RelationshipType,
+    pub source_type: Qualified<CustomTypeName>,
+    pub source_data_connector: data_connectors::DataConnectorLink,
+    #[serde(
+        serialize_with = "serialize_qualified_btreemap",
+        deserialize_with = "deserialize_qualified_btreemap"
+    )]
+    pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, object_types::TypeMapping>,
+    pub target_source: ModelTargetSource,
+    pub target_type: Qualified<CustomTypeName>,
+    pub target_model_name: Qualified<ModelName>,
+    pub mappings: Vec<relationships::RelationshipModelMapping>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
+pub struct ModelTargetSource {
+    pub(crate) model: models::ModelSource,
+    pub(crate) capabilities: relationships::RelationshipCapabilities,
+}
+
+impl ModelTargetSource {
+    pub fn new(
+        model: &ModelWithPermissions,
+        relationship: &relationships::Relationship,
+    ) -> Result<Option<Self>, Error> {
+        model
+            .model
+            .source
+            .as_ref()
+            .map(|model_source| Self::from_model_source(model_source, relationship))
+            .transpose()
+    }
+
+    pub fn from_model_source(
+        model_source: &models::ModelSource,
+        relationship: &relationships::Relationship,
+    ) -> Result<Self, Error> {
+        Ok(Self {
+            model: model_source.clone(),
+            capabilities: relationship
+                .target_capabilities
+                .as_ref()
+                .ok_or_else(|| Error::RelationshipError {
+                    relationship_error: RelationshipError::NoRelationshipCapabilitiesDefined {
+                        type_name: relationship.source.clone(),
+                        relationship_name: relationship.name.clone(),
+                        data_connector_name: model_source.data_connector.name.clone(),
+                    },
+                })?
+                .clone(),
+        })
+    }
+}

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

@@ -5,7 +5,7 @@ use open_dds::types::CustomTypeName;
 use std::collections::{BTreeMap, HashMap};
 
 use super::types::output_type::get_object_type_representation;
-use super::types::output_type::relationship::{FilterRelationshipAnnotation, ModelTargetSource};
+use super::types::output_type::relationship::FilterRelationshipAnnotation;
 use super::types::{BooleanExpressionAnnotation, InputAnnotation, TypeId};
 use crate::metadata::resolved;
 use crate::metadata::resolved::mk_name;
@@ -160,8 +160,10 @@ pub fn build_boolean_expression_input_schema(
                 // Build relationship field in filter expression only when
                 // the target_model is backed by a source
                 if let Some(target_source) = &target_model.model.source {
-                    let target_model_source =
-                        ModelTargetSource::from_model_source(target_source, relationship)?;
+                    let target_model_source = resolved::ModelTargetSource::from_model_source(
+                        target_source,
+                        relationship,
+                    )?;
 
                     // filter expression with relationships is currently only supported for local relationships
                     if let resolved::RelationshipExecutionCategory::Local =

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

@@ -5,7 +5,7 @@ use open_dds::models::ModelName;
 use open_dds::relationships::RelationshipType;
 use std::collections::{BTreeMap, HashMap};
 
-use super::types::output_type::relationship::{ModelTargetSource, OrderByRelationshipAnnotation};
+use super::types::output_type::relationship::OrderByRelationshipAnnotation;
 use super::types::{output_type::get_object_type_representation, Annotation, TypeId};
 use crate::metadata::resolved;
 use crate::metadata::resolved::mk_name;
@@ -178,8 +178,10 @@ pub fn build_model_order_by_input_schema(
                 if let (Some(target_source), Some(model_source)) =
                     (&target_model.model.source, &model.model.source)
                 {
-                    let target_model_source =
-                        ModelTargetSource::from_model_source(target_source, relationship)?;
+                    let target_model_source = resolved::ModelTargetSource::from_model_source(
+                        target_source,
+                        relationship,
+                    )?;
                     // order_by expression with relationships is currently only supported for local relationships
                     if let resolved::RelationshipExecutionCategory::Local =
                         resolved::relationship_execution_category(

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

@@ -10,7 +10,6 @@ use std::collections::{BTreeMap, HashMap, HashSet};
 
 use self::relationship::{
     CommandRelationshipAnnotation, CommandTargetSource, ModelRelationshipAnnotation,
-    ModelTargetSource,
 };
 use super::inbuilt_type::base_type_container_for_inbuilt_type;
 use super::{Annotation, PossibleApolloFederationTypes, TypeId};
@@ -340,7 +339,10 @@ fn object_type_fields(
                                 source_type: relationship.source.clone(),
                                 relationship_name: relationship.name.clone(),
                                 model_name: model_name.clone(),
-                                target_source: ModelTargetSource::new(model, relationship)?,
+                                target_source: resolved::ModelTargetSource::new(
+                                    model,
+                                    relationship,
+                                )?,
                                 target_type: target_typename.clone(),
                                 relationship_type: relationship_type.clone(),
                                 mappings: mappings.clone(),

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

@@ -25,7 +25,7 @@ pub struct ModelRelationshipAnnotation {
     pub source_type: Qualified<CustomTypeName>,
     pub relationship_name: RelationshipName,
     pub model_name: Qualified<ModelName>,
-    pub target_source: Option<ModelTargetSource>,
+    pub target_source: Option<resolved::ModelTargetSource>,
     pub target_type: Qualified<CustomTypeName>,
     pub relationship_type: RelationshipType,
     pub mappings: Vec<resolved::RelationshipModelMapping>,
@@ -42,7 +42,7 @@ pub struct FilterRelationshipAnnotation {
         deserialize_with = "deserialize_qualified_btreemap"
     )]
     pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
-    pub target_source: ModelTargetSource,
+    pub target_source: resolved::ModelTargetSource,
     pub target_type: Qualified<CustomTypeName>,
     pub target_model_name: Qualified<ModelName>,
     pub mappings: Vec<resolved::RelationshipModelMapping>,
@@ -59,66 +59,12 @@ pub struct OrderByRelationshipAnnotation {
         deserialize_with = "deserialize_qualified_btreemap"
     )]
     pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
-    pub target_source: ModelTargetSource,
+    pub target_source: resolved::ModelTargetSource,
     pub target_type: Qualified<CustomTypeName>,
     pub target_model_name: Qualified<ModelName>,
     pub mappings: Vec<resolved::RelationshipModelMapping>,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct PredicateRelationshipAnnotation {
-    pub relationship_name: RelationshipName,
-    pub relationship_type: RelationshipType,
-    pub source_type: Qualified<CustomTypeName>,
-    pub source_data_connector: resolved::DataConnectorLink,
-    #[serde(
-        serialize_with = "serialize_qualified_btreemap",
-        deserialize_with = "deserialize_qualified_btreemap"
-    )]
-    pub source_type_mappings: BTreeMap<Qualified<CustomTypeName>, resolved::TypeMapping>,
-    pub target_source: ModelTargetSource,
-    pub target_type: Qualified<CustomTypeName>,
-    pub target_model_name: Qualified<ModelName>,
-    pub mappings: Vec<resolved::RelationshipModelMapping>,
-}
-
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
-pub struct ModelTargetSource {
-    pub(crate) model: resolved::ModelSource,
-    pub(crate) capabilities: resolved::RelationshipCapabilities,
-}
-
-impl ModelTargetSource {
-    pub fn new(
-        model: &resolved::ModelWithPermissions,
-        relationship: &resolved::Relationship,
-    ) -> Result<Option<Self>, schema::Error> {
-        model
-            .model
-            .source
-            .as_ref()
-            .map(|model_source| Self::from_model_source(model_source, relationship))
-            .transpose()
-    }
-
-    pub fn from_model_source(
-        model_source: &resolved::ModelSource,
-        relationship: &resolved::Relationship,
-    ) -> Result<Self, schema::Error> {
-        Ok(Self {
-            model: model_source.clone(),
-            capabilities: relationship
-                .target_capabilities
-                .as_ref()
-                .ok_or_else(|| schema::Error::InternalMissingRelationshipCapabilities {
-                    type_name: relationship.source.clone(),
-                    relationship: relationship.name.clone(),
-                })?
-                .clone(),
-        })
-    }
-}
-
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
 pub struct CommandRelationshipAnnotation {
     pub source_type: Qualified<CustomTypeName>,