(GH-538) Use derive macro for DscRepoSchema trait

Prior to this change, the resource manifest, extension manifest, and
configuration document structs in `dsc-lib` manually implemented the
`DscRepoSchema` trait.

This change uses the new macro to derive the trait on those types and
other types in the library that currently map to schema files. This
change also makes an effort to correctly annotate types that aren't
covered by the separate schemas, but as not all types map to a schema
file, these changes don't fully cover all types that derive the
`JsonSchema` trait.

This change prepares the library for further canonicalization steps to
steer the generated schemas towards the definitions in the canonical
schemas.

Author: michaeltlombardi

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

@@ -3,38 +3,41 @@
 
 use chrono::{DateTime, Local};
 use rust_i18n::t;
-use schemars::{JsonSchema, json_schema};
+use schemars::JsonSchema;
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Map, Value};
 use std::{collections::HashMap, fmt::Display};
 
 use crate::schemas::{
-    dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri},
+    dsc_repo::DscRepoSchema,
     transforms::{idiomaticize_externally_tagged_enum, idiomaticize_string_enum}
 };
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(rename_all = "camelCase")]
 #[schemars(transform = idiomaticize_string_enum)]
+#[dsc_repo_schema(base_name = "securityContext", folder_path = "metadata/Microsoft.DSC")]
 pub enum SecurityContextKind {
     Current,
     Elevated,
     Restricted,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(rename_all = "camelCase")]
 #[schemars(transform = idiomaticize_string_enum)]
+#[dsc_repo_schema(base_name = "operation", folder_path = "metadata/Microsoft.DSC")]
 pub enum Operation {
     Get,
     Set,
     Test,
     Export,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(rename_all = "camelCase")]
 #[schemars(transform = idiomaticize_string_enum)]
