CRD generation for optional enums broke with `kube` 2.0.0

[sbernauer]

Current and expected behavior

Current behavior

Given a normal enum, as the one in the crd_schema_test:

/// Gender of a person
#[derive(Serialize, Deserialize, Debug, PartialEq, Clone, JsonSchema)]
#[serde(rename_all = "PascalCase")]
enum Gender {
    Female,
    Male,
    /// This variant has a comment!
    Other,
}

and referencing it as

// This enum is optional
optional_enum: Option<Gender>,

results in the following CRD:

"optionalEnum": {
    "anyOf": [
        {
            "description": "Gender of a person",
            "enum": [
                "Female",
                "Male",
                "Other"
            ],
            "type": "string"
        },
        {
            "enum": [null],
            "nullable": true
        }
    ]
}

This is rejected by Kubernetes because of the following errors.
Please note that they are for a different CRD, but the errors should be similar.

The CustomResourceDefinition "dummyclusters.dummy.stackable.tech" is invalid: 
* spec.validation.openAPIV3Schema.properties[spec].XXX.properties[level].anyOf[0].description: Forbidden: must be empty to be structural
* spec.validation.openAPIV3Schema.properties[spec].XXX.properties[level].anyOf[0].type: Forbidden: must be empty to be structural
* spec.validation.openAPIV3Schema.properties[spec].XXX.properties[level].anyOf[1].nullable: Forbidden: must be false to be structural
* spec.validation.openAPIV3Schema.properties[spec].XXX.properties[level].type: Required value: must not be empty for specified object fields

Expected behavior

Pre 2.0.0, kube (correctly) produced

"optionalEnum": {
    "description": "This enum is optional",
    "enum": [
        "Female",
        "Male",
        "Other"
    ],
    "type": "string",
    "nullable": true
}

Possible solution

No response

Additional context

No response

Environment

Client Version: v1.33.3
Kustomize Version: v5.6.0
Server Version: v1.33.1

This is the entire patch to reproduce the bug in the kube tests:

diff --git a/kube-derive/tests/crd_schema_test.rs b/kube-derive/tests/crd_schema_test.rs
index c00009ff..11e074d6 100644
--- a/kube-derive/tests/crd_schema_test.rs
+++ b/kube-derive/tests/crd_schema_test.rs
@@ -77,6 +77,9 @@ struct FooSpec {
 
     #[x_kube(merge_strategy = ListMerge::Set)]
     x_kubernetes_set: Vec<String>,
+
+    // This enum is optional
+    optional_enum: Option<Gender>,
 }
 
 #[derive(Clone, Debug, PartialEq, Deserialize, Serialize, JsonSchema)]
@@ -146,6 +149,7 @@ struct GenderAndDateOfBirth {
     date_of_birth: String,
 }
 
+/// Gender of a person
 #[derive(Serialize, Deserialize, Debug, PartialEq, Clone, JsonSchema)]
 #[serde(rename_all = "PascalCase")]
 enum Gender {
@@ -187,6 +191,7 @@ fn test_serialized_matches_expected() {
             my_list: vec!["".into()],
             set: HashSet::from(["foo".to_owned()]),
             x_kubernetes_set: vec![],
+            optional_enum: Some(Gender::Other),
         }))
         .unwrap(),
         serde_json::json!({
@@ -222,6 +227,7 @@ fn test_serialized_matches_expected() {
                 "myList": [""],
                 "set": ["foo"],
                 "xKubernetesSet": [],
+                "optionalEnum": "Other",
             }
         })
     )
@@ -410,6 +416,23 @@ fn test_crd_schema_matches_expected() {
                                                 },
                                                 "x-kubernetes-list-type": "set",
                                             },
