hasura · daniel-chambers · Apr 2, 2024 · Mar 26, 2024 · Mar 27, 2024 · Mar 28, 2024
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/crates/configuration/src/schema/database.rs b/crates/configuration/src/schema/database.rs
@@ -13,7 +13,7 @@ pub struct Collection {
     /// The name of a type declared in `objectTypes` that describes the fields of this collection.
     /// The type name may be the same as the collection name.
     pub r#type: String,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
 }
 
@@ -65,7 +65,7 @@ impl Type {
 #[serde(rename_all = "camelCase")]
 pub struct ObjectType {
     pub fields: BTreeMap<String, ObjectField>,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
 }
 
@@ -88,7 +88,7 @@ impl ObjectType {
 #[serde(rename_all = "camelCase")]
 pub struct ObjectField {
     pub r#type: Type,
-    #[serde(default)]
+    #[serde(default, skip_serializing_if = "Option::is_none")]
     pub description: Option<String>,
 }
 

diff --git a/crates/dc-api-test-helpers/src/field.rs b/crates/dc-api-test-helpers/src/field.rs
@@ -20,6 +20,19 @@ macro_rules! column {
     };
 }
 
+#[macro_export]
+macro_rules! relation_field {
+    ($relationship:literal => $name:literal, $query:expr) => {
+        (
+            $name.into(),
+            dc_api_types::Field::Relationship {
+                relationship: $relationship.to_owned(),
+                query: Box::new($query.into()),
+            },
+        )
+    };
+}
+
 #[macro_export()]
 macro_rules! nested_object_field {
     ($column:literal, $query:expr) => {

diff --git a/crates/dc-api-test-helpers/src/query.rs b/crates/dc-api-test-helpers/src/query.rs
@@ -30,6 +30,11 @@ impl QueryBuilder {
         self.predicate = Some(predicate);
         self
     }
+
+    pub fn order_by(mut self, order_by: OrderBy) -> Self {
+        self.order_by = Some(Some(order_by));
+        self
+    }
 }
 
 impl From<QueryBuilder> for Query {

diff --git a/crates/dc-api-test-helpers/src/query_request.rs b/crates/dc-api-test-helpers/src/query_request.rs
@@ -31,6 +31,11 @@ impl QueryRequestBuilder {
         self.query = Some(query.into());
         self
     }
+
+    pub fn relationships(mut self, relationships: impl Into<Vec<TableRelationships>>) -> Self {
+        self.relationships = Some(relationships.into());
+        self
+    }
 }
 
 impl From<QueryRequestBuilder> for QueryRequest {

diff --git a/crates/mongodb-agent-common/src/query/column_ref.rs b/crates/mongodb-agent-common/src/query/column_ref.rs
@@ -1,4 +1,4 @@
-use dc_api_types::comparison_column::ColumnSelector;
+use dc_api_types::ComparisonColumn;
 
 use crate::{
     interface_types::MongoAgentError,
@@ -11,18 +11,22 @@ use crate::{
 ///
 /// evaluating them as expressions.
 pub fn column_ref(
-    column_name: &ColumnSelector,
+    column: &ComparisonColumn,
     collection_name: Option<&str>,
 ) -> Result<String, MongoAgentError> {
+    if column.path.as_ref().map(|path| !path.is_empty()).unwrap_or(false) {
+        return Err(MongoAgentError::NotImplemented("comparisons against root query table columns")) 
+    }
+
     let reference = if let Some(collection) = collection_name {
         // This assumes that a related collection has been brought into scope by a $lookup stage.
         format!(
             "{}.{}",
             safe_name(collection)?,
-            safe_column_selector(column_name)?
+            safe_column_selector(&column.name)?
         )
     } else {
-        format!("{}", safe_column_selector(column_name)?)
+        format!("{}", safe_column_selector(&column.name)?)
     };
     Ok(reference)
 }
diff --git a/crates/mongodb-agent-common/src/query/make_selector.rs b/crates/mongodb-agent-common/src/query/make_selector.rs
@@ -77,7 +77,7 @@ fn make_selector_helper(
             value,
         } => {
             let mongo_op = ComparisonFunction::try_from(operator)?;
-            let col = column_ref(&column.name, in_table)?;
+            let col = column_ref(column, in_table)?;
             let comparison_value = match value {
                 ComparisonValue::AnotherColumnComparison { .. } => Err(
                     MongoAgentError::NotImplemented("comparisons between columns"),
@@ -117,7 +117,7 @@ fn make_selector_helper(
                 })
                 .collect::<Result<_, MongoAgentError>>()?;
             Ok(doc! {
-                column_ref(&column.name, in_table)?: {
+                column_ref(column, in_table)?: {
                     mongo_op: values
                 }
             })
@@ -129,11 +129,11 @@ fn make_selector_helper(
                 // value is null or is absent. Checking for type 10 returns true if the value is
                 // null, but false if it is absent.
                 Ok(doc! {
-                    column_ref(&column.name, in_table)?: { "$type": 10 }
+                    column_ref(column, in_table)?: { "$type": 10 }
                 })
             }
             UnaryComparisonOperator::CustomUnaryComparisonOperator(op) => {
-                let col = column_ref(&column.name, in_table)?;
+                let col = column_ref(column, in_table)?;
                 if op == "$exists" {
                     Ok(doc! { col: { "$exists": true } })
                 } else {

diff --git a/crates/mongodb-connector/Cargo.toml b/crates/mongodb-connector/Cargo.toml
@@ -14,6 +14,7 @@ futures = "^0.3"
 http = "^0.2"
 indexmap = { version = "2.1.0", features = ["serde"] }
 itertools = "^0.10"
+lazy_static = "^1.4.0"
 mongodb = "2.8"
 mongodb-agent-common = { path = "../mongodb-agent-common" }
 mongodb-support = { path = "../mongodb-support" }

diff --git a/crates/mongodb-connector/src/api_type_conversions/conversion_error.rs b/crates/mongodb-connector/src/api_type_conversions/conversion_error.rs
@@ -15,6 +15,21 @@ pub enum ConversionError {
     #[error("Unknown scalar type, \"{0}\"")]
     UnknownScalarType(String),
 
+    #[error("Unknown object type, \"{0}\"")]
+    UnknownObjectType(String),
+
+    #[error("Unknown field \"{field_name}\" in object type \"{object_type}\"")]
+    UnknownObjectTypeField { object_type: String, field_name: String },
+
+    #[error("Unknown collection, \"{0}\"")]
+    UnknownCollection(String),
+
+    #[error("Unknown relationship, \"{0}\"")]
+    UnknownRelationship(String),
+
+    #[error("Unknown aggregate function, \"{aggregate_function}\" in scalar type \"{scalar_type}\"")]
+    UnknownAggregateFunction { scalar_type: String, aggregate_function: String },
+
     #[error("Query referenced a function, \"{0}\", but it has not been defined")]
     UnspecifiedFunction(String),
 

diff --git a/crates/mongodb-connector/src/api_type_conversions/helpers.rs b/crates/mongodb-connector/src/api_type_conversions/helpers.rs
@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use ndc_sdk::models::{self as v3, ComparisonOperatorDefinition, ScalarType};
+use ndc_sdk::models::{self as v3};
 
 use super::ConversionError;
 
@@ -12,18 +12,3 @@ pub fn lookup_relationship<'a>(
         .get(relationship)
         .ok_or_else(|| ConversionError::UnspecifiedRelation(relationship.to_owned()))
 }
-
-pub fn lookup_operator_definition(
-    scalar_types: &BTreeMap<String, ScalarType>,
-    type_name: &str,
-    operator: &str,
-) -> Result<ComparisonOperatorDefinition, ConversionError> {
-    let scalar_type = scalar_types
-        .get(type_name)
-        .ok_or_else(|| ConversionError::UnknownScalarType(type_name.to_owned()))?;
-    let operator = scalar_type
-        .comparison_operators
-        .get(operator)
-        .ok_or_else(|| ConversionError::UnknownComparisonOperator(operator.to_owned()))?;
-    Ok(operator.clone())
-}