Enable export operation to have own schema

Cargo.toml

@@ -197,7 +197,7 @@ quote = { version = "1.0" }
 # used by other crates
 rand = { version = "0.10.1" }
 # dsc, dsc-lib
-regex = { version = "1.12.3" }
+regex = { version = "1.12.4" }
 # registry, dsc-lib, dsc-lib-registry, dsctest
 registry = { version = "1.3" }
 # dsc

dsc/tests/dsc_resource_export.tests.ps1

@@ -0,0 +1,20 @@
+# Copyright (c) Microsoft Corporation.
+# Licensed under the MIT License.
+
+Describe 'Resource export tests' {
+    It "Export with <resource> accepts input '<json>' and returns filtered results" -TestCases @(
+        @{ resource = 'Test/ExportSchemaCommand'; json = '{ "name": "Gijs" }'; expected = @('Gijs') },
+        @{ resource = 'Test/ExportSchemaCommand'; json = '{ "name": "*e*" }'; expected = @('Steve', 'Tess') },
+        @{ resource = 'Test/ExportSchemaEmbedded'; json = '{ "name": "Gijs" }'; expected = @('Gijs') },
+        @{ resource = 'Test/ExportSchemaEmbedded'; json = '{ "name": "*e*" }'; expected = @('Steve', 'Tess') },
+        @{ resource = 'Test/ExportSchemaNoFiltering'; json = '{ "name": "Gijs" }'; expected = @('Steve', 'Tess', 'Gijs') }
+    ){
+        param($resource, $json, $expected)
+
+        $output = dsc resource export -r $resource -i $json  2>$TESTDRIVE/error.log | ConvertFrom-Json
+        $errorlog = Get-Content "$TESTDRIVE/error.log" -Raw
+        $LASTEXITCODE | Should -Be 0 -Because $errorlog
+        $output.resources.count | Should -Be $expected.Count -Because ($output | ConvertTo-Json -Depth 4)
+        $output.resources.properties.name | Should -Be $expected -Because ($output | ConvertTo-Json -Depth 4)
+    }
+}

lib/dsc-lib/src/dscresources/command_resource.rs

@@ -8,7 +8,7 @@ use rust_i18n::t;
 use serde::Deserialize;
 use serde_json::{Map, Value};
 use std::{collections::HashMap, env, path::Path, process::Stdio};
-use crate::{configure::{config_doc::{ExecutionKind, SecurityContextKind}, config_result::{ResourceGetResult, ResourceTestResult}}, dscresources::{resource_manifest::SchemaArgKind}, types::ExitCodesMap, util::canonicalize_which};
+use crate::{configure::{config_doc::{ExecutionKind, SecurityContextKind}, config_result::{ResourceGetResult, ResourceTestResult}}, dscresources::resource_manifest::{ExportSchemaKind, SchemaArgKind}, types::{ExitCodesMap}, util::canonicalize_which};
 use crate::dscerror::DscError;
 use super::{
     dscresource::{get_diff, redact, DscResource},
@@ -586,6 +586,64 @@ pub fn get_schema(resource: &DscResource, target_resource: Option<&DscResource>)
     }
 }
 
+fn verify_with_export_schema(input: &str, resource: &DscResource, target_resource: Option<&DscResource>) -> Result<(), DscError> {
+    let Some(manifest) = &resource.manifest else {
+        return Err(DscError::MissingManifest(resource.type_name.to_string()));
+    };
+
+    let Some(export) = manifest.export.as_ref() else {
+        return Err(DscError::SchemaNotAvailable(resource.type_name.to_string()));
+    };
+
+    let command_resource = match target_resource {
+        Some(r) => r,
+        None => resource,
+    };
+
+    let schema = match export.schema {
+        Some(ExportSchemaKind::Command(ref command)) => {
+            let args = process_schema_args(command.args.as_ref(), command_resource);
+            let (_exit_code, stdout, _stderr) = invoke_command(&command.executable, args, None, Some(&resource.directory), None, manifest.exit_codes.as_ref())?;
+            stdout
+        },
+        Some(ExportSchemaKind::Embedded(ref schema)) => {
+            serde_json::to_string(schema)?
+        },
+        Some(ExportSchemaKind::NoFiltering) => {
+            return Ok(());
+        },
+        None => {
+            if manifest.validate.is_some() {
+                let result = invoke_validate(resource, input, target_resource)?;
+                if result.valid {
+                    return Ok(());
+                }
+
+                let reason = result
+                    .reason
+                    .map(|s| s.trim().to_string())
+                    .filter(|s| !s.is_empty())
+                    .unwrap_or_else(|| t!("dscresources.commandResource.resourceInvalidJson").to_string());
+                return Err(DscError::Validation(reason));
+            }
+
+            get_schema(resource, target_resource)?
+        }
+    };
+    let schema = serde_json::from_str(&schema)?;
+    let compiled_schema = match Validator::new(&schema) {
+        Ok(schema) => schema,
+        Err(e) => {
+            return Err(DscError::Schema(e.to_string()));
+        },
+    };
+    let json: Value = serde_json::from_str(input)?;
+    if let Err(err) = compiled_schema.validate(&json) {
+        return Err(DscError::Schema(err.to_string()));
+    }
+    Ok(())
+}
+
 /// Invoke the export operation on a resource
 ///
 /// # Arguments
