Require both pgConfig and pgBouncerConfig in PATCH/POST bodies

The behaviour matrix captured in #163 shows the live API rejects any
postgresInstanceConfig PATCH or POST body that omits either nested
object: omitting pgBouncerConfig yields `BAD_REQUEST: request
body.pgBouncerConfig: 'undefined'`, omitting pgConfig yields the
symmetric error. Sending `{}` for either is accepted (matrix body 2 →
200). The previous commit had flipped both to Option<T> with
skip_serializing_if so partial PATCHes could send only the changed
half, but that shape doesn't match the API.

Flip pg_config and pg_bouncer_config on PostgresInstanceConfig back to
required (bare T with #[serde(default)] so the default envelope still
serialises to `{ "pgConfig": {}, "pgBouncerConfig": {} }`), drop the
two corresponding OPTIONALITY_EXEMPTIONS entries, and update the
fixture/integration tests to construct the new shape. Inner pgConfig
fields stay Option<T> with skip_serializing_if — those remain
opt-in per the spec's all-optional partial-update semantics.

Response-side deserialisation is still broken (the API returns
strictly-numeric pgConfig fields wrapped in JSON strings), which is
tracked separately and blocks the integration round-trip.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: sdairs

crates/clickhouse-cloud-api/src/models.rs

@@ -11968,10 +11968,10 @@ pub struct PgConfig {
 /// `postgresInstanceConfig` from the ClickHouse Cloud API.
 #[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
 pub struct PostgresInstanceConfig {
-    #[serde(rename = "pgBouncerConfig", skip_serializing_if = "Option::is_none", default)]
-    pub pg_bouncer_config: Option<PgBouncerConfig>,
-    #[serde(rename = "pgConfig", skip_serializing_if = "Option::is_none", default)]
-    pub pg_config: Option<PgConfig>,
+    #[serde(rename = "pgBouncerConfig", default)]
+    pub pg_bouncer_config: PgBouncerConfig,
+    #[serde(rename = "pgConfig", default)]
+    pub pg_config: PgConfig,
 }
 
 /// `postgresInstanceUpdateConfigResponse` from the ClickHouse Cloud API.

crates/clickhouse-cloud-api/tests/client_test.rs

@@ -2168,10 +2168,7 @@ async fn get_postgres_config() {
         .await
         .unwrap();
     let config = resp.result.unwrap();
-    assert_eq!(
-        config.pg_config.and_then(|c| c.max_connections),
-        Some(100)
-    );
+    assert_eq!(config.pg_config.max_connections, Some(100));
 }
 
 #[tokio::test]
@@ -2192,11 +2189,11 @@ async fn replace_postgres_config() {
         .await;
 
     let body = PostgresInstanceConfig {
-        pg_config: Some(PgConfig {
+        pg_config: PgConfig {
             max_connections: Some(200),
             ..Default::default()
-        }),
-        pg_bouncer_config: None,
+        },
+        pg_bouncer_config: PgBouncerConfig::default(),
     };
     let resp = c
         .postgres_instance_config_post("org-1", "pg-1", &body)
@@ -2225,11 +2222,11 @@ async fn patch_postgres_config() {
         .await;
 
     let body = PostgresInstanceConfig {
-        pg_config: Some(PgConfig {
+        pg_config: PgConfig {
             max_connections: Some(150),
             ..Default::default()
-        }),
-        pg_bouncer_config: None,
+        },
+        pg_bouncer_config: PgBouncerConfig::default(),
     };
     let resp = c
         .postgres_instance_config_patch("org-1", "pg-1", &body)

crates/clickhouse-cloud-api/tests/integration_postgres_test.rs

@@ -236,11 +236,7 @@ async fn cloud_postgres_crud_lifecycle() -> TestResult<()> {
         // Round-trip a single pgConfig field: PATCH max_connections to a
         // new value, poll-until GET reflects it, then PATCH back.
         if let Some(baseline) = baseline {
-            let baseline_max = baseline
-                .pg_config
-                .as_ref()
-                .and_then(|c| c.max_connections)
-                .unwrap_or(100);
+            let baseline_max = baseline.pg_config.max_connections.unwrap_or(100);
             let target = baseline_max + 7;
 
             failures
@@ -254,11 +250,11 @@ async fn cloud_postgres_crud_lifecycle() -> TestResult<()> {
                         let postgres_id = postgres_id.clone();
                         async move {
                             let body = PostgresInstanceConfig {
-                                pg_config: Some(PgConfig {
+                                pg_config: PgConfig {
                                     max_connections: Some(target),
                                     ..Default::default()
-                                }),
-                                pg_bouncer_config: None,
+                                },
+                                pg_bouncer_config: PgBouncerConfig::default(),
                             };
                             client
                                 .postgres_instance_config_patch(&org_id, &postgres_id, &body)
@@ -295,8 +291,7 @@ async fn cloud_postgres_crud_lifecycle() -> TestResult<()> {
                                             .await?;
                                         let observed = resp
                                             .result
-                                            .and_then(|r| r.pg_config)
-                                            .and_then(|c| c.max_connections);
+                                            .and_then(|r| r.pg_config.max_connections);
                                         if observed == Some(target) {
                                             Ok(Some(()))
                                         } else {
@@ -322,11 +317,11 @@ async fn cloud_postgres_crud_lifecycle() -> TestResult<()> {
                         let postgres_id = postgres_id.clone();
                         async move {
                             let body = PostgresInstanceConfig {
-                                pg_config: Some(PgConfig {
+                                pg_config: PgConfig {
                                     max_connections: Some(baseline_max),
                                     ..Default::default()
-                                }),
-                                pg_bouncer_config: None,
+                                },
+                                pg_bouncer_config: PgBouncerConfig::default(),
                             };
                             client
                                 .postgres_instance_config_patch(&org_id, &postgres_id, &body)

crates/clickhouse-cloud-api/tests/models_test.rs

@@ -763,33 +763,36 @@ fn serialize_servic_private_endpointe_post_request() {
 #[test]
 fn serialize_postgres_instance_config() {
     let config = PostgresInstanceConfig {
-        pg_config: Some(PgConfig {
+        pg_config: PgConfig {
             max_connections: Some(200),
             ..Default::default()
-        }),
-        pg_bouncer_config: Some(PgBouncerConfig {}),
+        },
+        pg_bouncer_config: PgBouncerConfig::default(),
     };
     let json = serde_json::to_value(&config).unwrap();
     assert_eq!(json["pgConfig"]["max_connections"], 200);
     assert!(json.get("pgBouncerConfig").is_some());
 }
 
 #[test]
-fn serialize_postgres_instance_config_omits_none_nested() {
-    // The fix for #163: partial PATCH must omit pgBouncerConfig when None,
-    // and pgConfig must omit fields the caller didn't set.
+fn serialize_postgres_instance_config_always_includes_both_nested() {
+    // The live API rejects PATCH/POST bodies that omit either `pgConfig` or
+    // `pgBouncerConfig` with `BAD_REQUEST: ... 'undefined'`, so the envelope
+    // always serializes both — defaulting to `{}` — while inner pgConfig
+    // fields stay opt-in. See #163 for the matrix evidence.
     let config = PostgresInstanceConfig {
-        pg_config: Some(PgConfig {
+        pg_config: PgConfig {
             max_connections: Some(200),
             ..Default::default()
-        }),
-        pg_bouncer_config: None,
+        },
+        pg_bouncer_config: PgBouncerConfig::default(),
     };
     let json = serde_json::to_value(&config).unwrap();
     assert!(
-        json.get("pgBouncerConfig").is_none(),
-        "pgBouncerConfig must be omitted when None"
+        json.get("pgBouncerConfig").is_some(),
+        "pgBouncerConfig must always be present"
     );
+    assert_eq!(json["pgBouncerConfig"], serde_json::json!({}));
     assert_eq!(json["pgConfig"]["max_connections"], 200);
     let pg = json["pgConfig"].as_object().unwrap();
     assert_eq!(
@@ -799,6 +802,13 @@ fn serialize_postgres_instance_config_omits_none_nested() {
     );
 }
 
+#[test]
+fn serialize_postgres_instance_config_default_envelope() {
+    // Default envelope serializes to the minimal accepted body shape.
+    let json = serde_json::to_value(PostgresInstanceConfig::default()).unwrap();
+    assert_eq!(json, serde_json::json!({ "pgConfig": {}, "pgBouncerConfig": {} }));
+}
+
 // ===========================================================================
 // Forward compatibility: extra unknown fields ignored
 // ===========================================================================
@@ -1071,10 +1081,7 @@ fn deserialize_postgres_instance_config() {
         "pgBouncerConfig": {}
     }"#;
     let config: PostgresInstanceConfig = serde_json::from_str(json).unwrap();
-    assert_eq!(
-        config.pg_config.and_then(|c| c.max_connections),
-        Some(200)
-    );
+    assert_eq!(config.pg_config.max_connections, Some(200));
 }
 
 #[test]

crates/clickhouse-cloud-api/tests/spec_coverage_test.rs

@@ -390,10 +390,11 @@ const OPTIONALITY_EXEMPTIONS: &[(&str, &str)] = &[
     // the endpoint is partial-update: sending the default value for any
     // field yields `Validation failed for following fields: pg_config.*`.
     // Every property is effectively optional. The wrapping
-    // `postgresInstanceConfig` also lists both nested objects as required,
-    // but PATCH must accept either alone. Exempt all until the upstream
-    // spec adds proper required semantics. See #163 for the behaviour
-    // matrix evidence and the upstream report draft.
+    // `postgresInstanceConfig` is *not* exempted — the live API requires
+    // both `pgConfig` and `pgBouncerConfig` to be present in PATCH and
+    // POST bodies (omitting either yields `BAD_REQUEST: ... 'undefined'`),
+    // matching the spec's `required` listing. See #163 for the behaviour
+    // matrix evidence.
     ("PgConfig", "default_transaction_isolation"),
     ("PgConfig", "effective_cache_size"),
     ("PgConfig", "effective_io_concurrency"),
@@ -417,8 +418,6 @@ const OPTIONALITY_EXEMPTIONS: &[(&str, &str)] = &[
     ("PgConfig", "wal_keep_size"),
     ("PgConfig", "wal_sender_timeout"),
     ("PgConfig", "work_mem"),
-    ("PostgresInstanceConfig", "pgConfig"),
-    ("PostgresInstanceConfig", "pgBouncerConfig"),
 ];
 
 fn assert_field_optionality(spec: &Value) {