fixed openapi translation, regenerate

Author: l-trotta

compiler-rs/clients_schema/src/lib.rs

@@ -380,6 +380,7 @@ pub enum ServerDefault {
 pub enum Variants {
     ExternalTag(ExternalTag),
     InternalTag(InternalTag),
+    Untagged(Untagged),
     Container(Container),
 }
 
@@ -404,6 +405,13 @@ pub struct InternalTag {
     pub default_tag: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(rename_all = "camelCase")]
+pub struct Untagged {
+    #[serde(default)]
+    pub non_exhaustive: bool,
+}
+
 #[derive(Debug, Clone, Serialize, Deserialize)]
 #[serde(rename_all = "camelCase")]
 pub struct Container {
@@ -799,6 +807,7 @@ impl TypeAlias {
 pub enum TypeAliasVariants {
     ExternalTag(ExternalTag),
     InternalTag(InternalTag),
+    Untagged(Untagged),
 }
 
 //------------------------------------------------------------------------------------------------------------

compiler-rs/clients_schema_to_openapi/src/main.rs

@@ -16,6 +16,7 @@
 // under the License.
 
 use std::path::{Path, PathBuf};
+use anyhow::bail;
 
 use clap::{Parser, ValueEnum};
 use clients_schema::{Availabilities, Visibility};
@@ -71,7 +72,10 @@ impl Cli {
             std::fs::read_to_string(self.schema)?
         };
 
-        let mut model: clients_schema::IndexedModel = serde_json::from_str(&json)?;
+        let mut model: clients_schema::IndexedModel = match serde_json::from_str(&json) {
+            Ok(indexed_model) => indexed_model,
+            Err(e) => bail!("cannot parse schema json: {}", e)
+        };
 
         if let Some(flavor) = self.flavor {
             if flavor != SchemaFlavor::All {

compiler-rs/clients_schema_to_openapi/src/schemas.rs

@@ -395,6 +395,8 @@ impl<'a> TypesAndComponents<'a> {
                     extensions: Default::default(),
                 });
             }
+            Some(TypeAliasVariants::Untagged(_tag)) => {
+            }
         };
 
         Ok(schema)

compiler-rs/compiler-wasm-lib/pkg/compiler_wasm_lib_bg.wasm

@@ -323,7 +323,7 @@ fn generate_schema_kind_one_of(
     let mut variants: Option<TypeAliasVariants> = None;
 
     // TODO: do we want to allow untagged unions (those that are disambiguated by inspecting property names)?
-
+    
     if let Some(discriminator) = discriminator {
         variants = Some(TypeAliasVariants::InternalTag(InternalTag {
             default_tag: None,