@@ -636,9 +694,15 @@ pub fn invoke_export(resource: &DscResource, input: Option<&str>, target_resourc
         None => resource,
     };
     validate_security_context(&export.require_security_context, &command_resource.type_name, "export")?;
+
     if let Some(input) = input {
+        let input = if export.schema == Some(ExportSchemaKind::NoFiltering) {
+            ""
+        } else {
+            input
+        };
         if !input.is_empty() {
-            verify_json_from_manifest(resource, input, target_resource)?;
+            verify_with_export_schema(input, resource, target_resource)?;
 
             command_input = get_command_input(export.input.as_ref(), input)?;
         }

lib/dsc-lib/src/dscresources/resource_manifest.rs

@@ -206,6 +206,18 @@ pub enum SchemaKind {
     Embedded(Value),
 }
 
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
+#[dsc_repo_schema(base_name = "manifest.exportSchema", folder_path = "definitions")]
+#[serde(rename_all = "camelCase")]
+pub enum ExportSchemaKind {
+    /// The export schema is returned by running a command.
+    Command(SchemaCommand),
+    /// The export schema is embedded in the manifest.
+    Embedded(Value),
+    /// The export operation does not support filtering.
+    NoFiltering,
+}
+
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 pub struct SchemaCommand {
     /// The command to run to get the schema.
@@ -321,6 +333,7 @@ pub struct ExportMethod {
     /// The security context required to run the Export method.  Default if not specified is `current`.
     #[serde(rename = "requireSecurityContext", skip_serializing_if = "Option::is_none")]
     pub require_security_context: Option<SecurityContextKind>,
+    pub schema: Option<ExportSchemaKind>,
 }
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]

tools/dsctest/Cargo.toml

@@ -7,6 +7,7 @@ edition = "2024"
 
 [dependencies]
 clap = { workspace = true }
+regex = { workspace = true }
 schemars = { workspace = true }
 serde = { workspace = true }
 serde_json = { workspace = true }

tools/dsctest/dsctest.dsc.manifests.json

@@ -1405,6 +1405,114 @@
           ]
         }
       }
+    },
+    {
+      "$schema": "https://aka.ms/dsc/schemas/v3/bundled/resource/manifest.json",
+      "type": "Test/ExportSchemaCommand",
+      "version": "0.1.0",
+      "description": "Test resource for export specific schema",
+      "export": {
+        "executable": "dsctest",
+        "args": [
+          "export-schema",
+          {
+            "jsonInputArg": "--input",
+            "mandatory": true
+          }
+        ],
+        "schema": {
+          "command":{
+            "executable": "dsctest",
+            "args": [
+              "schema",
+              "-s",
+              "export-schema"
+            ]
+          }
+        }
+      },
+      "schema": {
+        "command": {
+          "executable": "dsctest",
+          "args": [
+            "schema",
+            "-s",
+            "export-get-schema"
+          ]
+        }
+      }
+    },
+    {
+      "$schema": "https://aka.ms/dsc/schemas/v3/bundled/resource/manifest.json",
+      "type": "Test/ExportSchemaEmbedded",
+      "version": "0.1.0",
+      "description": "Test resource for export specific schema",
+      "export": {
+        "executable": "dsctest",
+        "args": [
+          "export-schema",
+          {
+            "jsonInputArg": "--input",
+            "mandatory": true
+          }
+        ],
+        "schema": {
+          "embedded": {
+            "$schema": "http://json-schema.org/draft-07/schema#",
+            "$id": "http://example.com/export-schema",
+            "title": "Export Schema",
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "name": {
+                "type": "string",
+                "title": "Export Property",
+                "description": "Can contain wildcards for export filtering."
+              }
+            },
+            "required": [
+              "name"
+            ]
+          }
+        }
+      },
+      "schema": {
+        "command": {
+          "executable": "dsctest",
+          "args": [
+            "schema",
+            "-s",
+            "export-get-schema"
+          ]
+        }
+      }
+    },
+    {
+      "$schema": "https://aka.ms/dsc/schemas/v3/bundled/resource/manifest.json",
+      "type": "Test/ExportSchemaNoFiltering",
+      "version": "0.1.0",
+      "description": "Test resource for export specific schema",
+      "export": {
+        "executable": "dsctest",
+        "args": [
+          "export-schema",
+          {
+            "jsonInputArg": "--input",
+            "mandatory": true
+          }
+        ],
+        "schema": "noFiltering"
+      },
+      "schema": {
+        "command": {
+          "executable": "dsctest",
+          "args": [
+            "schema",
+            "-s",
+            "export-get-schema"
+          ]
+        }
+      }
     }
   ]
 }

tools/dsctest/src/args.rs

@@ -11,6 +11,8 @@ pub enum Schemas {
     Exist,
     ExitCode,
     Export,
+    ExportGetSchema,
+    ExportSchema,
     Exporter,
     Get,
     InDesiredState,
@@ -95,6 +97,12 @@ pub enum SubCommand {
         input: String,
     },
 
+    #[clap(name = "export-schema", about = "Test export specific schema")]
+    ExportSchema {
+        #[clap(name = "input", short, long, help = "The input to the export schema command as JSON")]
+        input: String,
+    },
+
     #[clap(name = "exporter", about = "Exports different types of resources")]
     Exporter {
         #[clap(name = "input", short, long, help = "The input to the exporter command as JSON")]