DTOSS-9177: Abort validation if too many errors are returned

src/ServiceLayer.Mesh/Configuration/AppConfiguration.cs

@@ -6,32 +6,21 @@ public class AppConfiguration :
     IFileTransformQueueClientConfiguration,
     IFileTransformFunctionConfiguration,
     IFileRetryFunctionConfiguration,
-    IMeshHandshakeFunctionConfiguration
+    IMeshHandshakeFunctionConfiguration,
+    IValidationRunnerConfiguration
 {
     public string NbssMeshMailboxId => GetRequired("NbssMailboxId");
 
     public string FileExtractQueueName => GetRequired("FileExtractQueueName");
 
     public string FileTransformQueueName => GetRequired("FileTransformQueueName");
 
-    public int StaleHours => GetRequiredInt("StaleHours");
+    public int MaximumValidationErrors => GetOptionalInt("MaximumValidationErrors", 100);
 
-    private static string GetRequired(string key)
-    {
-        var value = EnvironmentVariables.GetRequired(key);
+    public int StaleHours => GetOptionalInt("StaleHours", 12);
 
-        return value;
-    }
-
-    private static int GetRequiredInt(string key)
-    {
-        var value = GetRequired(key);
-
-        if (!int.TryParse(value, out var intValue))
-        {
-            throw new InvalidOperationException($"Environment variable '{key}' is not a valid integer");
-        }
-
-        return intValue;
-    }
+    private static string GetRequired(string key) =>
+        EnvironmentVariables.GetRequired(key);
+    private static int GetOptionalInt(string key, int defaultValue) =>
+        EnvironmentVariables.GetOptionalInt(key, defaultValue);
 }

src/ServiceLayer.Mesh/Configuration/IValidationRunnerConfiguration.cs

@@ -0,0 +1,6 @@
+namespace ServiceLayer.Mesh.Configuration;
+
+public interface IValidationRunnerConfiguration
+{
+    int MaximumValidationErrors { get; }
+}

src/ServiceLayer.Mesh/Configuration/ServiceCollectionExtensions.cs

@@ -6,12 +6,16 @@ internal static class ServiceCollectionExtensions
 {
     internal static IServiceCollection AddApplicationConfiguration(this IServiceCollection services)
     {
-        services.AddTransient<IFileDiscoveryFunctionConfiguration, AppConfiguration>();
-        services.AddTransient<IFileExtractQueueClientConfiguration, AppConfiguration>();
-        services.AddTransient<IFileTransformQueueClientConfiguration, AppConfiguration>();
-        services.AddTransient<IMeshHandshakeFunctionConfiguration, AppConfiguration>();
-        services.AddTransient<IFileRetryFunctionConfiguration, AppConfiguration>();
-        services.AddTransient<IFileTransformFunctionConfiguration, AppConfiguration>();
+        var implementationType = typeof(AppConfiguration);
+
+        var interfaces = implementationType
+            .GetInterfaces()
+            .Where(i => i.Namespace == implementationType.Namespace);
+
+        foreach (var serviceType in interfaces)
+        {
+            services.AddTransient(serviceType, implementationType);
+        }
 
         return services;
     }

src/ServiceLayer.Mesh/FileTypes/NbssAppointmentEvents/Validation/ErrorCodes.cs

@@ -71,4 +71,5 @@ public static class ErrorCodes
     public const string MissingActionTimestamp = "NBSSAPPT067";
     public const string InvalidActionTimestamp = "NBSSAPPT068";
     public const string UnknownRecordTypeIdentifier = "NBSSAPPT069";
+    public const string ValidationAborted = "NBSSAPPT999";
 }

src/ServiceLayer.Mesh/FileTypes/NbssAppointmentEvents/Validation/ValidationRunner.cs

@@ -1,8 +1,10 @@
+using ServiceLayer.Mesh.Configuration;
 using ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Models;
 
 namespace ServiceLayer.Mesh.FileTypes.NbssAppointmentEvents.Validation;
 
 public class ValidationRunner(
+    IValidationRunnerConfiguration configuration,
     IEnumerable<IFileValidator> fileValidators,
     IEnumerable<IRecordValidator> recordValidators)
     : IValidationRunner
@@ -11,18 +13,61 @@ public IList<ValidationError> Validate(ParsedFile file)
     {
         var errors = new List<ValidationError>();
 
+        RunFileValidators(file, errors);
+        if (errors.Count >= configuration.MaximumValidationErrors)
+        {
+            return FinalizeEarly(errors);
+        }
+
+        RunRecordValidators(file, errors);
+        if (errors.Count >= configuration.MaximumValidationErrors)
+        {
+            return FinalizeEarly(errors);
+        }
+
+        return errors;
+    }
+
+    private void RunFileValidators(ParsedFile file, List<ValidationError> errors)
+    {
         foreach (var validator in fileValidators)
         {
-            errors.AddRange(validator.Validate(file));
+            var results = validator.Validate(file);
+            AddErrorsWithCap(results, errors);
+            if (errors.Count >= configuration.MaximumValidationErrors) return;
         }
+    }
 
-        foreach (var dataRecord in file.DataRecords)
+    private void RunRecordValidators(ParsedFile file, List<ValidationError> errors)
+    {
+        foreach (var record in file.DataRecords)
         {
-            foreach (var recordValidator in recordValidators)
+            foreach (var validator in recordValidators)
             {
-                errors.AddRange(recordValidator.Validate(dataRecord));
+                var results = validator.Validate(record);
+                AddErrorsWithCap(results, errors);
+                if (errors.Count >= configuration.MaximumValidationErrors) return;
             }
         }
+    }
+
+    private void AddErrorsWithCap(IEnumerable<ValidationError> newErrors, List<ValidationError> existingErrors)
+    {
+        foreach (var error in newErrors)
+        {
+            if (existingErrors.Count >= configuration.MaximumValidationErrors) break;
+            existingErrors.Add(error);
+        }
+    }
+
+    private List<ValidationError> FinalizeEarly(List<ValidationError> errors)
+    {
+        errors.Add(new ValidationError
+        {
+            Code = ErrorCodes.ValidationAborted,
+            Error = $"Validation aborted after {configuration.MaximumValidationErrors} errors encountered",
+            Scope = ValidationErrorScope.File
+        });
 
         return errors;
     }

src/ServiceLayer.Mesh/ValidationError.cs

@@ -4,7 +4,7 @@ public class ValidationError
 {
     public int? RowNumber { get; set; }
 
-    public required string Field { get; set; }
+    public string? Field { get; set; }
 
     public required string Code { get; set; }
 

src/ServiceLayer.Shared/EnvironmentVariables.cs

@@ -19,4 +19,33 @@ public static string GetRequired(string key)
 
         return value;
     }
+
+    public static int GetRequiredInt(string key)
+    {
+        var value = GetRequired(key);
+
+        if (!int.TryParse(value, out var intValue))
+        {
+            throw new InvalidOperationException($"Environment variable '{key}' is not a valid integer");
+        }
+
+        return intValue;
+    }
+
+    public static int GetOptionalInt(string key, int defaultValue)
+    {
+        var value = Environment.GetEnvironmentVariable(key);
+
+        if (string.IsNullOrWhiteSpace(value))
+        {
+            return defaultValue;
+        }
+
+        if (!int.TryParse(value, out var intValue))
+        {
+            throw new InvalidOperationException($"Environment variable '{key}' is not a valid integer");
+        }
+
+        return intValue;
+    }
 }