Implement deserializer for resources to handle Array and Object

Which is necessary to support ARMv2's new "symbolic names" structure.

Many alternatives were tried, including updating the type to be an `enum`
and then either implementing the used `Vec`-like interfaces
or pattern matching on the type everywhere `resources` used.
Neither of these were great and resulted in a lot of unnecessary code churn.

The `serde_with` library was also briefly tried with the `PickAs` trait,
but the only thing that gained was eliminating the need to define the
(very easy) deserialization of `Array`,
at the cost of multiple additional libraries.

This seems to be the best way forward as it results in the least possible
potential problems and eliminates changes throughout the codebase.
What it lacks it the ability serialize to ARMv2, but that's not (yet) desired.
It also has not fixed `dependsOn` but that would need to be done regardless.

Author: andyleejordan

lib/dsc-lib/src/configure/config_doc.rs

@@ -8,7 +8,7 @@ use dsc_lib_jsonschema::transforms::{
 };
 use rust_i18n::t;
 use schemars::{JsonSchema, json_schema};
-use serde::{Deserialize, Serialize};
+use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Map, Value};
 use std::{collections::HashMap, fmt::Display};
 
@@ -174,6 +174,7 @@ pub struct Configuration {
     pub outputs: Option<HashMap<String, Output>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub parameters: Option<HashMap<String, Parameter>>,
+    #[serde(deserialize_with = "deserialize_resources")]
     pub resources: Vec<Resource>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub variables: Option<Map<String, Value>>,
@@ -184,6 +185,44 @@ pub struct Configuration {
     pub extensions: Option<Map<String, Value>>,
 }
 
+/// Simplest implementation of a custom deserializer that will map a JSON object
+/// of resources (where the keys are symbolic names) as found in ARMv2 back to a
+/// vector, so the rest of this codebase can remain untouched.
+fn deserialize_resources<'de, D>(deserializer: D) -> Result<Vec<Resource>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    let value = Value::deserialize(deserializer)?;
+
+    match value {
+        Value::Array(resources) => {
+            resources.into_iter()
+                .map(|resource| serde_json::from_value::<Resource>(resource).map_err(serde::de::Error::custom))
+                .collect()
+        }
+        Value::Object(resources) => {
+            resources.into_iter()
+                .map(|(name, resource)| {
+                    let mut resource = serde_json::from_value::<Resource>(resource).map_err(serde::de::Error::custom)?;
+                    // Note that this is setting the symbolic name as the
+                    // resource's name property only if that isn't already set.
+                    // In the general use case from Bicep, it won't be, but
+                    // we're unsure of the implications in other use cases.
+                    //
+                    // TODO: We will need to update the 'dependsOn' logic to
+                    // accept both the symbolic name as mapped here in addition
+                    // to `resourceId()`, or possibly track both.
+                    if resource.name.is_empty() {
+                        resource.name = name;
+                    }
+                    Ok(resource)
+                })
+                .collect()
+        }
+        other => Err(serde::de::Error::custom(format!("Expected resources to be either an array or an object, but was {:?}", other))),
+    }
+}
+
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct Parameter {
@@ -326,6 +365,7 @@ pub struct Resource {
     #[serde(skip_serializing_if = "Option::is_none", rename = "apiVersion")]
     pub api_version: Option<String>,
     /// A friendly name for the resource instance
+    #[serde(default)]
     pub name: String, // friendly unique instance name
     #[serde(skip_serializing_if = "Option::is_none")]
     pub comments: Option<String>,
@@ -486,4 +526,80 @@ mod test {
 
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_resources_as_array() {
+        let config_json = r#"{
+            "$schema": "https://aka.ms/dsc/schemas/v3/bundled/config/document.json",
+            "resources": [
+                {
+                    "type": "Microsoft.DSC.Debug/Echo",
+                    "name": "echoResource",
+                    "apiVersion": "1.0.0"
+                },
+                {
+                    "type": "Microsoft/Process",
+                    "name": "processResource",
+                    "apiVersion": "0.1.0"
+                }
+            ]
+        }"#;
+
+        let config: Configuration = serde_json::from_str(config_json).unwrap();
+
+        assert_eq!(config.resources.len(), 2);
+        assert_eq!(config.resources[0].name, "echoResource");
+        assert_eq!(config.resources[0].resource_type, "Microsoft.DSC.Debug/Echo");
+        assert_eq!(config.resources[0].api_version.as_deref(), Some("1.0.0"));
+
+        assert_eq!(config.resources[1].name, "processResource");
+        assert_eq!(config.resources[1].resource_type, "Microsoft/Process");
+        assert_eq!(config.resources[1].api_version.as_deref(), Some("0.1.0"));
+    }
+
+    #[test]
+    fn test_resources_with_symbolic_names() {
+        let config_json = r#"{
+            "$schema": "https://aka.ms/dsc/schemas/v3/bundled/config/document.json",
+            "languageVersion": "2.2-experimental",
+            "extensions": {
+                "dsc": {
+                    "name": "DesiredStateConfiguration",
+                    "version": "0.1.0"
+                }
+            },
+            "resources": {
+                "echoResource": {
+                    "extension": "dsc",
+                    "type": "Microsoft.DSC.Debug/Echo",
+                    "apiVersion": "1.0.0",
+                    "properties": {
+                        "output": "Hello World"
+                    }
+                },
+                "processResource": {
+                    "extension": "dsc",
+                    "type": "Microsoft/Process",
+                    "apiVersion": "0.1.0",
+                    "properties": {
+                        "name": "pwsh",
+                        "pid": 1234
+                    }
+                }
+            }
+        }"#;
+
+        let config: Configuration = serde_json::from_str(config_json).unwrap();
+        assert_eq!(config.resources.len(), 2);
+
+        // Find resources by name (order may vary in HashMap)
+        let echo_resource = config.resources.iter().find(|r| r.name == "echoResource").unwrap();
+        let process_resource = config.resources.iter().find(|r| r.name == "processResource").unwrap();
+
+        assert_eq!(echo_resource.resource_type, "Microsoft.DSC.Debug/Echo");
+        assert_eq!(echo_resource.api_version.as_deref(), Some("1.0.0"));
+
+        assert_eq!(process_resource.resource_type, "Microsoft/Process");
+        assert_eq!(process_resource.api_version.as_deref(), Some("0.1.0"));
+    }
 }