+#[dsc_repo_schema(base_name = "executionType", folder_path = "metadata/Microsoft.DSC")]
 pub enum ExecutionKind {
     Actual,
     WhatIf,
@@ -47,9 +50,10 @@ pub struct Process {
     pub id: u32,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(rename_all = "camelCase")]
 #[schemars(transform = idiomaticize_externally_tagged_enum)]
+#[dsc_repo_schema(base_name = "restartRequired", folder_path = "metadata/Microsoft.DSC")]
 pub enum RestartRequired {
     System(String),
     Service(String),
@@ -104,33 +108,38 @@ impl MicrosoftDscMetadata {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
+#[dsc_repo_schema(base_name = "document.metadata", folder_path = "config")]
 pub struct Metadata {
     #[serde(rename = "Microsoft.DSC", skip_serializing_if = "Option::is_none")]
     pub microsoft: Option<MicrosoftDscMetadata>,
     #[serde(flatten)]
     pub other: Map<String, Value>,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
+#[dsc_repo_schema(base_name = "document.function", folder_path = "config")]
 pub struct UserFunction {
     pub namespace: String,
     pub members: HashMap<String, UserFunctionDefinition>,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
+#[dsc_repo_schema(base_name = "definition", folder_path = "definitions/functions/user")]
 pub struct UserFunctionDefinition {
     pub parameters: Option<Vec<UserFunctionParameter>>,
     pub output: UserFunctionOutput,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
+#[dsc_repo_schema(base_name = "parameter", folder_path = "definitions/functions/user")]
 pub struct UserFunctionParameter {
     pub name: String,
     pub r#type: DataType,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
+#[dsc_repo_schema(base_name = "output", folder_path = "definitions/functions/user")]
 pub struct UserFunctionOutput {
     pub r#type: DataType,
     pub value: String,
@@ -143,17 +152,28 @@ pub enum ValueOrCopy {
     Copy(Copy),
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "document.output", folder_path = "config")]
 pub struct Output {
     pub condition: Option<String>,
     pub r#type: DataType,
     #[serde(flatten)]
     pub value_or_copy: ValueOrCopy,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(
+    base_name = "document",
+    folder_path = "config",
+    should_bundle = true,
+    schema_field(
+        name = schema,
+        title = t!("configure.config_doc.configurationDocumentSchemaTitle"),
+        description = t!("configure.config_doc.configurationDocumentSchemaDescription"),
+    )
+)]
 pub struct Configuration {
     #[serde(rename = "$schema")]
     #[schemars(schema_with = "Configuration::recognized_schema_uris_subschema")]
@@ -222,8 +242,9 @@ where
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "document.parameter", folder_path = "config")]
 pub struct Parameter {
     #[serde(rename = "type")]
     pub parameter_type: DataType,
@@ -245,8 +266,9 @@ pub struct Parameter {
     pub metadata: Option<Map<String, Value>>,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[schemars(transform = idiomaticize_string_enum)]
+#[dsc_repo_schema(base_name = "dataTypes", folder_path = "definitions/parameters")]
 pub enum DataType {
     #[serde(rename = "string")]
     String,
@@ -353,8 +375,9 @@ pub struct Sku {
     pub capacity: Option<i32>,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "document.resource", folder_path = "config")]
 pub struct Resource {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub condition: Option<String>,
@@ -406,30 +429,6 @@ impl Default for Configuration {
     }
 }
 
-impl DscRepoSchema for Configuration {
-    const SCHEMA_FILE_BASE_NAME: &'static str = "document";
-    const SCHEMA_FOLDER_PATH: &'static str = "config";
-    const SCHEMA_SHOULD_BUNDLE: bool = true;
-
-    fn schema_property_metadata() -> schemars::Schema {
-        json_schema!({
-            "title": t!("configure.config_doc.configurationDocumentSchemaTitle").to_string(),
-            "description": t!("configure.config_doc.configurationDocumentSchemaDescription").to_string(),
-        })
-    }
-
-    fn validate_schema_uri(&self) -> Result<(), UnrecognizedSchemaUri> {
-        if Self::is_recognized_schema_uri(&self.schema) {
-            Ok(())
-        } else {
-            Err(UnrecognizedSchemaUri(
-                self.schema.clone(),
-                Self::recognized_schema_uris(),
-            ))
-        }
-    }
-}
-
 impl Configuration {
     #[must_use]
     pub fn new() -> Self {

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

@@ -7,7 +7,7 @@ use serde_json::{Map, Value};
 
 use crate::dscresources::invoke_result::{GetResult, SetResult, TestResult};
 use crate::configure::config_doc::{Configuration, Metadata};
-use crate::schemas::transforms::idiomaticize_string_enum;
+use crate::schemas::{dsc_repo::DscRepoSchema, transforms::idiomaticize_string_enum};
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
@@ -18,8 +18,9 @@ pub enum MessageLevel {
     Information,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "message", folder_path = "definitions")]
 pub struct ResourceMessage {
     pub name: String,
     #[serde(rename="type")]
@@ -28,8 +29,9 @@ pub struct ResourceMessage {
     pub level: MessageLevel,
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "get.full", folder_path = "outputs/resource")]
 pub struct ResourceGetResult {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<Metadata>,
@@ -50,8 +52,9 @@ impl From<ResourceTestResult> for ResourceGetResult {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "get", folder_path = "outputs/config")]
 pub struct ConfigurationGetResult {
     pub metadata: Option<Metadata>,
     pub results: Vec<ResourceGetResult>,
@@ -97,8 +100,9 @@ impl From<ConfigurationTestResult> for ConfigurationGetResult {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "set.full", folder_path = "outputs/resource")]
 pub struct ResourceSetResult {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<Metadata>,
@@ -140,8 +144,9 @@ impl Default for GroupResourceSetResult {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "set", folder_path = "outputs/config")]
 pub struct ConfigurationSetResult {
     pub metadata: Option<Metadata>,
     pub results: Vec<ResourceSetResult>,
@@ -171,8 +176,9 @@ impl Default for ConfigurationSetResult {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "test.full", folder_path = "outputs/resource")]
 pub struct ResourceTestResult {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub metadata: Option<Metadata>,
@@ -203,8 +209,9 @@ impl Default for GroupResourceTestResult {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "test", folder_path = "outputs/config")]
 pub struct ConfigurationTestResult {
     pub metadata: Option<Metadata>,
     pub results: Vec<ResourceTestResult>,
@@ -234,8 +241,9 @@ impl Default for ConfigurationTestResult {
     }
 }
 
-#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "export", folder_path = "outputs/config")]
 pub struct ConfigurationExportResult {
     pub metadata: Option<Metadata>,
     pub result: Option<Configuration>,

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

@@ -14,6 +14,8 @@ use std::collections::HashMap;
 use std::path::PathBuf;
 use tracing::{debug, info, trace};
 
+use crate::schemas::dsc_repo::DscRepoSchema;
+
 use super::{
     command_resource,
     dscerror,
@@ -25,8 +27,9 @@ use super::{
     }
 };
 
-#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema)]
+#[derive(Clone, Debug, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(deny_unknown_fields)]
+#[dsc_repo_schema(base_name = "list", folder_path = "outputs/resource")]
 pub struct DscResource {
     /// The namespaced name of the resource.
     #[serde(rename="type")]
@@ -59,9 +62,10 @@ pub struct DscResource {
     pub manifest: Option<Value>,
 }
 
-#[derive(Clone, Debug, PartialEq, Deserialize, Serialize, JsonSchema)]
+#[derive(Clone, Debug, PartialEq, Deserialize, Serialize, JsonSchema, DscRepoSchema)]
 #[serde(rename_all = "camelCase")]
 #[schemars(transform = idiomaticize_string_enum)]
+#[dsc_repo_schema(base_name = "resourceCapabilities", folder_path = "definitions")]
 pub enum Capability {
     /// The resource supports retrieving configuration.
     Get,