Rewrite deserialization

pulumi_wasm_generator_lib/Cargo.toml

@@ -18,6 +18,7 @@ syn.workspace = true
 quote.workspace = true
 proc-macro2.workspace = true
 itertools.workspace = true
+pulumi_wasm_provider_common.workspace = true
 
 [dev-dependencies]
 assert_cmd.workspace = true

pulumi_wasm_generator_lib/src/lib.rs

@@ -4,16 +4,20 @@ use std::io::{BufReader, Write};
 use std::path::Path;
 
 use crate::schema::Package;
+use crate::schema_types::PulumiSchema;
 use anyhow::{Context, Result};
+
 mod code_generation;
 mod description;
 mod model;
 mod output;
 mod schema;
+mod schema_types;
 mod utils;
 
 pub fn generate_rust_library(schema_json: &Path, result_path: &Path) -> Result<()> {
     let schema_package: schema::Package = extract_schema_from_file(schema_json)?;
+    extract_schema_2_from_file(schema_json)?;
     let package = schema::to_model(&schema_package)?;
 
     fs::create_dir_all(result_path.join("wit").join("deps"))?;
@@ -82,6 +86,7 @@ pub fn generate_rust_library(schema_json: &Path, result_path: &Path) -> Result<(
 
 pub fn generate_wasm_provider(schema_json: &Path, result_path: &Path) -> Result<()> {
     let schema_package: schema::Package = extract_schema_from_file(schema_json)?;
+    extract_schema_2_from_file(schema_json)?;
     let package = schema::to_model(&schema_package)?;
 
     fs::create_dir_all(result_path.join("wit").join("deps"))?;
@@ -149,3 +154,21 @@ fn extract_schema_from_file(schema_json: &Path) -> anyhow::Result<Package> {
         )),
     }
 }
+
+fn extract_schema_2_from_file(schema_json: &Path) -> anyhow::Result<PulumiSchema> {
+    let file = File::open(schema_json)
+        .with_context(|| format!("Error opening schema file [{:?}]", schema_json))?;
+    let reader = BufReader::new(file);
+    match schema_json.extension().and_then(|s| s.to_str()) {
+        None => Err(anyhow::anyhow!(
+            "No extensions for schema file: {}.",
+            schema_json.display()
+        )),
+        Some("yml" | "yaml") => serde_yaml::from_reader(reader).map_err(anyhow::Error::new),
+        Some("json") => serde_json::from_reader(reader).map_err(anyhow::Error::new),
+        Some(ext) => Err(anyhow::anyhow!(
+            "Unsupported schema file extension: {}.",
+            ext
+        )),
+    }
+}

pulumi_wasm_generator_lib/src/schema.rs

@@ -8,7 +8,7 @@ use convert_case::{Case, Casing};
 use serde::Deserialize;
 use std::collections::{BTreeMap, BTreeSet, HashSet};
 
