PowerShell · iSazonov · May 4, 2023 · Sep 3, 2022 · Sep 5, 2022 · Sep 6, 2022
@@ -35,11 +35,7 @@
     <PackageReference Include="Microsoft.CodeAnalysis.CSharp" Version="4.6.0-1.final" />
     <PackageReference Include="System.Threading.AccessControl" Version="8.0.0-preview.3.23174.8" />
     <PackageReference Include="System.Drawing.Common" Version="8.0.0-preview.2.23128.3" />
-    <PackageReference Include="NJsonSchema" Version="10.8.0" />
-    <!-- NJsonSchema brings in an old version of CSharp
-      So, we are forcing a newer version.
-    -->
-    <PackageReference Include="Microsoft.CSharp" Version="4.7.0" />
+    <PackageReference Include="JsonSchema.Net" Version="3.3.2" />
   </ItemGroup>
 
 </Project>
diff --git a/...ft.PowerShell.Commands.Utility/commands/utility/JsonSchemaReferenceResolutionException.cs b/...ft.PowerShell.Commands.Utility/commands/utility/JsonSchemaReferenceResolutionException.cs
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+#nullable enable
+
+using System;
+
+namespace Microsoft.PowerShell.Commands;
+
+/// <summary>
+/// Thrown during evaluation of <see cref="TestJsonCommand"/> when an attempt
+/// to resolve a <code>$ref</code> or <code>$dynamicRef</code> fails.
+/// </summary>
+internal class JsonSchemaReferenceResolutionException : Exception
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="JsonSchemaReferenceResolutionException"/> class.
+    /// </summary>
+    /// <param name="innerException">
+    /// The exception that is the cause of the current exception, or a null reference
+    /// (<code>Nothing</code> in Visual Basic) if no inner exception is specified.
+    /// </param>
+    public JsonSchemaReferenceResolutionException(Exception innerException)
+        : base(message: null, innerException)
+    {
+    }
+}
diff --git a/src/Microsoft.PowerShell.Commands.Utility/commands/utility/TestJsonCommand.cs b/src/Microsoft.PowerShell.Commands.Utility/commands/utility/TestJsonCommand.cs
@@ -5,11 +5,11 @@
 using System.Globalization;
 using System.IO;
 using System.Management.Automation;
-using System.Reflection;
-using System.Runtime.ExceptionServices;
+using System.Net.Http;
 using System.Security;