+                                            "optionalEnum": {
+                                                "anyOf": [
+                                                    {
+                                                        "description": "Gender of a person",
+                                                        "enum": [
+                                                            "Female",
+                                                            "Male",
+                                                            "Other"
+                                                        ],
+                                                        "type": "string"
+                                                    },
+                                                    {
+                                                        "enum": [null],
+                                                        "nullable": true
+                                                    }
+                                                ]
+                                            }
                                         },
                                         "required": [
                                             "complexEnum",

Configuration and features

Using kubes main branch to run tests

YAML

No response

Affected crates

kube-derive

Would you like to work on fixing this bug?

maybe

[clux]

Thank you for the very detailed bug. This is indeed unfortunate.

My bet would be this is from something changed in schemars 1 that has caused this, but I don't know if there's something we can do to make it better here, or if it needs to be an upstream issue.

From a quick look in how we generate schemas and the update pr in https://github.com/kube-rs/kube/pull/1780/files , maybe there's a case for a schemars::transform or something to do with nullable. There's also an open issue on schemars with Option<Enum> GREsau/schemars#464 and GREsau/schemars#470, seems possibly more advanced though (unless you are flattening).

If you have any time to investigate it would be very much appreciated.

[sbernauer]

I was at least able to reduce the problem to be related to descriptions.

If the enum does not have variant descriptions it always works fine.
Enums with variant description worked on 1.1.0, but stopped working on 2.0.0.

As the enum variant descriptions don't show up in the CRD anyway, a simple workaround is to remove them.

Test code

#[derive(CustomResource, Debug, Serialize, Deserialize, PartialEq, Clone, KubeSchema)]
#[kube(group = "clux.dev", version = "v1", kind = "OptionalEnum")]
struct OptionalEnumSpec {
    /// Configure a log level
    log_level: Option<LogLevel>,

    /// Configure a log level
    log_level_with_comment: Option<LogLevelWithComment>,

    /// This number is optional
    optional_number: Option<u32>,
}

/// Same as [`LogLevelWithComment`], but without any descriptions
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, JsonSchema)]
enum LogLevel {
    None,
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

/// Same as [`LogLevel`], but with descriptions
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, JsonSchema)]
enum LogLevelWithComment {
    /// Don't log anything at all
    None,
    Trace,
    Debug,
    Info,
    Warn,
    Error,
}

On main

JSON schema

{
    "$defs": {
        "LogLevel": {
            "description": "Same as [`LogLevelWithComment`], but without any descriptions",
            "enum": [
                "None",
                "Trace",
                "Debug",
                "Info",
                "Warn",
                "Error"
            ],
            "type": "string"
        },
        "LogLevelWithComment": {
            "description": "Same as [`LogLevel`], but with descriptions",
            "oneOf": [
                {
                    "enum": [
                        "Trace",
                        "Debug",
                        "Info",
                        "Warn",
                        "Error"
                    ],
                    "type": "string"
                },
                {
                    "const": "None",
                    "description": "Don't log anything at all",
                    "type": "string"
                }
            ]
        }
    },
    "$schema": "https://json-schema.org/draft/2020-12/schema",
    "description": "Auto-generated derived type for OptionalEnumSpec via `CustomResource`",
    "properties": {
        "spec": {
            "properties": {
                "log_level": {
                    "anyOf": [
                        {
                            "$ref": "#/$defs/LogLevel"
                        },
                        {
                            "type": "null"
                        }
                    ],
                    "description": "Configure a log level"
                },
                "log_level_with_comment": {
                    "anyOf": [
                        {
                            "$ref": "#/$defs/LogLevelWithComment"
                        },
                        {
                            "type": "null"
                        }
                    ],
                    "description": "Configure a log level"
                },
                "optional_number": {
                    "description": "This number is optional",
                    "format": "uint32",
                    "minimum": 0,
                    "type": [
                        "integer",
                        "null"
                    ]
                }
            },
            "type": "object"
        }
    },
    "required": [
        "spec"
    ],
    "title": "OptionalEnum",
    "type": "object"
}

CRD schema

{
    "apiVersion": "apiextensions.k8s.io/v1",
    "kind": "CustomResourceDefinition",
    "metadata": {
        "name": "optionalenums.clux.dev"
    },
    "spec": {
        "group": "clux.dev",
        "names": {
            "categories": [],
            "kind": "OptionalEnum",
            "plural": "optionalenums",
            "shortNames": [],
            "singular": "optionalenum"
        },
        "scope": "Cluster",
        "versions": [
            {
                "additionalPrinterColumns": [],
                "name": "v1",
                "schema": {
                    "openAPIV3Schema": {
                        "description": "Auto-generated derived type for OptionalEnumSpec via `CustomResource`",
                        "properties": {
                            "spec": {
                                "properties": {
                                    "log_level": {
                                        "description": "Configure a log level",
                                        "enum": [
                                            "None",
                                            "Trace",
                                            "Debug",
                                            "Info",
                                            "Warn",
                                            "Error",
                                            null
                                        ],
                                        "nullable": true,
                                        "type": "string"
                                    },
                                    "log_level_with_comment": {
                                        "anyOf": [
                                            {
                                                "description": "Same as [`LogLevel`], but with descriptions",
                                                "enum": [
                                                    "Trace",
                                                    "Debug",
                                                    "Info",
                                                    "Warn",
                                                    "Error",
                                                    "None"
                                                ],
                                                "type": "string"
                                            },
                                            {
                                                "enum": [
                                                    null
                                                ],
                                                "nullable": true
                                            }
                                        ],
                                        "description": "Configure a log level"
                                    },
                                    "optional_number": {
                                        "description": "This number is optional",
                                        "format": "uint32",
                                        "minimum": 0.0,
                                        "nullable": true,
                                        "type": "integer"
                                    }
                                },
                                "type": "object"
                            }
                        },
                        "required": [
                            "spec"
                        ],
                        "title": "OptionalEnum",
                        "type": "object"
                    }
                },
                "served": true,
                "storage": true,
                "subresources": {}
            }
        ]
    }
}

