Update ndc-models and ndc-sdk to v0.1.4

Cargo.toml

@@ -18,8 +18,8 @@ resolver = "2"
 # The tag or rev of ndc-models must match the locked tag or rev of the
 # ndc-models dependency of ndc-sdk
 [workspace.dependencies]
-ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git" }
-ndc-models = { git = "http://github.com/hasura/ndc-spec.git", tag = "v0.1.2" }
+ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", tag = "v0.1.4" }
+ndc-models = { git = "http://github.com/hasura/ndc-spec.git", tag = "v0.1.4" }
 
 indexmap = { version = "2", features = ["serde"] } # should match the version that ndc-models uses
 itertools = "^0.12.1"

crates/cli/src/introspection/mod.rs

@@ -4,4 +4,3 @@ pub mod validation_schema;
 
 pub use sampling::{sample_schema_from_db, type_from_bson};
 pub use validation_schema::get_metadata_from_validation_schema;
-

crates/cli/src/introspection/sampling.rs

@@ -31,8 +31,13 @@ pub async fn sample_schema_from_db(
     while let Some(collection_spec) = collections_cursor.try_next().await? {
         let collection_name = collection_spec.name;
         if !existing_schemas.contains(&collection_name) || config_file_changed {
-            let collection_schema =
-                sample_schema_from_collection(&collection_name, sample_size, all_schema_nullalble, state).await?;
+            let collection_schema = sample_schema_from_collection(
+                &collection_name,
+                sample_size,
+                all_schema_nullalble,
+                state,
+            )
+            .await?;
             schemas.insert(collection_name, collection_schema);
         }
     }
@@ -74,7 +79,11 @@ async fn sample_schema_from_collection(
     })
 }
 