-using Newtonsoft.Json.Linq;
-using NJsonSchema;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Json.Schema;
 
 namespace Microsoft.PowerShell.Commands
 {
@@ -104,36 +104,50 @@ public string LiteralPath
         private bool _isLiteralPath = false;
         private JsonSchema _jschema;
 
-        /// <summary>
-        /// Process all exceptions in the AggregateException.
-        /// Unwrap TargetInvocationException if any and
-        /// rethrow inner exception without losing the stack trace.
-        /// </summary>
-        /// <param name="e">AggregateException to be unwrapped.</param>
-        /// <returns>Return value is unreachable since we always rethrow.</returns>
-        private static bool UnwrapException(Exception e)
-        {
-            if (e.InnerException != null && e is TargetInvocationException)
-            {
-                ExceptionDispatchInfo.Capture(e.InnerException).Throw();
-            }
-            else
-            {
-                ExceptionDispatchInfo.Capture(e).Throw();
-            }
-
-            return true;
-        }
-
         #endregion
 
-        #region Protected Members
-
         /// <summary>
         /// Prepare a JSON schema.
         /// </summary>
         protected override void BeginProcessing()
         {
+            // By default, a JSON Schema implementation isn't supposed to automatically fetch content.
+            // Instead JsonSchema.Net has been set up with a registry so that users can pre-register
+            // any schemas they may need to resolve.
+            // However, pre-registering schemas doesn't make sense in the context of a Powershell command,
+            // and automatically fetching referenced URIs is likely the preferred behavior.  To do that,
+            // this property must be set with a method to retrieve and deserialize the content.
+            // For more information, see https://json-everything.net/json-schema#automatic-resolution
+            SchemaRegistry.Global.Fetch = static uri =>
+            {
+                try
+                {
+                    string text;
+                    switch (uri.Scheme)
+                    {
+                        case "http":
+                        case "https":
+                            {
+                                using var client = new HttpClient();
+                                text = client.GetStringAsync(uri).Result;
+                                break;
+                            }
+                        case "file":
+                            var filename = Uri.UnescapeDataString(uri.AbsolutePath);
+                            text = File.ReadAllText(filename);
+                            break;
+                        default:
+                            throw new FormatException(string.Format(TestJsonCmdletStrings.InvalidUriScheme, uri.Scheme));
+                    }
+
+                    return JsonSerializer.Deserialize<JsonSchema>(text);
+                }
+                catch (Exception e)
+                {
+                    throw new JsonSchemaReferenceResolutionException(e);
+                }
+            };
+
             string resolvedpath = string.Empty;
 
             try
@@ -142,25 +156,25 @@ protected override void BeginProcessing()
                 {
                     try
                     {
-                        _jschema = JsonSchema.FromJsonAsync(Schema).Result;
+                        _jschema = JsonSchema.FromText(Schema);
                     }
-                    catch (AggregateException ae)
+                    catch (JsonException e)
                     {
-                        // Even if only one exception is thrown, it is still wrapped in an AggregateException exception
-                        // https://docs.microsoft.com/en-us/dotnet/standard/parallel-programming/exception-handling-task-parallel-library
-                        ae.Handle(UnwrapException);
+                        Exception exception = new(TestJsonCmdletStrings.InvalidJsonSchema, e);
+                        WriteError(new ErrorRecord(exception, "InvalidJsonSchema", ErrorCategory.InvalidData, Schema));
                     }
                 }
                 else if (SchemaFile != null)
                 {
                     try
                     {
                         resolvedpath = Context.SessionState.Path.GetUnresolvedProviderPathFromPSPath(SchemaFile);
-                        _jschema = JsonSchema.FromFileAsync(resolvedpath).Result;
+                        _jschema = JsonSchema.FromFile(resolvedpath);
                     }
-                    catch (AggregateException ae)
+                    catch (JsonException e)
                     {
-                        ae.Handle(UnwrapException);
+                        Exception exception = new(TestJsonCmdletStrings.InvalidJsonSchema, e);
+                        WriteError(new ErrorRecord(exception, "InvalidJsonSchema", ErrorCategory.InvalidData, SchemaFile));
                     }
                 }
             }
@@ -194,6 +208,7 @@ e is SecurityException
         protected override void ProcessRecord()
         {
             bool result = true;
+
             string jsonToParse = string.Empty;
 
             if (Json != null)
@@ -217,45 +232,57 @@ protected override void ProcessRecord()
                 jsonToParse = File.ReadAllText(resolvedPath);
             }
 
-            if (string.IsNullOrWhiteSpace(jsonToParse))
-            {
-                WriteObject(false);
-                return;
-            }
-
             try
             {
-                var parsedJson = JToken.Parse(jsonToParse);
+
+                var parsedJson = JsonNode.Parse(jsonToParse);
 
                 if (_jschema != null)
                 {
-                    var errorMessages = _jschema.Validate(parsedJson);
-                    if (errorMessages != null && errorMessages.Count != 0)
-                    {
-                        result = false;
-
-                        Exception exception = new(TestJsonCmdletStrings.InvalidJsonAgainstSchema);
-
-                        foreach (var message in errorMessages)
+                        var validationResults = _jschema.Validate(parsedJson, new ValidationOptions { OutputFormat = OutputFormat.Basic });
+                        result = validationResults.IsValid;
+                        if (!result)
                         {
-                            ErrorRecord errorRecord = new(exception, "InvalidJsonAgainstSchema", ErrorCategory.InvalidData, null);
-                            errorRecord.ErrorDetails = new ErrorDetails(message.ToString());
-                            WriteError(errorRecord);
+                            if (validationResults.Message != null)
+                            {
+                                Exception exception = new(string.Format(TestJsonCmdletStrings.InvalidJsonAgainstSchemaDetailed, validationResults.Message, validationResults.InstanceLocation));
+                                ErrorRecord errorRecord = new(exception, "InvalidJsonAgainstSchemaDetailed", ErrorCategory.InvalidData, null);
+                                WriteError(errorRecord);
+                            }
+
+                            if (validationResults.HasNestedResults)
+                            {
+                                foreach (var nestedResult in validationResults.NestedResults)
+                                {
+                                    if (nestedResult.Message == null)
+                                    {
+                                        continue;
+                                    }
+
+                                    Exception exception = new(string.Format(TestJsonCmdletStrings.InvalidJsonAgainstSchemaDetailed, nestedResult.Message, nestedResult.InstanceLocation));
+                                    ErrorRecord errorRecord = new(exception, "InvalidJsonAgainstSchemaDetailed", ErrorCategory.InvalidData, null);
+                                    WriteError(errorRecord);
+                                }
+                            }
                         }
-                    }
                 }
             }
+            catch (JsonSchemaReferenceResolutionException jsonExc)
+            {
+                result = false;
+
+                Exception exception = new(TestJsonCmdletStrings.InvalidJsonSchema, jsonExc);
+                WriteError(new ErrorRecord(exception, "InvalidJsonSchema", ErrorCategory.InvalidData, _jschema));
+            }
             catch (Exception exc)
             {
                 result = false;
 
                 Exception exception = new(TestJsonCmdletStrings.InvalidJson, exc);
-                WriteError(new ErrorRecord(exception, "InvalidJson", ErrorCategory.InvalidData, jsonToParse));
+                WriteError(new ErrorRecord(exception, "InvalidJson", ErrorCategory.InvalidData, Json));
             }
 
             WriteObject(result);
         }
-
-        #endregion
     }
 }
diff --git a/src/Microsoft.PowerShell.Commands.Utility/resources/TestJsonCmdletStrings.resx b/src/Microsoft.PowerShell.Commands.Utility/resources/TestJsonCmdletStrings.resx
@@ -123,10 +123,13 @@
   <data name="InvalidJson" xml:space="preserve">
     <value>Cannot parse the JSON.</value>
   </data>
-  <data name="InvalidJsonAgainstSchema" xml:space="preserve">
-    <value>The JSON is not valid with the schema.</value>
+  <data name="InvalidJsonAgainstSchemaDetailed" xml:space="preserve">
+    <value>The JSON is not valid with the schema: {0} at {1}</value>
   </data>
   <data name="JsonSchemaFileOpenFailure" xml:space="preserve">
     <value>Can not open JSON schema file: {0}</value>
   </data>
+  <data name="InvalidUriScheme" xml:space="preserve">
+    <value>URI scheme '{0}' is not supported. Only HTTP(S) and local file system URIs are allowed.</value>
+  </data>
 </root>