config v5 with native operations rename

Cargo.toml

@@ -51,6 +51,7 @@ multimap = "0.9"
 nonempty = "0.10"
 percent-encoding = "2"
 prometheus = "0.13"
+ref-cast = "1"
 reqwest = "0.11"
 schemars = "0.8"
 serde = "1"

benchmarks/component/docker-compose.yaml

@@ -59,7 +59,7 @@ services:
       OTEL_TRACES_SAMPLER: "always_off"
     volumes:
       - type: bind
-        source: ../../static/postgres/v3-chinook-ndc-metadata
+        source: ../../static/postgres/v5-configuration
         target: /etc/connector
         read_only: true
     healthcheck:

benchmarks/component/start.sh

@@ -36,7 +36,7 @@ CONNECTION_URI="postgresql://postgres:password@${POSTGRESQL_SOCKET}" \
 OTEL_EXPORTER_OTLP_TRACES_ENDPOINT='http://localhost:4317' \
 OTEL_SERVICE_NAME='ndc-postgres' \
   cargo run -p ndc-postgres --quiet --release -- \
-    serve --configuration='../../static/postgres/v3-chinook-ndc-metadata' \
+    serve --configuration='../../static/postgres/v5-configuration' \
   >& agent.log &
 AGENT_PID=$!
 echo "$AGENT_PID" > ./agent.pid

changelog.md

@@ -4,6 +4,9 @@
 
 ### Added
 
+- Introduce configuration version "v5".
+  [#522](https://github.com/hasura/ndc-postgres/pull/522)
+
 ### Changed
 
 ### Fixed

crates/cli/src/native_operations.rs

@@ -88,6 +88,17 @@ async fn list(context: Context<impl Environment>) -> anyhow::Result<()> {
                 println!("- {}", native_operation.0);
             }
         }
+        configuration::ParsedConfiguration::Version5(ref mut configuration) => {
+            let operations = &configuration.metadata.native_operations;
+            println!("Native Queries:");
+            for native_operation in &operations.queries.0 {
+                println!("- {}", native_operation.0);
+            }
+            println!("Native Mutations:");
+            for native_operation in &operations.mutations.0 {
+                println!("- {}", native_operation.0);
+            }
+        }
     };
     Ok(())
 }
@@ -157,7 +168,70 @@ async fn create(
                     {
                         entry.insert(new_native_operation);
                     } else {
-                        anyhow::bail!("A Native Operation with the name '{}' already exists. To override, use the --override flag.", name);
+                        anyhow::bail!("A Native Operation with the name '{name}' already exists. To override, use the --override flag.");
+                    }
+                }
+            }
+        }
+        configuration::ParsedConfiguration::Version5(ref mut configuration) => {
+            let connection_string = configuration.get_connection_uri()?;
+
+            let kind = match kind {
+                configuration::version4::native_operations::Kind::Query => {
+                    configuration::version5::native_operations::Kind::Query
+                }
+                configuration::version4::native_operations::Kind::Mutation => {
+                    configuration::version5::native_operations::Kind::Mutation
+                }
+            };
+
+            let new_native_operation = configuration::version5::native_operations::create(
+                configuration,
+                &connection_string,
+                &operation_path,
+                &file_contents,
+            )
+            .await?;
+
+            // Add the new native operation to the configuration.
+            match override_entry {
+                Override::Yes => match kind {
+                    configuration::version5::native_operations::Kind::Query => {
+                        configuration
+                            .metadata
+                            .native_operations
+                            .queries
+                            .0
+                            .insert(name, new_native_operation);
+                    }
+                    configuration::version5::native_operations::Kind::Mutation => {
+                        configuration
+                            .metadata
+                            .native_operations
+                            .mutations
+                            .0
+                            .insert(name, new_native_operation);
+                    }
+                },
+                Override::No => {
+                    // Only insert if vacant.
+                    if let std::collections::btree_map::Entry::Vacant(entry) = match kind {
+                        configuration::version5::native_operations::Kind::Query => configuration
+                            .metadata
+                            .native_operations
+                            .queries
+                            .0
+                            .entry(name.clone()),
+                        configuration::version5::native_operations::Kind::Mutation => configuration
+                            .metadata
+                            .native_operations
+                            .mutations
+                            .0
+                            .entry(name.clone()),
+                    } {
+                        entry.insert(new_native_operation);
+                    } else {
+                        anyhow::bail!("A Native Operation with the name '{name}' already exists. To override, use the --override flag.");
                     }
                 }
             }
@@ -224,6 +298,43 @@ async fn delete(
                 }
             }
         }