-fn make_object_type(object_type_name: &str, document: &Document, all_schema_nullalble: bool) -> Vec<ObjectType> {
+fn make_object_type(
+    object_type_name: &str,
+    document: &Document,
+    all_schema_nullalble: bool,
+) -> Vec<ObjectType> {
     let (mut object_type_defs, object_fields) = {
         let type_prefix = format!("{object_type_name}_");
         let (object_type_defs, object_fields): (Vec<Vec<ObjectType>>, Vec<ObjectField>) = document
@@ -105,7 +114,8 @@ fn make_object_field(
     all_schema_nullalble: bool,
 ) -> (Vec<ObjectType>, ObjectField) {
     let object_type_name = format!("{type_prefix}{field_name}");
-    let (collected_otds, field_type) = make_field_type(&object_type_name, field_value, all_schema_nullalble);
+    let (collected_otds, field_type) =
+        make_field_type(&object_type_name, field_value, all_schema_nullalble);
     let object_field_value = WithName::named(
         field_name.to_owned(),
         schema::ObjectField {
@@ -132,7 +142,11 @@ pub fn type_from_bson(
     (WithName::into_map(object_types), t)
 }
 
-fn make_field_type(object_type_name: &str, field_value: &Bson, all_schema_nullalble: bool) -> (Vec<ObjectType>, Type) {
+fn make_field_type(
+    object_type_name: &str,
+    field_value: &Bson,
+    all_schema_nullalble: bool,
+) -> (Vec<ObjectType>, Type) {
     fn scalar(t: BsonScalarType) -> (Vec<ObjectType>, Type) {
         (vec![], Type::Scalar(t))
     }
@@ -144,7 +158,8 @@ fn make_field_type(object_type_name: &str, field_value: &Bson, all_schema_nullal
             let mut collected_otds = vec![];
             let mut result_type = Type::Scalar(Undefined);
             for elem in arr {
-                let (elem_collected_otds, elem_type) = make_field_type(object_type_name, elem, all_schema_nullalble);
+                let (elem_collected_otds, elem_type) =
+                    make_field_type(object_type_name, elem, all_schema_nullalble);
                 collected_otds = if collected_otds.is_empty() {
                     elem_collected_otds
                 } else {
@@ -195,7 +210,8 @@ mod tests {
     fn simple_doc() -> Result<(), anyhow::Error> {
         let object_name = "foo";
         let doc = doc! {"my_int": 1, "my_string": "two"};
-        let result = WithName::into_map::<BTreeMap<_, _>>(make_object_type(object_name, &doc, false));
+        let result =
+            WithName::into_map::<BTreeMap<_, _>>(make_object_type(object_name, &doc, false));
 
         let expected = BTreeMap::from([(
             object_name.to_owned(),
@@ -229,7 +245,8 @@ mod tests {
     fn array_of_objects() -> Result<(), anyhow::Error> {
         let object_name = "foo";
         let doc = doc! {"my_array": [{"foo": 42, "bar": ""}, {"bar": "wut", "baz": 3.77}]};
-        let result = WithName::into_map::<BTreeMap<_, _>>(make_object_type(object_name, &doc, false));
+        let result =
+            WithName::into_map::<BTreeMap<_, _>>(make_object_type(object_name, &doc, false));
 
         let expected = BTreeMap::from([
             (
@@ -289,7 +306,8 @@ mod tests {
     fn non_unifiable_array_of_objects() -> Result<(), anyhow::Error> {
         let object_name = "foo";
         let doc = doc! {"my_array": [{"foo": 42, "bar": ""}, {"bar": 17, "baz": 3.77}]};
-        let result = WithName::into_map::<BTreeMap<_, _>>(make_object_type(object_name, &doc, false));
+        let result =
+            WithName::into_map::<BTreeMap<_, _>>(make_object_type(object_name, &doc, false));
 
         let expected = BTreeMap::from([
             (

crates/cli/src/lib.rs

@@ -44,19 +44,28 @@ pub async fn run(command: Command, context: &Context) -> anyhow::Result<()> {
 
 /// Update the configuration in the current directory by introspecting the database.
 async fn update(context: &Context, args: &UpdateArgs) -> anyhow::Result<()> {
-    let configuration_options = configuration::parse_configuration_options_file(&context.path).await;
+    let configuration_options =
+        configuration::parse_configuration_options_file(&context.path).await;
     // Prefer arguments passed to cli, and fallback to the configuration file
     let sample_size = match args.sample_size {
         Some(size) => size,
-        None => configuration_options.introspection_options.sample_size
+        None => configuration_options.introspection_options.sample_size,
     };
     let no_validator_schema = match args.no_validator_schema {
         Some(validator) => validator,
-        None => configuration_options.introspection_options.no_validator_schema
+        None => {
+            configuration_options
+                .introspection_options
+                .no_validator_schema
+        }
     };
     let all_schema_nullable = match args.all_schema_nullable {
         Some(validator) => validator,
-        None => configuration_options.introspection_options.all_schema_nullable
+        None => {
+            configuration_options
+                .introspection_options
+                .all_schema_nullable
+        }
     };
     let config_file_changed = configuration::get_config_file_changed(&context.path).await?;
 

crates/configuration/src/schema/mod.rs

@@ -149,6 +149,7 @@ impl From<ObjectField> for ndc_models::ObjectField {
         ndc_models::ObjectField {
             description: field.description,
             r#type: field.r#type.into(),
+            arguments: BTreeMap::new(),
         }
     }
 }

crates/mongodb-agent-common/src/mongodb/mod.rs

@@ -10,12 +10,8 @@ mod stage;
 pub mod test_helpers;
 
 pub use self::{
-    accumulator::Accumulator,
-    collection::CollectionTrait,
-    database::DatabaseTrait,
-    pipeline::Pipeline,
-    selection::Selection,
-    stage::Stage,
+    accumulator::Accumulator, collection::CollectionTrait, database::DatabaseTrait,
+    pipeline::Pipeline, selection::Selection, stage::Stage,
 };
 
 // MockCollectionTrait is generated by automock when the test flag is active.

crates/mongodb-connector/src/capabilities.rs

@@ -1,15 +1,21 @@
 use ndc_sdk::models::{
-    Capabilities, CapabilitiesResponse, LeafCapability, QueryCapabilities, RelationshipCapabilities,
+    Capabilities, CapabilitiesResponse, LeafCapability, NestedFieldCapabilities, QueryCapabilities,
+    RelationshipCapabilities,
 };
 
 pub fn mongo_capabilities_response() -> CapabilitiesResponse {
     ndc_sdk::models::CapabilitiesResponse {
-        version: "0.1.2".to_owned(),
+        version: "0.1.4".to_owned(),
         capabilities: Capabilities {
             query: QueryCapabilities {
                 aggregates: Some(LeafCapability {}),
                 variables: Some(LeafCapability {}),
                 explain: Some(LeafCapability {}),
+                nested_fields: NestedFieldCapabilities {
+                    filter_by: Some(LeafCapability {}),
+                    order_by: Some(LeafCapability {}),
+                    aggregates: None,
+                },
             },
             mutation: ndc_sdk::models::MutationCapabilities {
                 transactional: None,

crates/mongodb-connector/src/mutation.rs

@@ -145,7 +145,11 @@ fn rewrite_doc(
         .iter()
         .map(|(name, field)| {
             let field_value = match field {
-                ndc::Field::Column { column, fields } => {
+                ndc::Field::Column {
+                    column,
+                    fields,
+                    arguments: _,
+                } => {
                     let orig_value = doc.remove(column).ok_or_else(|| {
                         MutationError::UnprocessableContent(format!(
                             "missing expected field from response: {name}"

crates/mongodb-support/src/align.rs

@@ -1,7 +1,13 @@
 use indexmap::IndexMap;
 use std::hash::Hash;
 
-pub fn align<K, T, U, V, FT, FU, FTU>(ts: IndexMap<K, T>, mut us: IndexMap<K, U>, ft: FT, fu: FU, ftu: FTU) -> IndexMap<K, V>
+pub fn align<K, T, U, V, FT, FU, FTU>(
+    ts: IndexMap<K, T>,
+    mut us: IndexMap<K, U>,
+    ft: FT,
+    fu: FU,
+    ftu: FTU,
+) -> IndexMap<K, V>
 where
     K: Hash + Eq,
     FT: Fn(T) -> V,

crates/ndc-query-plan/src/plan_for_query_request/mod.rs

@@ -137,10 +137,16 @@ fn plan_for_aggregate<T: QueryContext>(
     aggregate: ndc::Aggregate,
 ) -> Result<plan::Aggregate<T>> {
     match aggregate {
-        ndc::Aggregate::ColumnCount { column, distinct } => {
-            Ok(plan::Aggregate::ColumnCount { column, distinct })
-        }
-        ndc::Aggregate::SingleColumn { column, function } => {
+        ndc::Aggregate::ColumnCount {
+            column,
+            distinct,
+            field_path: _,
+        } => Ok(plan::Aggregate::ColumnCount { column, distinct }),
+        ndc::Aggregate::SingleColumn {
+            column,
+            function,
+            field_path: _,
+        } => {
             let object_type_field_type =
                 find_object_field(collection_object_type, column.as_ref())?;
             // let column_scalar_type_name = get_scalar_type_name(&object_type_field.r#type)?;
@@ -211,9 +217,13 @@ fn plan_for_order_by_element<T: QueryContext>(
     element: ndc::OrderByElement,
 ) -> Result<plan::OrderByElement<T>> {
     let target = match element.target {
-        ndc::OrderByTarget::Column { name, path } => plan::OrderByTarget::Column {
+        ndc::OrderByTarget::Column {
+            name,
+            field_path,
+            path,
+        } => plan::OrderByTarget::Column {
             name: name.clone(),
-            field_path: Default::default(), // TODO: propagate this after ndc-spec update
+            field_path,
             path: plan_for_relationship_path(
                 plan_state,
                 root_collection_object_type,
@@ -227,6 +237,7 @@ fn plan_for_order_by_element<T: QueryContext>(
             column,
             function,
             path,
+            field_path: _,
         } => {
             let (plan_path, target_object_type) = plan_for_relationship_path(
                 plan_state,
@@ -495,7 +506,11 @@ fn plan_for_comparison_target<T: QueryContext>(
     target: ndc::ComparisonTarget,
 ) -> Result<plan::ComparisonTarget<T>> {
     match target {
-        ndc::ComparisonTarget::Column { name, path } => {
+        ndc::ComparisonTarget::Column {
+            name,
+            field_path,
+            path,
+        } => {
             let requested_columns = vec![name.clone()];
             let (path, target_object_type) = plan_for_relationship_path(
                 plan_state,
@@ -507,16 +522,16 @@ fn plan_for_comparison_target<T: QueryContext>(
             let column_type = find_object_field(&target_object_type, &name)?.clone();
             Ok(plan::ComparisonTarget::Column {
                 name,
-                field_path: Default::default(), // TODO: propagate this after ndc-spec update
+                field_path,
                 path,
                 column_type,
             })
         }
-        ndc::ComparisonTarget::RootCollectionColumn { name } => {
+        ndc::ComparisonTarget::RootCollectionColumn { name, field_path } => {
             let column_type = find_object_field(root_collection_object_type, &name)?.clone();
             Ok(plan::ComparisonTarget::ColumnInScope {
                 name,
-                field_path: Default::default(), // TODO: propagate this after ndc-spec update
+                field_path,
                 column_type,
                 scope: plan_state.scope.clone(),
             })

crates/ndc-query-plan/src/plan_for_query_request/tests.rs

@@ -55,6 +55,7 @@ fn translates_query_request_relationships() -> Result<(), anyhow::Error> {
                     order_direction: OrderDirection::Asc,
                     target: OrderByTarget::Column {
                         name: "advisor_name".to_owned(),
+                        field_path: None,
                         path: vec![
                             path_element("school_classes")
                                 .predicate(binop(
@@ -577,12 +578,14 @@ fn translates_relationships_in_fields_predicates_and_orderings() -> Result<(), a
                             column: "year".into(),
                             function: "Average".into(),
                             path: vec![path_element("author_articles").into()],
+                            field_path: None,
                         },
                     },
                     ndc::OrderByElement {
                         order_direction: OrderDirection::Desc,
                         target: OrderByTarget::Column {
                             name: "id".into(),
+                            field_path: None,
                             path: vec![],
                         },
                     },