Add output property to import extensions

SteveL-MSFT · SteveL-MSFT · commit ffceb56a94dd · 2025-11-21T13:38:26.000-08:00
diff --git a/dsc/src/subcommand.rs b/dsc/src/subcommand.rs
@@ -607,6 +607,7 @@ fn list_extensions(dsc: &mut DscManager, extension_name: Option<&String>, format
             let capability_types = [
                 (ExtensionCapability::Discover, "d"),
                 (ExtensionCapability::Secret, "s"),
+                (ExtensionCapability::Import, "i"),
             ];
             let mut capabilities = "-".repeat(capability_types.len());
 
diff --git a/extensions/bicep/bicepparams.dsc.extension.json b/extensions/bicep/bicepparams.dsc.extension.json
@@ -13,6 +13,7 @@
                 "fileArg": ""
             },
             "--stdout"
-        ]
+        ],
+        "output": "[json(json(stdout()).parametersJson)]"
     }
 }
diff --git a/lib/dsc-lib/locales/en-us.toml b/lib/dsc-lib/locales/en-us.toml
@@ -86,10 +86,8 @@ outputTypeNotMatch = "Output '%{name}' type does not match expected type '%{expe
 copyNotSupported = "Copy for output '%{name}' is currently not supported"
 
 [configure.parameters]
-importingParametersFromJson = "Importing parameters from `parameters_input` JSON"
 importingParametersFromComplexInput = "Importing parameters from complex input"
 importingParametersFromInput = "Importing parameters from simple input"
-invalidParamsJsonFormat = "Invalid parameters JSON format: %{error}"
 invalidParamsFormat = "Invalid parameters format: %{error}"
 
 [discovery.commandDiscovery]
@@ -231,6 +229,7 @@ importingFile = "Importing file '%{file}' with extension '%{extension}'"
 importNotSupported = "Import is not supported by extension '%{extension}' for file '%{file}'"
 importNoResults = "Extension '%{extension}' returned no results for import"
 secretMultipleLinesReturned = "Extension '%{extension}' returned multiple lines which is not supported for secrets"
+importProcessingOutput = "Processing output from extension '%{extension}'"
 
 [extensions.extension_manifest]
 extensionManifestSchemaTitle = "Extension manifest schema URI"
@@ -545,6 +544,10 @@ invoked = "skip function"
 invalidNumberToSkip = "Second argument must be an integer"
 invalidOriginalValue = "First argument must be an array or string"
 
+[functions.stdout]
+description = "Returns the standard output from the last executed resource.  Can only be used in output definitions."
+noStdoutAvailable = "No standard output is available from the last executed resource"
+
 [functions.string]
 description = "Converts a value to a string"
 
@@ -664,6 +667,10 @@ indexOutOfBounds = "Index is out of bounds"
 indexOnNonArray = "Index access on non-array value"
 invalidIndexType = "Invalid index type"
 propertyNameNotString = "Property name is not a string"
+accessorResult = "Accessor result: %{result}"
+evaluatingMemberAccessor = "Evaluating member accessor: %{name}"
+evaluatingIndexAccessor = "Evaluating index accessor: %{index}"
+evaluatingIndexExpression = "Evaluating index expression: %{expression}"
 
 [parser.functions]
 foundErrorNode = "Found error node parsing function"
