ndc-spec 0.1.2

Cargo.toml

@@ -47,6 +47,6 @@ unreadable_literal = "allow"
 unused_async = "allow"
 
 [workspace.dependencies]
-ndc-client = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.1" }
-ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", rev = "7b56fac3aba2bc6533d3163111377fd5fbeb3011" }
-ndc-test = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.1" }
+ndc-models = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.2" }
+ndc-sdk = { git = "https://github.com/hasura/ndc-sdk-rs.git", rev = "7409334" }
+ndc-test = { git = "https://github.com/hasura/ndc-spec.git", tag = "v0.1.2" }

changelog.md

@@ -5,12 +5,15 @@
 ### Added
 
 - Expose the type representation of base types and domain types.
-  ([#398](https://github.com/hasura/ndc-postgres/pull/397))
+  ([#398](https://github.com/hasura/ndc-postgres/pull/398))
 - Expose the type representation of enums via the ndc schema.
   ([#397](https://github.com/hasura/ndc-postgres/pull/397))
 
 ### Changed
 
+- Support ndc-spec v0.1.2 and change the type representation of types accordingly.
+  ([#408](https://github.com/hasura/ndc-postgres/pull/408))
+
 ### Fixed
 
 - Fix schema conflict result_type for native query mutations.

crates/configuration/src/version3/mod.rs

@@ -222,66 +222,59 @@ fn base_type_representations() -> database::TypeRepresentations {
             ),
             (
                 database::ScalarType("date".to_string()),
-                database::TypeRepresentation::String,
+                database::TypeRepresentation::Date,
             ),
             (
                 database::ScalarType("float4".to_string()),
-                database::TypeRepresentation::Number,
+                database::TypeRepresentation::Float32,
             ),
-            // Note that we default wide numerical types to Number/Integer because any column of such type
-            // that PostgreSQL outputs as json will still be using numbers, and there is nothing we can
-            // feasibly do about this that doesn't involve very careful book-keeping on types and extra
-            // deserialization/serialization passes over query results.
-            //
-            // Hinting any such type as String would thus only affect input. It is therefore up to users
-            // themselves to opt in to such assymetrical behavior if they can benefit from that. But
-            // nothing saves anyone from having to use a big-numbers aware json parser if they are ever
-            // going to consume the results of queries that use such types.
-            //
-            // See for instance https://neon.tech/blog/parsing-json-from-postgres-in-js.
             (
                 database::ScalarType("float8".to_string()),
-                database::TypeRepresentation::Number,
+                database::TypeRepresentation::Float64,
             ),
             (
                 database::ScalarType("int2".to_string()),
-                database::TypeRepresentation::Integer,
+                database::TypeRepresentation::Int16,
             ),
             (
                 database::ScalarType("int4".to_string()),
-                database::TypeRepresentation::Integer,
+                database::TypeRepresentation::Int32,
             ),
             (
                 database::ScalarType("int8".to_string()),
-                database::TypeRepresentation::Integer,
+                // ndc-spec defines that Int64 has the json representation of a string.
+                // This is not what we do now and is a breaking change.
+                // This will need to be changed in the future. In the meantime, we report
+                // The type representation to be json.
+                database::TypeRepresentation::Json,
             ),
             (
                 database::ScalarType("numeric".to_string()),
-                database::TypeRepresentation::Number,
+                database::TypeRepresentation::BigDecimal,
             ),
             (
                 database::ScalarType("text".to_string()),
                 database::TypeRepresentation::String,
             ),
             (
                 database::ScalarType("time".to_string()),
-                database::TypeRepresentation::String,
+                database::TypeRepresentation::Time,
             ),
             (
                 database::ScalarType("timestamp".to_string()),
-                database::TypeRepresentation::String,
+                database::TypeRepresentation::Timestamp,
             ),
             (
                 database::ScalarType("timestamptz".to_string()),
-                database::TypeRepresentation::String,
+                database::TypeRepresentation::Timestamptz,
             ),
             (
                 database::ScalarType("timetz".to_string()),
-                database::TypeRepresentation::String,
+                database::TypeRepresentation::Timetz,
             ),
             (
                 database::ScalarType("uuid".to_string()),
-                database::TypeRepresentation::String,
+                database::TypeRepresentation::UUID,
             ),
             (
                 database::ScalarType("varchar".to_string()),

crates/connectors/ndc-postgres/src/capabilities.rs

@@ -8,7 +8,7 @@ use ndc_sdk::models;
 /// from the NDC specification.
 pub fn get_capabilities() -> models::CapabilitiesResponse {
     models::CapabilitiesResponse {
-        version: "0.1.1".into(),
+        version: "0.1.2".into(),
         capabilities: models::Capabilities {
             query: models::QueryCapabilities {
                 aggregates: Some(models::LeafCapability {}),

crates/connectors/ndc-postgres/src/schema.rs

@@ -29,23 +29,11 @@ pub async fn get_schema(
         .into_iter()
         .map(|scalar_type| {
             let result = models::ScalarType {
-                representation: metadata.type_representations.0.get(&scalar_type).map(
-                    |type_representation| match type_representation {
-                        metadata::TypeRepresentation::Boolean => {
-                            models::TypeRepresentation::Boolean
-                        }
-                        metadata::TypeRepresentation::Integer => {
-                            models::TypeRepresentation::Integer
-                        }
-                        metadata::TypeRepresentation::Number => models::TypeRepresentation::Number,
-                        metadata::TypeRepresentation::String => models::TypeRepresentation::String,
-                        metadata::TypeRepresentation::Enum(variants) => {
-                            models::TypeRepresentation::Enum {
-                                one_of: variants.clone(),
-                            }
-                        }
-                    },
-                ),
+                representation: metadata
+                    .type_representations
+                    .0
+                    .get(&scalar_type)
+                    .map(map_type_representation),
                 aggregate_functions: metadata
                     .aggregate_functions
                     .0
@@ -584,7 +572,7 @@ fn make_procedure_type(
     scalar_types
         .entry("int4".to_string())
         .or_insert(models::ScalarType {
-            representation: Some(models::TypeRepresentation::Integer),
+            representation: Some(models::TypeRepresentation::Int32),
             aggregate_functions: BTreeMap::new(),
             comparison_operators: BTreeMap::new(),
         });
@@ -626,3 +614,34 @@ fn make_procedure_type(
         },
     }
 }
+
+/// Map our local type representation to ndc-spec type representation.
+fn map_type_representation(
+    type_representation: &metadata::TypeRepresentation,
+) -> models::TypeRepresentation {
+    match type_representation {
+        metadata::TypeRepresentation::Boolean => models::TypeRepresentation::Boolean,
+        metadata::TypeRepresentation::String => models::TypeRepresentation::String,
+        metadata::TypeRepresentation::Float32 => models::TypeRepresentation::Float32,
+        metadata::TypeRepresentation::Float64 => models::TypeRepresentation::Float64,
+        metadata::TypeRepresentation::Int16 => models::TypeRepresentation::Int16,
+        metadata::TypeRepresentation::Int32 => models::TypeRepresentation::Int32,
+        metadata::TypeRepresentation::Int64 => models::TypeRepresentation::Int64,
+        metadata::TypeRepresentation::BigDecimal => models::TypeRepresentation::BigDecimal,
+        metadata::TypeRepresentation::Timestamp => models::TypeRepresentation::Timestamp,
+        metadata::TypeRepresentation::Timestamptz => models::TypeRepresentation::TimestampTZ,
+        metadata::TypeRepresentation::Time => models::TypeRepresentation::String,
+        metadata::TypeRepresentation::Timetz => models::TypeRepresentation::String,
+        metadata::TypeRepresentation::Date => models::TypeRepresentation::Date,
+        metadata::TypeRepresentation::Geometry => models::TypeRepresentation::Geometry,
+        metadata::TypeRepresentation::Geography => models::TypeRepresentation::Geography,
+        metadata::TypeRepresentation::UUID => models::TypeRepresentation::UUID,
+        metadata::TypeRepresentation::Json => models::TypeRepresentation::JSON,
+        metadata::TypeRepresentation::Enum(variants) => models::TypeRepresentation::Enum {
+            one_of: variants.clone(),
+        },
+        // Stop gap until we remove these. Done so we won't break compatability.
+        metadata::TypeRepresentation::Integer => models::TypeRepresentation::JSON,
+        metadata::TypeRepresentation::Number => models::TypeRepresentation::JSON,
+    }
+}

crates/query-engine/metadata/src/metadata/database.rs

@@ -217,10 +217,40 @@ pub enum TypeRepresentation {
     Boolean,
     /// Any JSON string
     String,
+    /// float4
+    Float32,
+    /// float8
+    Float64,
+    /// int2
+    Int16,
+    /// int4
+    Int32,
+    /// int8
+    Int64,
+    /// numeric
+    BigDecimal,
+    /// timestamp
+    Timestamp,
+    /// timestamp with timezone
+    Timestamptz,
+    /// time
+    Time,
+    /// time with timezone
+    Timetz,
+    /// date
+    Date,
+    /// uuid
+    UUID,
+    /// geography
+    Geography,
+    /// geometry
+    Geometry,
     /// Any JSON number
     Number,
     /// Any JSON number, with no decimal part
     Integer,
+    /// An arbitrary json.
+    Json,
     /// One of the specified string values
     Enum(Vec<String>),
 }