+        configuration::ParsedConfiguration::Version5(ref mut configuration) => {
+            // Delete if exists and is of the same type, error if not.
+            match kind {
+                Kind::Mutation => {
+                    match configuration
+                        .metadata
+                        .native_operations
+                        .mutations
+                        .0
+                        .entry(name.clone())
+                    {
+                        std::collections::btree_map::Entry::Occupied(entry) => {
+                            entry.remove_entry();
+                        }
+                        std::collections::btree_map::Entry::Vacant(_) => {
+                            anyhow::bail!(error_message_not_exist);
+                        }
+                    }
+                }
+                Kind::Query => {
+                    match configuration
+                        .metadata
+                        .native_operations
+                        .queries
+                        .0
+                        .entry(name.clone())
+                    {
+                        std::collections::btree_map::Entry::Occupied(entry) => {
+                            entry.remove_entry();
+                        }
+                        std::collections::btree_map::Entry::Vacant(_) => {
+                            anyhow::bail!(error_message_not_exist);
+                        }
+                    }
+                }
+            }
+        }
     }
 
     // We write the configuration excluding the deleted Native Operation.

crates/cli/tests/snapshots/initialize_tests__initialize_version_is_unchanged.snap

@@ -2,4 +2,4 @@
 source: crates/cli/tests/initialize_tests.rs
 expression: version
 ---
-"4"
+"5"

crates/configuration/src/configuration.rs

