(GH-538) Re-export dsc-lib-jsonschema in dsc-lib

lib/dsc-lib/locales/en-us.toml

@@ -729,9 +729,7 @@ schemaNotAvailable = "No Schema found and `validate` is not supported"
 securityContext = "Security context"
 utf8Conversion = "UTF-8 conversion"
 unknown = "Unknown"
-unrecognizedSchemaUri = "Unrecognized $schema URI"
 validation = "Validation"
-validSchemaUrisAre = "Valid schema URIs are"
 extension = "Extension"
 unsupportedCapability = "does not support capability"
 setting = "Setting"

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

@@ -2,17 +2,16 @@
 // Licensed under the MIT License.
 
 use chrono::{DateTime, Local};
-use dsc_lib_jsonschema::transforms::{
-    idiomaticize_externally_tagged_enum,
-    idiomaticize_string_enum
-};
 use rust_i18n::t;
 use schemars::{JsonSchema, json_schema};
 use serde::{Deserialize, Deserializer, Serialize};
 use serde_json::{Map, Value};
 use std::{collections::HashMap, fmt::Display};
 
-use crate::{dscerror::DscError, schemas::DscRepoSchema};
+use crate::schemas::{
+    dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri},
+    transforms::{idiomaticize_externally_tagged_enum, idiomaticize_string_enum}
+};
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
@@ -412,18 +411,18 @@ impl DscRepoSchema for Configuration {
     const SCHEMA_FOLDER_PATH: &'static str = "config";
     const SCHEMA_SHOULD_BUNDLE: bool = true;
 
-    fn schema_metadata() -> schemars::Schema {
+    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<(), DscError> {
+    fn validate_schema_uri(&self) -> Result<(), UnrecognizedSchemaUri> {
         if Self::is_recognized_schema_uri(&self.schema) {
             Ok(())
         } else {
-            Err(DscError::UnrecognizedSchemaUri(
+            Err(UnrecognizedSchemaUri(
                 self.schema.clone(),
                 Self::recognized_schema_uris(),
             ))
@@ -485,11 +484,9 @@ impl Default for Resource {
 
 #[cfg(test)]
 mod test {
-    use crate::{
-        configure::config_doc::Configuration,
-        dscerror::DscError,
-        schemas::DscRepoSchema
-    };
+    use crate::schemas::dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri};
+
+    use crate::configure::config_doc::Configuration;
 
     #[test]
     fn test_validate_schema_uri_with_invalid_uri() {
@@ -505,13 +502,10 @@ mod test {
         assert!(result.as_ref().is_err());
 
         match result.as_ref().unwrap_err() {
-            DscError::UnrecognizedSchemaUri(actual, recognized) => {
+            UnrecognizedSchemaUri(actual, recognized) => {
                 assert_eq!(actual, &invalid_uri);
                 assert_eq!(recognized, &Configuration::recognized_schema_uris())
             },
-            _ => {
-                panic!("Expected validate_schema_uri() to error on unrecognized schema uri, but was {:?}", result.as_ref().unwrap_err())
-            }
         }
     }
 

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

@@ -1,9 +1,11 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
-use dsc_lib_jsonschema::transforms::idiomaticize_string_enum;
+
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
+use crate::schemas::transforms::idiomaticize_string_enum;
+
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
 pub struct ConfigurationResourceStartedEvent {

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

@@ -1,12 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use dsc_lib_jsonschema::transforms::idiomaticize_string_enum;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 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;
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]

lib/dsc-lib/src/discovery/command_discovery.rs

@@ -12,7 +12,7 @@ use crate::extensions::dscextension::{self, DscExtension, Capability as Extensio
 use crate::extensions::extension_manifest::ExtensionManifest;
 use crate::progress::{ProgressBar, ProgressFormat};
 use crate::util::convert_wildcard_to_regex;
-use dsc_lib_jsonschema::transforms::idiomaticize_externally_tagged_enum;
+use crate::schemas::transforms::idiomaticize_externally_tagged_enum;
 use regex::RegexBuilder;
 use rust_i18n::t;
 use semver::{Version, VersionReq};

lib/dsc-lib/src/dscerror.rs

@@ -128,8 +128,8 @@ pub enum DscError {
         message: String,
     },
 
-    #[error("{t}: {0}.  {t2}: {1:?}", t = t!("dscerror.unrecognizedSchemaUri"), t2 = t!("dscerror.validSchemaUrisAre"))]
-    UnrecognizedSchemaUri(String, Vec<String>),
+    #[error(transparent)]
+    UnrecognizedSchemaUri(#[from] crate::schemas::dsc_repo::UnrecognizedSchemaUri),
 
     #[error("{t} '{0}' {t2} '{1}'", t = t!("dscerror.extension"), t2 = t!("dscerror.unsupportedCapability"))]
     UnsupportedCapability(String, String),

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

@@ -3,7 +3,7 @@
 
 use crate::{configure::{Configurator, config_doc::{Configuration, ExecutionKind, Resource}, context::ProcessMode, parameters::{SECURE_VALUE_REDACTED, is_secure_value}}, dscresources::resource_manifest::{AdapterInputKind, Kind}};
 use crate::dscresources::invoke_result::{ResourceGetResponse, ResourceSetResponse};
-use dsc_lib_jsonschema::transforms::idiomaticize_string_enum;
+use crate::schemas::transforms::idiomaticize_string_enum;
 use dscerror::DscError;
 use jsonschema::Validator;
 use rust_i18n::t;

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

@@ -1,15 +1,17 @@
 // Copyright (c) Microsoft Corporation.
 // Licensed under the MIT License.
 
-use dsc_lib_jsonschema::transforms::idiomaticize_string_enum;
 use rust_i18n::t;
 use schemars::{Schema, JsonSchema, json_schema};
 use semver::Version;
 use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use std::collections::HashMap;
 
-use crate::{dscerror::DscError, schemas::DscRepoSchema};
+use crate::{
+    dscerror::DscError,
+    schemas::{dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri}, transforms::idiomaticize_string_enum},
+};
 
 #[derive(Debug, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(rename_all = "camelCase")]
@@ -259,18 +261,18 @@ impl DscRepoSchema for ResourceManifest {
     const SCHEMA_FOLDER_PATH: &'static str = "resource";
     const SCHEMA_SHOULD_BUNDLE: bool = true;
 
-    fn schema_metadata() -> Schema {
+    fn schema_property_metadata() -> Schema {
         json_schema!({
             "title": t!("dscresources.resource_manifest.resourceManifestSchemaTitle").to_string(),
             "description": t!("dscresources.resource_manifest.resourceManifestSchemaDescription").to_string(),
         })
     }
 
-    fn validate_schema_uri(&self) -> Result<(), DscError> {
+    fn validate_schema_uri(&self) -> Result<(), UnrecognizedSchemaUri> {
         if Self::is_recognized_schema_uri(&self.schema_version) {
             Ok(())
         } else {
-            Err(DscError::UnrecognizedSchemaUri(
+            Err(UnrecognizedSchemaUri(
                 self.schema_version.clone(),
                 Self::recognized_schema_uris(),
             ))
@@ -321,11 +323,9 @@ pub fn validate_semver(version: &str) -> Result<(), semver::Error> {
 
 #[cfg(test)]
 mod test {
-    use crate::{
-        dscerror::DscError,
-        dscresources::resource_manifest::ResourceManifest,
-        schemas::DscRepoSchema
-    };
+    use crate::schemas::dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri};
+
+    use crate::dscresources::resource_manifest::ResourceManifest;
 
     #[test]
     fn test_validate_schema_uri_with_invalid_uri() {
@@ -343,13 +343,10 @@ mod test {
         assert!(result.as_ref().is_err());
 
         match result.as_ref().unwrap_err() {
-            DscError::UnrecognizedSchemaUri(actual, recognized) => {
+            UnrecognizedSchemaUri(actual, recognized) => {
                 assert_eq!(actual, &invalid_uri);
                 assert_eq!(recognized, &ResourceManifest::recognized_schema_uris())
             },
-            _ => {
-                panic!("Expected validate_schema_uri() to error on unrecognized schema uri, but was {:?}", result.as_ref().unwrap_err())
-            }
         }
     }
 

lib/dsc-lib/src/extensions/dscextension.rs

@@ -2,7 +2,7 @@
 // Licensed under the MIT License.
 
 use crate::extensions::import::ImportMethod;
-use dsc_lib_jsonschema::transforms::idiomaticize_string_enum;
+use crate::schemas::transforms::idiomaticize_string_enum;
 use serde::{Deserialize, Serialize};
 use serde_json::Value;
 use schemars::JsonSchema;

lib/dsc-lib/src/extensions/extension_manifest.rs

@@ -8,8 +8,9 @@ use serde::{Deserialize, Serialize};
 use serde_json::{Map, Value};
 use std::collections::HashMap;
 
-use crate::{dscerror::DscError, schemas::DscRepoSchema};
+use crate::dscerror::DscError;
 use crate::extensions::{discover::DiscoverMethod, import::ImportMethod, secret::SecretMethod};
+use crate::schemas::dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri};
 
 #[derive(Debug, Default, Clone, PartialEq, Deserialize, Serialize, JsonSchema)]
 #[serde(deny_unknown_fields)]
@@ -51,18 +52,18 @@ impl DscRepoSchema for ExtensionManifest {
     const SCHEMA_FOLDER_PATH: &'static str = "extension";
     const SCHEMA_SHOULD_BUNDLE: bool = true;
 
-    fn schema_metadata() -> Schema {
+    fn schema_property_metadata() -> Schema {
         json_schema!({
             "title": t!("extensions.extension_manifest.extensionManifestSchemaTitle").to_string(),
             "description": t!("extensions.extension_manifest.extensionManifestSchemaDescription").to_string(),
         })
     }
 
-    fn validate_schema_uri(&self) -> Result<(), DscError> {
+    fn validate_schema_uri(&self) -> Result<(), UnrecognizedSchemaUri> {
         if Self::is_recognized_schema_uri(&self.schema_version) {
             Ok(())
         } else {
-            Err(DscError::UnrecognizedSchemaUri(
+            Err(UnrecognizedSchemaUri(
                 self.schema_version.clone(),
                 Self::recognized_schema_uris(),
             ))
@@ -109,9 +110,9 @@ pub fn validate_semver(version: &str) -> Result<(), semver::Error> {
 
 #[cfg(test)]
 mod test {
-    use crate::{
-        dscerror::DscError, extensions::extension_manifest::ExtensionManifest, schemas::DscRepoSchema
-    };
+    use crate::schemas::dsc_repo::{DscRepoSchema, UnrecognizedSchemaUri};
+
+    use crate::extensions::extension_manifest::ExtensionManifest;
 
     #[test]
     fn test_validate_schema_uri_with_invalid_uri() {
@@ -129,13 +130,10 @@ mod test {
         assert!(result.as_ref().is_err());
 
         match result.as_ref().unwrap_err() {
-            DscError::UnrecognizedSchemaUri(actual, recognized) => {
+            UnrecognizedSchemaUri(actual, recognized) => {
                 assert_eq!(actual, &invalid_uri);
                 assert_eq!(recognized, &ExtensionManifest::recognized_schema_uris())
             },
-            _ => {
-                panic!("Expected validate_schema_uri() to error on unrecognized schema uri, but was {:?}", result.as_ref().unwrap_err())
-            }
         }
     }
 

lib/dsc-lib/src/lib.rs

@@ -19,7 +19,9 @@ pub mod functions;
 pub mod parser;
 pub mod progress;
 pub mod util;
-pub mod schemas;
+
+// Re-export the dependency crate to minimize dependency management.
+pub use dsc_lib_jsonschema as schemas;
 
 i18n!("locales", fallback = "en-us");