diff --git a/lib/dsc-lib/src/configure/context.rs b/lib/dsc-lib/src/configure/context.rs
@@ -34,6 +34,7 @@ pub struct Context {
     pub restart_required: Option<Vec<RestartRequired>>,
     pub security_context: SecurityContextKind,
     pub start_datetime: DateTime<Local>,
+    pub stdout: Option<String>,
     pub system_root: PathBuf,
     pub user_functions: HashMap<String, UserFunctionDefinition>,
     pub variables: Map<String, Value>,
@@ -60,6 +61,7 @@ impl Context {
                 SecurityContext::User => SecurityContextKind::Restricted,
             },
             start_datetime: chrono::Local::now(),
+            stdout: None,
             system_root: get_default_os_system_root(),
             user_functions: HashMap::new(),
             variables: Map::new(),
diff --git a/lib/dsc-lib/src/configure/parameters.rs b/lib/dsc-lib/src/configure/parameters.rs
@@ -10,7 +10,7 @@ use std::{collections::HashMap, fmt::Display};
 use tracing::trace;
 
 #[derive(Debug, Clone, PartialEq, Deserialize, JsonSchema)]
-pub struct Input {
+pub struct SimpleInput {
     pub parameters: HashMap<String, Value>,
 }
 
@@ -24,12 +24,6 @@ pub struct InputObject {
     pub value: Value,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize)]
-pub struct ParametersJson {
-    #[serde(rename = "parametersJson")]
-    pub parameters_json: String,
-}
-
 pub const SECURE_VALUE_REDACTED: &str = "<secureValue>";
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
@@ -85,46 +79,27 @@ pub enum SecureKind {
 }
 
 pub fn import_parameters(parameters: &Value) -> Result<HashMap<String, Value>, DscError> {
-    let input = match serde_json::from_value::<ParametersJson>(parameters.clone()) {
-        Ok(input) => {
-            trace!("{}", t!("configure.parameters.importingParametersFromJson"));
-            let param_map = match serde_json::from_str::<ComplexInput>(&input.parameters_json) {
-                Ok(param_map) => param_map,
-                Err(e) => {
-                    return Err(DscError::Parser(t!("configure.parameters.invalidParamsJsonFormat", error = e).to_string()));
-                }
-            };
+    let parameters = match serde_json::from_value::<ComplexInput>(parameters.clone()) {
+        Ok(complex_input) => {
+            trace!("{}", t!("configure.parameters.importingParametersFromComplexInput"));
             let mut result: HashMap<String, Value> = HashMap::new();
-            for (name, input_object) in param_map.parameters {
+            for (name, input_object) in complex_input.parameters {
                 result.insert(name, input_object.value);
             }
             result
         },
         Err(_) => {
-            let complex_input = match serde_json::from_value::<ComplexInput>(parameters.clone()) {
-                Ok(complex_input) => {
-                    trace!("{}", t!("configure.parameters.importingParametersFromComplexInput"));
-                    let mut result: HashMap<String, Value> = HashMap::new();
-                    for (name, input_object) in complex_input.parameters {
-                        result.insert(name, input_object.value);
-                    }
-                    result
-                },
-                Err(_) => {
-                    let simple_input = match serde_json::from_value::<Input>(parameters.clone()) {
-                        Ok(simple_input) => {
-                            trace!("{}", t!("configure.parameters.importingParametersFromInput"));
-                            simple_input.parameters
-                        }
-                        Err(e) => {
-                            return Err(DscError::Parser(t!("configure.parameters.invalidParamsFormat", error = e).to_string()));
-                        }
-                    };
-                    simple_input
+            let simple_input = match serde_json::from_value::<SimpleInput>(parameters.clone()) {
+                Ok(simple_input) => {
+                    trace!("{}", t!("configure.parameters.importingParametersFromInput"));
+                    simple_input.parameters
+                }
+                Err(e) => {
+                    return Err(DscError::Parser(t!("configure.parameters.invalidParamsFormat", error = e).to_string()));
                 }
             };
-            complex_input
-        },
+            simple_input
+        }
     };
-    Ok(input)
+    Ok(parameters)
 }
diff --git a/lib/dsc-lib/src/discovery/command_discovery.rs b/lib/dsc-lib/src/discovery/command_discovery.rs
@@ -803,14 +803,14 @@ fn load_extension_manifest(path: &Path, manifest: &ExtensionManifest) -> Result<
         verify_executable(&manifest.r#type, "secret", &secret.executable, path.parent().unwrap());
         capabilities.push(dscextension::Capability::Secret);
     }
-    let import_extensions = if let Some(import) = &manifest.import {
+    let import = if let Some(import) = &manifest.import {
         verify_executable(&manifest.r#type, "import", &import.executable, path.parent().unwrap());
         capabilities.push(dscextension::Capability::Import);
         if import.file_extensions.is_empty() {
             warn!("{}", t!("discovery.commandDiscovery.importExtensionsEmpty", extension = manifest.r#type));
             None
         } else {
-            Some(import.file_extensions.clone())
+            Some(import.clone())
         }
     } else {
         None
@@ -821,7 +821,7 @@ fn load_extension_manifest(path: &Path, manifest: &ExtensionManifest) -> Result<
         description: manifest.description.clone(),
         version: manifest.version.clone(),
         capabilities,
-        import_file_extensions: import_extensions,
+        import,
         path: path.to_path_buf(),
         directory: path.parent().unwrap().to_path_buf(),
         manifest: serde_json::to_value(manifest)?,
diff --git a/lib/dsc-lib/src/extensions/dscextension.rs b/lib/dsc-lib/src/extensions/dscextension.rs
@@ -1,6 +1,7 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
+use crate::extensions::import::ImportMethod;
 use dsc_lib_jsonschema::transforms::idiomaticize_string_enum;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
@@ -18,9 +19,8 @@ pub struct DscExtension {
     pub version: String,
     /// The capabilities of the resource.
     pub capabilities: Vec<Capability>,
-    /// The extensions supported for importing.
-    #[serde(rename = "importFileExtensions")]
-    pub import_file_extensions: Option<Vec<String>>,
+    /// The import specifics.
+    pub import: Option<ImportMethod>,
     /// The file path to the resource.
     pub path: PathBuf,
     /// The description of the resource.
@@ -43,8 +43,6 @@ pub enum Capability {
     Secret,
     /// The extension imports configuration from a different format.
     Import,
-    /// The extension imports parameters from a different format.
-    ImportParameters,
 }
 
 impl Display for Capability {
@@ -53,7 +51,6 @@ impl Display for Capability {
             Capability::Discover => write!(f, "Discover"),
             Capability::Secret => write!(f, "Secret"),
             Capability::Import => write!(f, "Import"),
-            Capability::ImportParameters => write!(f, "ImportParams"),
         }
     }
 }
@@ -65,7 +62,7 @@ impl DscExtension {
             type_name: String::new(),
             version: String::new(),
             capabilities: Vec::new(),
-            import_file_extensions: None,
+            import: None,
             description: None,
             path: PathBuf::new(),
             directory: PathBuf::new(),
diff --git a/lib/dsc-lib/src/extensions/import.rs b/lib/dsc-lib/src/extensions/import.rs
@@ -2,19 +2,13 @@
 // Licensed under the MIT License.
 
 use crate::{
-    dscerror::DscError,
-    dscresources::{
-        command_resource::{
-            invoke_command,
-        },
-    },
-    extensions::{
+    configure::context::Context, dscerror::DscError, dscresources::command_resource::invoke_command, extensions::{
         dscextension::{
             Capability,
             DscExtension,
         },
         extension_manifest::ExtensionManifest,
-    },
+    }, parser::Statement
 };
 use path_absolutize::Absolutize;
 use rust_i18n::t;
@@ -32,6 +26,8 @@ pub struct ImportMethod {
     pub executable: String,
     /// The arguments to pass to the command to perform an Import.
     pub args: Option<Vec<ImportArgKind>>,
+    /// Enables modifying the resulting output from STDOUT after running the import command.
+    pub output: Option<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
@@ -62,9 +58,9 @@ impl DscExtension {
     ///
     /// This function will return an error if the import fails or if the extension does not support the import capability.
     pub fn import(&self, file: &Path) -> Result<String, DscError> {
-        if self.capabilities.contains(&Capability::Import) {
+        if let Some(import) = &self.import {
             let file_extension = file.extension().and_then(|s| s.to_str()).unwrap_or_default().to_string();
-            if self.import_file_extensions.as_ref().is_some_and(|exts| exts.contains(&file_extension)) {
+            if import.file_extensions.contains(&file_extension) {
                 debug!("{}", t!("extensions.dscextension.importingFile", file = file.display(), extension = self.type_name));
             } else {
                 return Err(DscError::NotSupported(
@@ -93,6 +89,16 @@ impl DscExtension {
             if stdout.is_empty() {
                 info!("{}", t!("extensions.dscextension.importNoResults", extension = self.type_name));
             } else {
+                debug!("got stdout: {}", stdout);
+                if let Some(output) = &import.output {
+                    debug!("processing output: {}", output);
+                    debug!("{}", t!("extensions.dscextension.importProcessingOutput", extension = self.type_name));
+                    let mut parser = Statement::new()?;
+                    let mut context = Context::new();
+                    context.stdout = Some(stdout);
+                    let processed_output = parser.parse_and_execute(output, &context)?;
+                    return Ok(processed_output.to_string());
+                }
                 return Ok(stdout);
             }
         }
diff --git a/lib/dsc-lib/src/functions/mod.rs b/lib/dsc-lib/src/functions/mod.rs
@@ -66,6 +66,7 @@ pub mod resource_id;
 pub mod secret;
 pub mod skip;
 pub mod starts_with;
+pub mod stdout;
 pub mod string;
 pub mod take;
 pub mod sub;
@@ -202,6 +203,7 @@ impl FunctionDispatcher {
             Box::new(secret::Secret{}),
             Box::new(skip::Skip{}),
             Box::new(starts_with::StartsWith{}),
+            Box::new(stdout::Stdout{}),
             Box::new(string::StringFn{}),
             Box::new(sub::Sub{}),
             Box::new(take::Take{}),
diff --git a/lib/dsc-lib/src/functions/stdout.rs b/lib/dsc-lib/src/functions/stdout.rs
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+use crate::DscError;
+use crate::configure::context::Context;
+use crate::functions::{FunctionArgKind, FunctionCategory, FunctionMetadata};
+use rust_i18n::t;
+use serde_json::Value;
+use super::Function;
+
+#[derive(Debug, Default)]
+pub struct Stdout {}
+
+impl Function for Stdout {
+    fn get_metadata(&self) -> FunctionMetadata {
+        FunctionMetadata {
+            name: "stdout".to_string(),
+            description: t!("functions.stdout.description").to_string(),
+            category: vec![FunctionCategory::System],
+            min_args: 0,
+            max_args: 0,
+            accepted_arg_ordered_types: vec![],
+            remaining_arg_accepted_types: None,
+            return_types: vec![FunctionArgKind::String],
+        }
+    }
+
+    fn invoke(&self, _args: &[Value], context: &Context) -> Result<Value, DscError> {
+        if let Some(stdout) = &context.stdout {
+            let result = stdout.to_string();
+            return Ok(Value::String(result));
+        }
+        Err(DscError::Parser(t!("functions.stdout.noStdoutAvailable").to_string(),
+        ))
+    }
+}
diff --git a/lib/dsc-lib/src/parser/expressions.rs b/lib/dsc-lib/src/parser/expressions.rs
diff --git a/lib/dsc-lib/src/parser/functions.rs b/lib/dsc-lib/src/parser/functions.rs
diff --git a/lib/dsc-lib/tests/integration/schemas/schema_for.rs b/lib/dsc-lib/tests/integration/schemas/schema_for.rs

Original file line number	Diff line number	Diff line change
`@@ -13,6 +13,7 @@`
`13`	`13`	`"fileArg": ""`
`14`	`14`	`},`
`15`	`15`	`"--stdout"`
`16`		`- ]`
	`16`	`+ ],`
	`17`	`+ "output": "[json(json(stdout()).parametersJson)]"`
`17`	`18`	`}`
`18`	`19`	`}`