@@ -12,6 +12,7 @@ use crate::error::{
 use crate::values::{IsolationLevel, PoolSettings};
 use crate::version3;
 use crate::version4;
+use crate::version5;
 use crate::VersionTag;
 use schemars::{gen::SchemaSettings, schema::RootSchema};
 
@@ -39,11 +40,12 @@ pub const DEFAULT_CONNECTION_URI_VARIABLE: &str = "CONNECTION_URI";
 pub enum ParsedConfiguration {
     Version3(version3::RawConfiguration),
     Version4(version4::ParsedConfiguration),
+    Version5(version5::ParsedConfiguration),
 }
 
 impl ParsedConfiguration {
     pub fn initial() -> Self {
-        ParsedConfiguration::Version4(version4::ParsedConfiguration::empty())
+        ParsedConfiguration::Version5(version5::ParsedConfiguration::empty())
     }
 }
 
@@ -78,24 +80,31 @@ pub async fn introspect(
         ParsedConfiguration::Version4(config) => Ok(ParsedConfiguration::Version4(
             version4::introspect(config, environment).await?,
         )),
+        ParsedConfiguration::Version5(config) => Ok(ParsedConfiguration::Version5(
+            version5::introspect(config, environment).await?,
+        )),
     }
 }
 
 pub async fn parse_configuration(
     configuration_dir: impl AsRef<Path> + Send,
 ) -> Result<ParsedConfiguration, ParseConfigurationError> {
     // Try parsing each supported version in turn
-    match version4::parse_configuration(configuration_dir.as_ref()).await {
-        Err(v4_err) => match version3::parse_configuration(configuration_dir.as_ref()).await {
-            Err(v3_err) => Err(ParseConfigurationError::UnableToParseAnyVersions(
-                MultiError(vec![
-                    ("Trying V3".to_string(), Box::new(v3_err)),
-                    ("Trying V4".to_string(), Box::new(v4_err)),
-                ]),
-            )),
-            Ok(config) => Ok(ParsedConfiguration::Version3(config)),
+    match version5::parse_configuration(configuration_dir.as_ref()).await {
+        Err(v5_err) => match version4::parse_configuration(configuration_dir.as_ref()).await {
+            Err(v4_err) => match version3::parse_configuration(configuration_dir.as_ref()).await {
+                Err(v3_err) => Err(ParseConfigurationError::UnableToParseAnyVersions(
+                    MultiError(vec![
+                        ("Trying V3".to_string(), Box::new(v3_err)),
+                        ("Trying V4".to_string(), Box::new(v4_err)),
+                        ("Trying V5".to_string(), Box::new(v5_err)),
+                    ]),
+                )),
+                Ok(config) => Ok(ParsedConfiguration::Version3(config)),
+            },
+            Ok(config) => Ok(ParsedConfiguration::Version4(config)),
         },
-        Ok(config) => Ok(ParsedConfiguration::Version4(config)),
+        Ok(config) => Ok(ParsedConfiguration::Version5(config)),
     }
 }
 
@@ -111,6 +120,7 @@ pub fn make_runtime_configuration(
     match parsed_config {
         ParsedConfiguration::Version3(c) => version3::make_runtime_configuration(c, environment),
         ParsedConfiguration::Version4(c) => version4::make_runtime_configuration(c, environment),
+        ParsedConfiguration::Version5(c) => version5::make_runtime_configuration(c, environment),
     }
 }
 
@@ -122,6 +132,7 @@ pub async fn write_parsed_configuration(
     match parsed_config {
         ParsedConfiguration::Version3(c) => version3::write_parsed_configuration(c, out_dir).await,
         ParsedConfiguration::Version4(c) => version4::write_parsed_configuration(c, out_dir).await,
+        ParsedConfiguration::Version5(c) => version5::write_parsed_configuration(c, out_dir).await,
     }
 }
 
@@ -132,8 +143,11 @@ pub async fn write_parsed_configuration(
 pub fn upgrade_to_latest_version(parsed_config: ParsedConfiguration) -> ParsedConfiguration {
     match parsed_config {
         ParsedConfiguration::Version3(v) => {
-            ParsedConfiguration::Version4(version4::upgrade_from_v3(v))
+            ParsedConfiguration::Version5(version5::upgrade_from_v4(version4::upgrade_from_v3(v)))
+        }
+        ParsedConfiguration::Version4(v) => {
+            ParsedConfiguration::Version5(version5::upgrade_from_v4(v))
         }
-        ParsedConfiguration::Version4(_) => parsed_config,
+        ParsedConfiguration::Version5(_) => parsed_config,
     }
 }

crates/configuration/src/lib.rs

@@ -7,6 +7,7 @@ pub mod metrics;
 
 pub mod version3;
 pub mod version4;
+pub mod version5;
 
 pub use configuration::{
     generate_latest_schema, introspect, make_runtime_configuration, parse_configuration,
@@ -21,6 +22,7 @@ pub use metrics::Metrics;
 pub enum VersionTag {
     Version3,
     Version4,
+    Version5,
 }
 
 #[cfg(test)]

crates/configuration/src/metrics.rs

@@ -9,6 +9,7 @@ use crate::VersionTag;
 pub struct Metrics {
     configuration_version_3: IntGauge,
     configuration_version_4: IntGauge,
+    configuration_version_5: IntGauge,
 }
 
 impl Metrics {
@@ -26,9 +27,16 @@ impl Metrics {
             "Get whether configuration version 4 is used",
         )?;
 
+        let configuration_version_5 = add_int_gauge_metric(
+            metrics_registry,
+            "ndc_postgres_configuration_version_5",
+            "Get whether configuration version 5 is used",
+        )?;
+
         Ok(Self {
             configuration_version_3,
             configuration_version_4,
+            configuration_version_5,
         })
     }
 
@@ -37,6 +45,7 @@ impl Metrics {
         match version {
             VersionTag::Version3 => self.configuration_version_3.set(1),
             VersionTag::Version4 => self.configuration_version_4.set(1),
+            VersionTag::Version5 => self.configuration_version_5.set(1),
         }
     }
 }