kube 1.1.0

JSON schema

{
    "$schema": "http://json-schema.org/draft-07/schema#",
    "definitions": {
        "LogLevel": {
            "description": "Same as [`LogLevelWithComment`], but without any descriptions",
            "enum": [
                "None",
                "Trace",
                "Debug",
                "Info",
                "Warn",
                "Error"
            ],
            "type": "string"
        },
        "LogLevelWithComment": {
            "description": "Same as [`LogLevel`], but with descriptions",
            "oneOf": [
                {
                    "enum": [
                        "Trace",
                        "Debug",
                        "Info",
                        "Warn",
                        "Error"
                    ],
                    "type": "string"
                },
                {
                    "description": "Don't log anything at all",
                    "enum": [
                        "None"
                    ],
                    "type": "string"
                }
            ]
        }
    },
    "description": "Auto-generated derived type for OptionalEnumSpec via `CustomResource`",
    "properties": {
        "spec": {
            "properties": {
                "log_level": {
                    "anyOf": [
                        {
                            "$ref": "#/definitions/LogLevel"
                        },
                        {
                            "type": "null"
                        }
                    ],
                    "description": "Configure a log level"
                },
                "log_level_with_comment": {
                    "anyOf": [
                        {
                            "$ref": "#/definitions/LogLevelWithComment"
                        },
                        {
                            "type": "null"
                        }
                    ],
                    "description": "Configure a log level"
                },
                "optional_number": {
                    "description": "This number is optional",
                    "format": "uint32",
                    "minimum": 0.0,
                    "type": [
                        "integer",
                        "null"
                    ]
                }
            },
            "type": "object"
        }
    },
    "required": [
        "spec"
    ],
    "title": "OptionalEnum",
    "type": "object"
}

CRD schema

{
    "apiVersion": "apiextensions.k8s.io/v1",
    "kind": "CustomResourceDefinition",
    "metadata": {
        "name": "optionalenums.clux.dev"
    },
    "spec": {
        "group": "clux.dev",
        "names": {
            "categories": [],
            "kind": "OptionalEnum",
            "plural": "optionalenums",
            "shortNames": [],
            "singular": "optionalenum"
        },
        "scope": "Cluster",
        "versions": [
            {
                "additionalPrinterColumns": [],
                "name": "v1",
                "schema": {
                    "openAPIV3Schema": {
                        "description": "Auto-generated derived type for OptionalEnumSpec via `CustomResource`",
                        "properties": {
                            "spec": {
                                "properties": {
                                    "log_level": {
                                        "description": "Configure a log level",
                                        "enum": [
                                            "None",
                                            "Trace",
                                            "Debug",
                                            "Info",
                                            "Warn",
                                            "Error"
                                        ],
                                        "nullable": true,
                                        "type": "string"
                                    },
                                    "log_level_with_comment": {
                                        "description": "Configure a log level",
                                        "enum": [
                                            "Trace",
                                            "Debug",
                                            "Info",
                                            "Warn",
                                            "Error",
                                            "None"
                                        ],
                                        "nullable": true,
                                        "type": "string"
                                    },
                                    "optional_number": {
                                        "description": "This number is optional",
                                        "format": "uint32",
                                        "minimum": 0.0,
                                        "nullable": true,
                                        "type": "integer"
                                    }
                                },
                                "type": "object"
                            }
                        },
                        "required": [
                            "spec"
                        ],
                        "title": "OptionalEnum",
                        "type": "object"
                    }
                },
                "served": true,
                "storage": true,
                "subresources": {}
            }
        ]
    }
}

Full test code (passes on main)

#![allow(missing_docs)]

use assert_json_diff::assert_json_eq;
use kube::{CustomResource, CustomResourceExt, KubeSchema};
use schemars::{JsonSchema, schema_for};
use serde::{Deserialize, Serialize};

#[derive(CustomResource, Debug, Serialize, Deserialize, PartialEq, Clone, KubeSchema)]
#[kube(group = "clux.dev", version = "v1", kind = "OptionalEnum")]
struct OptionalEnumSpec {
  /// Configure a log level
  log_level: Option<LogLevel>,

