update ndc-spec version

pranshi06 · pranshi06 · commit 3c9b2f6a5c87 · 2024-09-17T18:08:45.000+05:30
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -33,9 +33,9 @@ similar_names = "allow"
 too_many_lines = "allow"
 
 [workspace.dependencies]
-ndc-models = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.5" }
-ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", tag = "v0.2.1" }
-ndc-test = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.5" }
+ndc-models = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.6" }
+ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", tag = "v0.4.0" }
+ndc-test = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.6" }
 
 anyhow = "1"
 async-trait = "0.1"
diff --git a/crates/connectors/ndc-bigquery/src/capabilities.rs b/crates/connectors/ndc-bigquery/src/capabilities.rs
@@ -12,6 +12,9 @@ pub fn get_capabilities() -> models::Capabilities {
             aggregates: Some(models::LeafCapability {}),
             variables: Some(models::LeafCapability {}),
             explain: Some(models::LeafCapability {}),
+            exists: models::ExistsCapabilities {
+                nested_collections: Some(models::LeafCapability {}),
+            },
             nested_fields: models::NestedFieldCapabilities {
                 filter_by: Some(models::LeafCapability {}),
                 order_by: Some(models::LeafCapability {}),
diff --git a/crates/connectors/ndc-bigquery/src/connector.rs b/crates/connectors/ndc-bigquery/src/connector.rs
@@ -9,7 +9,7 @@ use async_trait::async_trait;
 use tracing::{info_span, Instrument};
 
 use ndc_sdk::connector;
-use ndc_sdk::connector::{Connector, ConnectorSetup};
+use ndc_sdk::connector::{Connector, ConnectorSetup, Result};
 use ndc_sdk::json_response::JsonResponse;
 use ndc_sdk::models;
 
@@ -45,33 +45,10 @@ impl Connector for BigQuery {
     fn fetch_metrics(
         _configuration: &Arc<ndc_bigquery_configuration::Configuration>,
         _state: &Self::State,
-    ) -> Result<(), connector::FetchMetricsError> {
+    ) -> Result<()> {
         Ok(())
     }
 
-    /// Check the health of the connector.
-    ///
-    /// For example, this function should check that the connector
-    /// is able to reach its data source over the network.
-    async fn health_check(
-        _configuration: &Self::Configuration,
-        state: &Self::State,
-    ) -> Result<(), connector::HealthError> {
-        health::health_check(&state.bigquery_client)
-            .await
-            .map_err(|err| {
-                tracing::error!(
-                    meta.signal_type = "log",
-                    event.domain = "ndc",
-                    event.name = "Health check error",
-                    name = "Health check error",
-                    body = %err,
-                    error = true,
-                );
-                err
-            })
-    }
-
     /// Get the connector's capabilities.
     ///
     /// This function implements the [capabilities endpoint](https://hasura.github.io/ndc-spec/specification/capabilities.html)
@@ -86,7 +63,7 @@ impl Connector for BigQuery {
     /// from the NDC specification.
     async fn get_schema(
         configuration: &Self::Configuration,
-    ) -> Result<JsonResponse<models::SchemaResponse>, connector::SchemaError> {
+    ) -> Result<JsonResponse<models::SchemaResponse>> {
         schema::get_schema(configuration)
             .await
             .map_err(|err| {
@@ -112,7 +89,7 @@ impl Connector for BigQuery {
         configuration: &Self::Configuration,
         state: &Self::State,
         request: models::QueryRequest,
-    ) -> Result<JsonResponse<models::ExplainResponse>, connector::ExplainError> {
+    ) -> Result<JsonResponse<models::ExplainResponse>> {
         todo!("query explain is currently not implemented")
         // query::explain(configuration, state, request)
         //     .await
@@ -138,7 +115,7 @@ impl Connector for BigQuery {
         configuration: &Self::Configuration,
         state: &Self::State,
         request: models::MutationRequest,
-    ) -> Result<JsonResponse<models::ExplainResponse>, connector::ExplainError> {
+    ) -> Result<JsonResponse<models::ExplainResponse>> {
         todo!("mutation explain is currently not implemented")
         // mutation::explain(configuration, state, request)
         //     .await
@@ -164,7 +141,7 @@ impl Connector for BigQuery {
         configuration: &Self::Configuration,
         state: &Self::State,
         request: models::MutationRequest,
-    ) -> Result<JsonResponse<models::MutationResponse>, connector::MutationError> {
+    ) -> Result<JsonResponse<models::MutationResponse>> {
         todo!("mutation is currently not implemented")
         // mutation::mutation(configuration, state, request)
         //     .await
@@ -189,7 +166,7 @@ impl Connector for BigQuery {
         configuration: &Self::Configuration,
         state: &Self::State,
         query_request: models::QueryRequest,
-    ) -> Result<JsonResponse<models::QueryResponse>, connector::QueryError> {
+    ) -> Result<JsonResponse<models::QueryResponse>>  {
         query::query(configuration, state, query_request)
             .await
             .map_err(|err| {
@@ -225,7 +202,7 @@ impl<Env: Environment + Send + Sync> ConnectorSetup for BigQuerySetup<Env> {
     async fn parse_configuration(
         &self,
         configuration_dir: impl AsRef<Path> + Send,
-    ) -> Result<<Self::Connector as Connector>::Configuration, connector::ParseError> {
+    ) -> Result<<Self::Connector as Connector>::Configuration> {
         // Note that we don't log validation errors, because they are part of the normal business
         // operation of configuration validation, i.e. they don't represent an error condition that
         // signifies that anything has gone wrong with the ndc process or infrastructure.
@@ -243,7 +220,8 @@ impl<Env: Environment + Send + Sync> ConnectorSetup for BigQuerySetup<Env> {
                     line,
                     column,
                     message,
-                }),
+                })
+                .into(),
                 configuration::error::ParseConfigurationError::EmptyConnectionUri { file_path } => {
                     connector::ParseError::ValidateError(connector::InvalidNodes(vec![
                         connector::InvalidNode {
@@ -252,16 +230,17 @@ impl<Env: Environment + Send + Sync> ConnectorSetup for BigQuerySetup<Env> {
                             message: "database connection URI must be specified".to_string(),
                         },
                     ]))
+                    .into()
                 }
                 configuration::error::ParseConfigurationError::IoError(inner) => {
-                    connector::ParseError::IoError(inner)
+                    connector::ParseError::IoError(inner).into()
                 }
                 configuration::error::ParseConfigurationError::IoErrorButStringified(inner) => {
-                    connector::ParseError::Other(inner.into())
+                    inner.into()
                 }
                 configuration::error::ParseConfigurationError::DidNotFindExpectedVersionTag(_)
                 | configuration::error::ParseConfigurationError::UnableToParseAnyVersions(_) => {
-                    connector::ParseError::Other(Box::new(error))
+                    connector::ErrorResponse::from_error(error)
                 }
             })?;
 
@@ -296,7 +275,7 @@ impl<Env: Environment + Send + Sync> ConnectorSetup for BigQuerySetup<Env> {
         &self,
         _configuration: &<Self::Connector as Connector>::Configuration,
         metrics: &mut prometheus::Registry,
-    ) -> Result<<Self::Connector as Connector>::State, connector::InitializationError> {
+    ) -> Result<<Self::Connector as Connector>::State> {
         state::create_state(
             // &configuration.connection_uri,
             // &configuration.pool_settings,
@@ -306,7 +285,7 @@ impl<Env: Environment + Send + Sync> ConnectorSetup for BigQuerySetup<Env> {
         .instrument(info_span!("Initialise state"))
         .await
         .map(Arc::new)
-        .map_err(|err| connector::InitializationError::Other(err.into()))
+        .map_err(|err| connector::ErrorResponse::from_error(err))
         .map_err(|err| {
             tracing::error!(
                 meta.signal_type = "log",
diff --git a/crates/connectors/ndc-bigquery/src/error/convert.rs b/crates/connectors/ndc-bigquery/src/error/convert.rs
@@ -1,115 +1,40 @@
 //! Functions to convert between internal error types and the error types exposed by ndc-sdk.
 
-use ndc_sdk::connector;
+use ndc_sdk::connector::{self, ErrorResponse};
 
-/// Convert an error from [query_engine_execution] to [connector::QueryError].
-pub fn execution_error_to_query_error(
-    error: query_engine_execution::error::Error,
-) -> connector::QueryError {
+/// Convert an error from [query_engine_execution] to [ErrorResponse].
+pub fn execution_error_to_response(error: query_engine_execution::error::Error) -> ErrorResponse {
     use query_engine_execution::error::*;
     match error {
         Error::Query(query_error) => match &query_error {
             QueryError::VariableNotFound(_) => {
-                connector::QueryError::new_invalid_request(&query_error.to_string())
+                connector::QueryError::new_invalid_request(&query_error.to_string()).into()
             }
             QueryError::NotSupported(_) => {
-                connector::QueryError::new_unsupported_operation(&query_error.to_string())
-            }
-            QueryError::DBError(_) | QueryError::DBConstraintError(_) => {
-                connector::QueryError::new_unprocessable_content(&query_error.to_string())
-            }
-            QueryError::MutationConstraintFailed => connector::QueryError::new("Internal error")
-                .with_details(serde_json::Value::String(query_error.to_string())),
-        },
-        Error::DB(_) => connector::QueryError::new("Internal error")
-            .with_details(serde_json::Value::String(error.to_string())),
-    }
-}
-
-/// Convert an error from [query_engine_execution] to [connector::MutationError].
-pub fn execution_error_to_mutation_error(
-    error: query_engine_execution::error::Error,
-) -> connector::MutationError {
-    use query_engine_execution::error::*;
-    match error {
-        Error::Query(query_error) => match &query_error {
-            QueryError::VariableNotFound(_) => {
-                connector::MutationError::new_invalid_request(&query_error.to_string())
-            }
-            QueryError::NotSupported(_) => {
-                connector::MutationError::new_unsupported_operation(&query_error.to_string())
+                connector::QueryError::new_unsupported_operation(&query_error.to_string()).into()
             }
             QueryError::DBError(_) => {
-                connector::MutationError::new_unprocessable_content(&query_error.to_string())
+                connector::QueryError::new_unprocessable_content(&query_error.to_string()).into()
             }
             QueryError::DBConstraintError(_) | QueryError::MutationConstraintFailed => {
-                connector::MutationError::new_constraint_not_met(&query_error.to_string())
+                connector::MutationError::new_constraint_not_met(&query_error.to_string()).into()
             }
         },
-        Error::DB(_) => connector::MutationError::new("Internal error")
-            .with_details(serde_json::Value::String(error.to_string())),
-    }
-}
-
-/// Convert an error from [query_engine_execution] to [connector::ExplainError].
-pub fn execution_error_to_explain_error(
-    error: query_engine_execution::error::Error,
-) -> connector::ExplainError {
-    use query_engine_execution::error::*;
-    match error {
-        Error::Query(query_error) => match &query_error {
-            QueryError::VariableNotFound(_) => {
-                connector::ExplainError::new_invalid_request(&query_error.to_string())
-            }
-            QueryError::NotSupported(_) => {
-                connector::ExplainError::new_unsupported_operation(&query_error.to_string())
-            }
-            QueryError::DBError(_) | QueryError::DBConstraintError(_) => {
-                connector::ExplainError::new_unprocessable_content(&query_error.to_string())
-            }
-            QueryError::MutationConstraintFailed => connector::ExplainError::new("Internal error")
-                .with_details(serde_json::Value::String(query_error.to_string())),
-        },
-        Error::DB(_) => connector::ExplainError::new("Internal error")
-            .with_details(serde_json::Value::String(error.to_string())),
-    }
-}
-
-/// Convert an error from [query_engine_translation] to [connector::QueryError].
-pub fn translation_error_to_query_error(
-    error: &query_engine_translation::translation::error::Error,
-) -> connector::QueryError {
-    use query_engine_translation::translation::error::*;
-    match error {
-        Error::CapabilityNotSupported(_) | Error::NotImplementedYet(_) => {
-            connector::QueryError::new_unsupported_operation(&error.to_string())
-        }
-        _ => connector::QueryError::new_invalid_request(&error.to_string()),
-    }
-}
-
-/// Convert an error from [query_engine_translation] to [connector::MutationError].
-pub fn translation_error_to_mutation_error(
-    error: &query_engine_translation::translation::error::Error,
-) -> connector::MutationError {
-    use query_engine_translation::translation::error::*;
-    match error {
-        Error::CapabilityNotSupported(_) | Error::NotImplementedYet(_) => {
-            connector::MutationError::new_unsupported_operation(&error.to_string())
+        Error::DB(_) => {
+            ErrorResponse::new_internal_with_details(serde_json::Value::String(error.to_string()))
         }
-        _ => connector::MutationError::new_invalid_request(&error.to_string()),
     }
 }
 
-/// Convert an error from [query_engine_translation] to [connector::ExplainError].
-pub fn translation_error_to_explain_error(
+/// Convert an error from [query_engine_translation] to [connector::QueryError].
+pub fn translation_error_to_response(
     error: &query_engine_translation::translation::error::Error,
-) -> connector::ExplainError {
+) -> ErrorResponse {
     use query_engine_translation::translation::error::*;
     match error {
         Error::CapabilityNotSupported(_) | Error::NotImplementedYet(_) => {
-            connector::ExplainError::new_unsupported_operation(&error.to_string())
+            connector::QueryError::new_unsupported_operation(&error.to_string()).into()
         }
-        _ => connector::ExplainError::new_invalid_request(&error.to_string()),
+        _ => connector::QueryError::new_invalid_request(&error.to_string()).into(),
     }
 }
diff --git a/crates/connectors/ndc-bigquery/src/health.rs b/crates/connectors/ndc-bigquery/src/health.rs
@@ -1,6 +1,6 @@
 //! Health check endpoint for the connector.
 
-use ndc_sdk::connector;
+use ndc_sdk::connector::ErrorResponse;
 
 use gcp_bigquery_client::model::query_request::QueryRequest;
 
@@ -10,7 +10,7 @@ use gcp_bigquery_client::model::query_request::QueryRequest;
 /// is able to reach its data source over the network.
 pub async fn health_check(
     bigquery_client: &gcp_bigquery_client::Client,
-) -> Result<(), connector::HealthError> {
+) -> Result<(), ErrorResponse> {
     // TODO: need to parse this from service account key or allow user to provide it
     let project_id = "hasura-development";
 
diff --git a/crates/connectors/ndc-bigquery/src/query.rs b/crates/connectors/ndc-bigquery/src/query.rs
@@ -29,7 +29,7 @@ pub async fn query(
     configuration: &configuration::Configuration,
     state: &state::State,
     query_request: models::QueryRequest,
-) -> Result<JsonResponse<models::QueryResponse>, connector::QueryError> {
+) -> Result<JsonResponse<models::QueryResponse>, connector::ErrorResponse> {
     // let timer = state.query_metrics.time_query_total();
 
     // See https://docs.rs/tracing/0.1.29/tracing/span/struct.Span.html#in-asynchronous-code
@@ -42,7 +42,7 @@ pub async fn query(
         let plan = async {
             plan_query(configuration, state, query_request).map_err(|err| {
                 record::translation_error(&err, &state.metrics);
-                convert::translation_error_to_query_error(&err)
+                convert::translation_error_to_response(&err)
             })
         }
         .instrument(info_span!("Plan query"))
@@ -51,7 +51,7 @@ pub async fn query(
         let result = async {
             execute_query(state, plan).await.map_err(|err| {
                 record::execution_error(&err, &state.metrics);
-                convert::execution_error_to_query_error(err)
+                convert::execution_error_to_response(err)
             })
         }
         .instrument(info_span!("Execute query"))
diff --git a/crates/connectors/ndc-bigquery/src/schema.rs b/crates/connectors/ndc-bigquery/src/schema.rs
@@ -40,7 +40,7 @@ use ndc_bigquery_configuration::configuration;
 /// from the NDC specification.
 pub async fn get_schema(
     configuration: &configuration::Configuration,
-) -> Result<models::SchemaResponse, connector::SchemaError> {
+) -> Result<models::SchemaResponse, connector::ErrorResponse> {
     // let RawConfiguration {
     //     metadata,
     //     aggregate_functions,
diff --git a/crates/query-engine/translation/src/translation/query/filtering.rs b/crates/query-engine/translation/src/translation/query/filtering.rs
@@ -635,6 +635,7 @@ pub fn translate_exists_in_collection(
                 select: Box::new(select),
             })
         }
+        models::ExistsInCollection::NestedCollection { column_name, arguments, field_path } => todo!("Filter by nested collection is not implemented yet"),
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -635,6 +635,7 @@ pub fn translate_exists_in_collection(`
`635`	`635`	`select: Box::new(select),`
`636`	`636`	`})`
`637`	`637`	`}`
	`638`	`+ models::ExistsInCollection::NestedCollection { column_name, arguments, field_path } => todo!("Filter by nested collection is not implemented yet"),`
`638`	`639`	`}`
`639`	`640`	`}`
`640`	`641`