fix: large number parsing and add non-negative validation.

There is an issue where the deserializer throws due to the int.parse if specs contain large numbers.
at the same time we are fixing a validation issue for jsonSchema where the min/max properties should be non-negative

Author: VisualBean

src/ByteBard.AsyncAPI.Readers/AsyncApiStringReader.cs

@@ -4,6 +4,7 @@ namespace ByteBard.AsyncAPI.Readers
     using ByteBard.AsyncAPI.Models;
     using ByteBard.AsyncAPI.Models.Interfaces;
     using ByteBard.AsyncAPI.Readers.Interface;
+    using Extensions;
 
     /// <summary>
     /// Service class for converting strings into AsyncApiDocument instances.

src/ByteBard.AsyncAPI.Readers/Schemas/AsyncApiJsonSchemaDeserializer.cs

@@ -1,10 +1,13 @@
 namespace ByteBard.AsyncAPI.Readers
 {
+    using System;
     using System.Collections.Generic;
     using System.Globalization;
+    using System.Runtime.CompilerServices;
     using ByteBard.AsyncAPI.Extensions;
     using ByteBard.AsyncAPI.Models;
     using ByteBard.AsyncAPI.Readers.ParseNodes;
+    using Exceptions;
 
     public class AsyncApiJsonSchemaDeserializer
     {
@@ -77,30 +80,30 @@ public class AsyncApiJsonSchemaDeserializer
                 }
             },
             {
-                "maxLength", (a, n) => { a.MaxLength = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
+                "maxLength", (a, n) => { a.MaxLength = ParseInteger(n); }
             },
             {
-                "minLength", (a, n) => { a.MinLength = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
+                "minLength", (a, n) => { a.MinLength = ParseInteger(n); }
             },
             {
                 "pattern", (a, n) => { a.Pattern = n.GetScalarValue(); }
             },
             {
-                "maxItems", (a, n) => { a.MaxItems = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
+                "maxItems", (a, n) => { a.MaxItems = ParseInteger(n); }
             },
             {
-                "minItems", (a, n) => { a.MinItems = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
+                "minItems", (a, n) => { a.MinItems = ParseInteger(n); }
             },
             {
                 "uniqueItems", (a, n) => { a.UniqueItems = bool.Parse(n.GetScalarValue()); }
             },
             {
                 "maxProperties",
-                (a, n) => { a.MaxProperties = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
+                (a, n) => { a.MaxProperties = ParseInteger(n); }
             },
             {
                 "minProperties",
-                (a, n) => { a.MinProperties = int.Parse(n.GetScalarValue(), n.Context.Settings.CultureInfo); }
+                (a, n) => { a.MinProperties = ParseInteger(n); }
             },
             {
                 "enum", (a, n) => { a.Enum = n.CreateListOfAny(); }
@@ -212,6 +215,18 @@ public class AsyncApiJsonSchemaDeserializer
             },
         };
 
+        private static int ParseInteger(ParseNode node)
+        {
+            try
+            {
+                return int.Parse(node.GetScalarValue(), node.Context.Settings.CultureInfo);
+            }
+            catch (Exception e)
+            {
+                throw new AsyncApiReaderException("The value is out of range.", node.Context);
+            }
+        }
+
         private static readonly PatternFieldMap<AsyncApiJsonSchema> schemaPatternFields =
             new()
             {

src/ByteBard.AsyncAPI/Resource.Designer.cs

@@ -132,6 +132,9 @@
   <data name="Validation_FieldRequired" xml:space="preserve">
     <value>The field '{0}' in '{1}' object is REQUIRED.</value>
   </data>
+  <data name="Validation_MustBeNonNegative" xml:space="preserve">
+    <value>The field '{0}' must be non-negative.</value>
+  </data>
   <data name="Validation_KeyMustMatchRegularExpr" xml:space="preserve">
     <value>The key '{0}' in '{1}' MUST match the regular expression '{2}'.</value>
   </data>

src/ByteBard.AsyncAPI/Resource.resx

@@ -0,0 +1,72 @@
+namespace ByteBard.AsyncAPI.Validation.Rules;
+
+using Models;
+using Validations;
+
+[AsyncApiRule]
+public static class AsyncApiJsonSchemaRules
+{
+    public static ValidationRule<AsyncApiJsonSchema> NonNegativeFields =>
+        new ValidationRule<AsyncApiJsonSchema>((context, schema) =>
+        {
+            context.Enter("maxLength");
+            if (schema.MaxLength != null && schema.MaxLength < 0)
+            {
+                context.CreateError(
+                    nameof(NonNegativeFields),
+                    string.Format(Resource.Validation_MustBeNonNegative, "maxLength"));
+            }
+
+            context.Exit();
+
+            context.Enter("minLength");
+            if (schema.MinLength != null && schema.MinLength < 0)
+            {
+                context.CreateError(
+                    nameof(NonNegativeFields),
+                    string.Format(Resource.Validation_MustBeNonNegative, "minLength"));
+            }
+
+            context.Exit();
+
+            context.Enter("maxItems");
+            if (schema.MaxItems != null && schema.MaxItems < 0)
+            {
+                context.CreateError(
+                    nameof(NonNegativeFields),
+                    string.Format(Resource.Validation_MustBeNonNegative, "maxItems"));
+            }
+
+            context.Exit();
+
+            context.Enter("minItems");
+            if (schema.MinItems != null && schema.MinItems < 0)
+            {
+                context.CreateError(
+                    nameof(NonNegativeFields),
+                    string.Format(Resource.Validation_MustBeNonNegative, "minItems"));
+            }
+
+            context.Exit();
+
+            context.Enter("maxProperties");
+            if (schema.MaxProperties != null && schema.MaxProperties < 0)
+            {
+                context.CreateError(
+                    nameof(NonNegativeFields),
+                    string.Format(Resource.Validation_MustBeNonNegative, "maxProperties"));
+            }
+
+            context.Exit();
+
+            context.Enter("minProperties");
+            if (schema.MinProperties != null && schema.MinProperties < 0)
+            {
+                context.CreateError(
+                    nameof(NonNegativeFields),
+                    string.Format(Resource.Validation_MustBeNonNegative, "minProperties"));
+            }
+
+            context.Exit();
+        });
+}