  /// Configure a log level
  log_level_with_comment: Option<LogLevelWithComment>,

  /// This number is optional
  optional_number: Option<u32>,
}

/// Same as [`LogLevelWithComment`], but without any descriptions
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, JsonSchema)]
enum LogLevel {
  None,
  Trace,
  Debug,
  Info,
  Warn,
  Error,
}

/// Same as [`LogLevel`], but with descriptions
#[derive(Debug, Serialize, Deserialize, PartialEq, Clone, JsonSchema)]
enum LogLevelWithComment {
  /// Don't log anything at all
  None,
  Trace,
  Debug,
  Info,
  Warn,
  Error,
}

#[test]
fn optional_enum_json_schema() {
  assert_json_eq!(
      schema_for!(OptionalEnum),
      serde_json::json!(
          {
            "$defs": {
              "LogLevel": {
                "description": "Same as [`LogLevelWithComment`], but without any descriptions",
                "enum": [
                  "None",
                  "Trace",
                  "Debug",
                  "Info",
                  "Warn",
                  "Error"
                ],
                "type": "string"
              },
              "LogLevelWithComment": {
                "description": "Same as [`LogLevel`], but with descriptions",
                "oneOf": [
                  {
                    "enum": [
                      "Trace",
                      "Debug",
                      "Info",
                      "Warn",
                      "Error"
                    ],
                    "type": "string"
                  },
                  {
                    "const": "None",
                    "description": "Don't log anything at all",
                    "type": "string"
                  }
                ]
              }
            },
            "$schema": "https://json-schema.org/draft/2020-12/schema",
            "description": "Auto-generated derived type for OptionalEnumSpec via `CustomResource`",
            "properties": {
              "spec": {
                "properties": {
                  "log_level": {
                    "anyOf": [
                      {
                        "$ref": "#/$defs/LogLevel"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "description": "Configure a log level"
                  },
                  "log_level_with_comment": {
                    "anyOf": [
                      {
                        "$ref": "#/$defs/LogLevelWithComment"
                      },
                      {
                        "type": "null"
                      }
                    ],
                    "description": "Configure a log level"
                  },
                  "optional_number": {
                    "description": "This number is optional",
                    "format": "uint32",
                    "minimum": 0,
                    "type": [
                      "integer",
                      "null"
                    ]
                  }
                },
                "type": "object"
              }
            },
            "required": [
              "spec"
            ],
            "title": "OptionalEnum",
            "type": "object"
          }
      )
  );
}

#[test]
fn optional_enum_crd_schema() {
  assert_json_eq!(
      OptionalEnum::crd(),
      serde_json::json!(
          {
            "apiVersion": "apiextensions.k8s.io/v1",
            "kind": "CustomResourceDefinition",
            "metadata": {
              "name": "optionalenums.clux.dev"
            },
            "spec": {
              "group": "clux.dev",
              "names": {
                "categories": [],
                "kind": "OptionalEnum",
                "plural": "optionalenums",
                "shortNames": [],
                "singular": "optionalenum"
              },
              "scope": "Cluster",
              "versions": [
                {
                  "additionalPrinterColumns": [],
                  "name": "v1",
                  "schema": {
                    "openAPIV3Schema": {
                      "description": "Auto-generated derived type for OptionalEnumSpec via `CustomResource`",
                      "properties": {
                        "spec": {
                          "properties": {
                            "log_level": {
                              "description": "Configure a log level",
                              "enum": [
                                "None",
                                "Trace",
                                "Debug",
                                "Info",
                                "Warn",
                                "Error",
                                null
                              ],
                              "nullable": true,
                              "type": "string"
                            },
                            "log_level_with_comment": {
                              "anyOf": [
                                {
                                  "description": "Same as [`LogLevel`], but with descriptions",
                                  "enum": [
                                    "Trace",
                                    "Debug",
                                    "Info",
                                    "Warn",
                                    "Error",
                                    "None"
                                  ],
                                  "type": "string"
                                },
                                {
                                  "enum": [
                                    null
                                  ],
                                  "nullable": true
                                }
                              ],
                              "description": "Configure a log level"
                            },
                            "optional_number": {
                              "description": "This number is optional",
                              "format": "uint32",
                              "minimum": 0.0,
                              "nullable": true,
                              "type": "integer"
                            }
                          },
                          "type": "object"
                        }
                      },
                      "required": [
                        "spec"
                      ],
                      "title": "OptionalEnum",
                      "type": "object"
                    }
                  },
                  "served": true,
                  "storage": true,
                  "subresources": {}
                }
              ]
            }
          }
      )
  );
}