-type PulumiMap<T> = BTreeMap<String, T>;
+pub(crate) type PulumiMap<T> = BTreeMap<String, T>;
 
 #[derive(Deserialize, Debug)]
 pub(crate) enum TypeEnum {
@@ -67,7 +67,7 @@ enum OneOfTypePrimitiveType {
 }
 
 #[derive(Deserialize, Debug)]
-struct Property {
+pub(crate) struct Property {
     #[serde(flatten)]
     r#type: Type,
 }
@@ -103,21 +103,21 @@ enum ObjectTypeEnum {
 }
 
 #[derive(Deserialize, Debug)]
-struct IntegerEnumValue {
+pub(crate) struct IntegerEnumValue {
     name: String,
     description: Option<String>,
     value: i64,
 }
 
 #[derive(Deserialize, Debug)]
-struct NumberEnumValue {
+pub(crate) struct NumberEnumValue {
     name: String,
     description: Option<String>,
     value: f64,
 }
 
 #[derive(Deserialize, Debug)]
-struct StringEnumValue {
+pub(crate) struct StringEnumValue {
     name: Option<String>,
     description: Option<String>,
     value: Option<String>,
@@ -150,16 +150,6 @@ pub(crate) struct Package {
     functions: PulumiMap<Function>,
 }
 
-// fn complex_type_mapper(complex_type: ComplexType) -> Result<crate::model::Type> {
-//     //TODO: Enums
-//     object_type_mapper(complex_type.object_type)
-// }
-//
-// fn object_type_mapper(object_type: ObjectType) -> Result<crate::model::Type> {
-//
-//
-// }
-
 //TODO: Fix formatting
 fn new_type_mapper(type_: &Type) -> Result<crate::model::Type> {
     (match type_ {

pulumi_wasm_generator_lib/src/schema_types.rs

@@ -0,0 +1,129 @@
+use crate::schema::IntegerEnumValue;
+use crate::schema::NumberEnumValue;
+use crate::schema::{PulumiMap, StringEnumValue};
+use pulumi_wasm_provider_common;
+use serde::Deserialize;
+use std::collections::BTreeSet;
+
+pulumi_wasm_provider_common::generate_string_const!(StringConstant, "string");
+pulumi_wasm_provider_common::generate_string_const!(IntegerConstant, "integer");
+pulumi_wasm_provider_common::generate_string_const!(NumberConstant, "number");
+pulumi_wasm_provider_common::generate_string_const!(BooleanConstant, "boolean");
+pulumi_wasm_provider_common::generate_string_const!(ArrayConstant, "array");
+pulumi_wasm_provider_common::generate_string_const!(ObjectConstant, "object");
+
+#[derive(Deserialize)]
+pub(crate) struct PulumiSchema {
+    #[serde(default)]
+    types: PulumiMap<TopLevelType>,
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum TopLevelType {
+    Object(MyTypeObject),
+    StringEnum(StringEnumType),
+    IntegerEnum(IntegerEnumType),
+    NumberEnum(NumberEnumType),
+}
+
+#[derive(Deserialize)]
+#[serde(untagged)]
+enum InnerType {
+    StringEnum(StringEnumType),
+    IntegerEnum(IntegerEnumType),
+    NumberEnum(NumberEnumType),
+    Boolean(BooleanType),
+    AnyString(AnyStringType),
+    AnyNumber(AnyNumberType),
+    AnyInteger(AnyIntegerType),
+    HashMap(HashMapType),
+    Ref(RefType),
+    OneOf(OneOfType),
+    Array(ArrayType),
+}
+
+#[derive(Deserialize)]
+struct MyTypeObject {
+    #[serde(rename = "type")]
+    type_: ObjectConstant,
+    description: Option<String>,
+    properties: PulumiMap<InnerType>,
+    #[serde(default)]
+    required: BTreeSet<String>,
+}
+
+#[derive(Deserialize)]
+struct StringEnumType {
+    #[serde(rename = "type")]
+    type_: StringConstant,
+    #[serde(rename = "enum")]
+    enum_: Vec<StringEnumValue>,
+}
+
+#[derive(Deserialize)]
+struct IntegerEnumType {
+    #[serde(rename = "type")]
+    type_: IntegerConstant,
+    #[serde(rename = "enum")]
+    enum_: Vec<IntegerEnumValue>,
+}
+
+#[derive(Deserialize)]
+struct NumberEnumType {
+    #[serde(rename = "type")]
+    type_: NumberConstant,
+    #[serde(rename = "enum")]
+    enum_: Vec<NumberEnumValue>,
+}
+
+#[derive(Deserialize)]
+struct AnyStringType {
+    #[serde(rename = "type")]
+    type_: StringConstant,
+}
+
+#[derive(Deserialize)]
+struct BooleanType {
+    #[serde(rename = "type")]
+    type_: BooleanConstant,
+}
+
+#[derive(Deserialize)]
+struct AnyIntegerType {
+    #[serde(rename = "type")]
+    type_: IntegerConstant,
+}
+
+#[derive(Deserialize)]
+struct AnyNumberType {
+    #[serde(rename = "type")]
+    type_: NumberConstant,
+}
+
+#[derive(Deserialize)]
+struct RefType {
+    #[serde(rename = "$ref")]
+    ref_: String,
+}
+
+#[derive(Deserialize)]
+struct OneOfType {
+    #[serde(rename = "oneOf")]
+    one_of: Vec<InnerType>,
+}
+
+#[derive(Deserialize)]
+struct ArrayType {
+    #[serde(rename = "type")]
+    type_: ArrayConstant,
+    items: Box<InnerType>,
+}
+
+#[derive(Deserialize)]
+struct HashMapType {
+    #[serde(rename = "type")]
+    type_: ObjectConstant,
+    #[serde(rename = "additionalProperties")]
+    additional_properties: Box<InnerType>,
+}