Merge branch 'gh-57/main/add-tryindexfromend-function' of https://github.com/Gijsreyn/operation-methods into gh-57/main/add-tryindexfromend-function

Author: Gijsreyn

docs/reference/schemas/config/functions/tryIndexFromEnd.md

@@ -200,7 +200,8 @@ appropriate log level or `null` without throwing errors.
 Use `tryIndexFromEnd()` with [`coalesce()`][02] to implement fallback logic when
 accessing configuration values from arrays that might have different lengths
 across regions. This example shows how to safely access regional endpoints with
-a default fallback.
+a default fallback. This example uses [`createArray()`][05] to build the
+regional endpoint arrays.
 
 ```yaml
 # tryIndexFromEnd.example.4.dsc.config.yaml

dsc/tests/dsc_armv2.tests.ps1

@@ -0,0 +1,57 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+Describe 'ARM Language 2.0 tests' {
+    It 'config with ARM Language 2.0 format works' {
+<#
+This JSON config built from the following Bicep code using the
+desiredStateConfiguration and moduleExtensionConfigs experimental features:
+
+extension dsc
+targetScope = 'desiredStateConfiguration'
+
+resource echoResource 'Microsoft.DSC.Debug/Echo@1.0.0' = {
+  output: 'Hello World'
+}
+#>
+        $configJson = @'
+{
+  "$schema": "https://aka.ms/dsc/schemas/v3/bundled/config/document.json",
+  "languageVersion": "2.2-experimental",
+  "contentVersion": "1.0.0.0",
+  "metadata": {
+    "_EXPERIMENTAL_WARNING": "This template uses ARM features that are experimental. Experimental features should be enabled for testing purposes only, as there are no guarantees about the quality or stability of these features. Do not enable these settings for any production usage, or your production environment may be subject to breaking.",
+    "_EXPERIMENTAL_FEATURES_ENABLED": [
+      "Enable defining extension configs for modules"
+    ],
+    "_generator": {
+      "name": "bicep",
+      "version": "0.38.33.27573",
+      "templateHash": "5233252217641859406"
+    }
+  },
+  "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"
+      }
+    }
+  }
+}
+'@
+        $out = dsc config get -i $configJson | ConvertFrom-Json -Depth 10
+        $LASTEXITCODE | Should -Be 0
+        $out.results | Should -HaveCount 1
+        $out.results[0].type | Should -Be 'Microsoft.DSC.Debug/Echo'
+        $out.results[0].result.actualState.output | Should -Be 'Hello World'
+    }
+}

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};
 
@@ -159,6 +159,11 @@ pub struct Configuration {
     #[serde(rename = "$schema")]
     #[schemars(schema_with = "Configuration::recognized_schema_uris_subschema")]
     pub schema: String,
+    /// Irrelevant Bicep metadata from using the extension
+    /// TODO: Potentially check this as a feature flag.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "languageVersion")]
+    pub language_version: Option<String>,
     #[serde(rename = "contentVersion")]
     pub content_version: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
@@ -169,9 +174,53 @@ 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>>,
+    /// Irrelevant Bicep metadata from using the extension
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub imports: Option<Map<String, Value>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    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)]
@@ -316,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>,
@@ -344,6 +394,11 @@ pub struct Resource {
     pub resources: Option<Vec<Resource>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<Metadata>,
+    /// Irrelevant Bicep metadata from using the extension
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub import: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub extension: Option<String>,
 }
 
 impl Default for Configuration {
@@ -381,13 +436,16 @@ impl Configuration {
     pub fn new() -> Self {
         Self {
             schema: Self::default_schema_id_uri(),
+            language_version: None,
             content_version: Some("1.0.0".to_string()),
             metadata: None,
             parameters: None,
             resources: Vec::new(),
             functions: None,
             variables: None,
             outputs: None,
+            imports: None,
+            extensions: None,
         }
     }
 }
@@ -413,6 +471,8 @@ impl Resource {
             location: None,
             tags: None,
             api_version: None,
+            import: None,
+            extension: None,
         }
     }
 }
@@ -466,4 +526,140 @@ mod test {
 
         assert!(result.is_ok());
     }
+
+    #[test]
+    fn test_invalid_resource_field_in_array() {
+        let config_json = r#"{
+            "resources": [
+                {
+                    "invalidField": "someValue"
+                }
+            ]
+        }"#;
+
+        let result: Result<Configuration, _> = serde_json::from_str(config_json);
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(err.starts_with("unknown field `invalidField`, expected one of `condition`, `type`,"));
+    }
+
+    #[test]
+    fn test_invalid_resource_field_in_object() {
+        let config_json = r#"{
+            "resources": {
+                "someResource": {
+                    "invalidField": "someValue"
+                }
+            }
+        }"#;
+
+        let result: Result<Configuration, _> = serde_json::from_str(config_json);
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(err.starts_with("unknown field `invalidField`, expected one of `condition`, `type`,"));
+    }
+
+    #[test]
+    fn test_invalid_resource_type_in_array() {
+        let config_json = r#"{
+            "resources": [
+                "invalidType"
+            ]
+        }"#;
+
+        let result: Result<Configuration, _> = serde_json::from_str(config_json);
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(err.contains("expected struct Resource"));
+    }
+
+    #[test]
+    fn test_invalid_resource_type_in_object() {
+        let config_json = r#"{
+            "resources": {
+                "someResource": "invalidType"
+            }
+        }"#;
+
+        let result: Result<Configuration, _> = serde_json::from_str(config_json);
+        assert!(result.is_err());
+        let err = result.unwrap_err().to_string();
+        assert!(err.contains("expected struct Resource"));
+    }
+
+    #[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"));
+    }
 }