Feature json schema

Directory.Packages.props

@@ -90,6 +90,7 @@
     <PackageVersion Include="Nito.AsyncEx.Coordination" Version="5.1.2" />
     <PackageVersion Include="NLog" Version="5.5.1" />
     <PackageVersion Include="NLog.Web.AspNetCore" Version="5.5.0" />
+    <PackageVersion Include="NJsonSchema" Version="11.3.2" />
     <PackageVersion Include="NodaTime" Version="3.2.2" />
     <PackageVersion Include="Npgsql" Version="9.0.4" />
     <PackageVersion Include="NuGet.Commands" Version="7.0.1" />

src/Raven.Client/Documents/Operations/SchemaValidation/ConfigureSchemaValidationOperation.cs

@@ -0,0 +1,65 @@
+using System;
+using System.Net.Http;
+using Raven.Client.Documents.Conventions;
+using Raven.Client.Http;
+using Raven.Client.Json;
+using Raven.Client.Json.Serialization;
+using Raven.Client.Util;
+using Sparrow.Json;
+
+namespace Raven.Client.Documents.Operations.SchemaValidation;
+
+public class ConfigureSchemaValidationOperation : IMaintenanceOperation<ConfigureSchemaValidationOperationResult>
+{
+    private readonly SchemaValidationConfiguration _configuration;
+
+    /// <inheritdoc cref="ConfigureSchemaValidationOperation"/>
+    /// <param name="configuration">The schema validation configuration to apply.</param>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="configuration"/> is null.</exception>
+    public ConfigureSchemaValidationOperation(SchemaValidationConfiguration configuration)
+    {
+        _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+    }
+
+    public RavenCommand<ConfigureSchemaValidationOperationResult> GetCommand(DocumentConventions conventions, JsonOperationContext ctx)
+    {
+        return new ConfigureSchemaValidationCommand(conventions, _configuration);
+    }
+
+    private class ConfigureSchemaValidationCommand : RavenCommand<ConfigureSchemaValidationOperationResult>, IRaftCommand
+    {
+        private readonly DocumentConventions _conventions;
+        private readonly SchemaValidationConfiguration _configuration;
+
+        public ConfigureSchemaValidationCommand(DocumentConventions conventions, SchemaValidationConfiguration configuration)
+        {
+            _conventions = conventions ?? throw new ArgumentNullException(nameof(conventions));
+            _configuration = configuration ?? throw new ArgumentNullException(nameof(configuration));
+        }
+
+        public override bool IsReadRequest => false;
+
+        public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
+        {
+            url = $"{node.Url}/databases/{node.Database}/admin/schema-validation/config";
+
+            var request = new HttpRequestMessage
+            {
+                Method = HttpMethod.Post,
+                Content = new BlittableJsonContent(async stream => await ctx.WriteAsync(stream, DocumentConventions.Default.Serialization.DefaultConverter.ToBlittable(_configuration, ctx)).ConfigureAwait(false), _conventions)
+            };
+
+            return request;
+        }
+
+        public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache)
+        {
+            if (response == null)
+                ThrowInvalidResponse();
+
+            Result = JsonDeserializationClient.ConfigureSchemaValidationOperationResult(response);
+        }
+
+        public string RaftUniqueRequestId { get; } = RaftIdGenerator.NewId();
+    }
+}

src/Raven.Client/Documents/Operations/SchemaValidation/ConfigureSchemaValidationOperationResult.cs

@@ -0,0 +1,6 @@
+namespace Raven.Client.Documents.Operations.SchemaValidation;
+
+public class ConfigureSchemaValidationOperationResult
+{
+    public long? RaftCommandIndex { get; set; }
+}

src/Raven.Client/Documents/Operations/SchemaValidation/GetSchemaValidationConfiguration.cs

@@ -0,0 +1,40 @@
+using System.Net.Http;
+using Raven.Client.Documents.Conventions;
+using Raven.Client.Http;
+using Raven.Client.Json.Serialization;
+using Sparrow.Json;
+
+namespace Raven.Client.Documents.Operations.SchemaValidation;
+
+public sealed class GetSchemaValidationConfiguration : IMaintenanceOperation<GetSchemaValidationConfigurationResult>
+{
+    public RavenCommand<GetSchemaValidationConfigurationResult> GetCommand(DocumentConventions conventions, JsonOperationContext context)
+    {
+        return new GetSchemaValidationCommand();
+    }
+
+    internal sealed class GetSchemaValidationCommand : RavenCommand<GetSchemaValidationConfigurationResult>
+    {
+        public override bool IsReadRequest => true;
+
+        public override HttpRequestMessage CreateRequest(JsonOperationContext ctx, ServerNode node, out string url)
+        {
+            url = $"{node.Url}/databases/{node.Database}/schema-validation/config";
+
+            var request = new HttpRequestMessage
+            {
+                Method = HttpMethod.Get
+            };
+
+            return request;
+        }
+
+        public override void SetResponse(JsonOperationContext context, BlittableJsonReaderObject response, bool fromCache)
+        {
+            if (response == null)
+                return;
+
+            Result = JsonDeserializationClient.GetSchemaValidationConfiguration(response);
+        }
+    }
+}

src/Raven.Client/Documents/Operations/SchemaValidation/GetSchemaValidationConfigurationResult.cs

@@ -0,0 +1,6 @@
+namespace Raven.Client.Documents.Operations.SchemaValidation;
+
+public sealed class GetSchemaValidationConfigurationResult
+{
+    public SchemaValidationConfiguration Configuration { get; set; }
+}

src/Raven.Client/Documents/Operations/SchemaValidation/SchemaDefinition.cs

@@ -0,0 +1,23 @@
+using System;
+using Sparrow.Json.Parsing;
+
+namespace Raven.Client.Documents.Operations.SchemaValidation;
+
+public class SchemaDefinition
+{
+    public bool Disabled { get; set; }
+
+    public string Schema { get; set; }
+
+    public DateTime LastModifiedTime { get; } = DateTime.UtcNow;
+
+    public DynamicJsonValue ToJson()
+    {
+        return new DynamicJsonValue
+        {
+            [nameof(Disabled)] = Disabled,
+            [nameof(Schema)] = Schema,
+            [nameof(LastModifiedTime)] = LastModifiedTime
+        };
+    }
+}

src/Raven.Client/Documents/Operations/SchemaValidation/SchemaValidationConfiguration.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using Sparrow.Json.Parsing;
+
+namespace Raven.Client.Documents.Operations.SchemaValidation;
+
+public sealed class SchemaValidationConfiguration
+{
+    private Dictionary<string, SchemaDefinition> _validatorsPerCollection;
+
+    public bool Disabled { get; set; }
+
+    public Dictionary<string, SchemaDefinition> ValidatorsPerCollection
+    {
+        get => _validatorsPerCollection;
+        set => _validatorsPerCollection = new Dictionary<string, SchemaDefinition>(value, StringComparer.OrdinalIgnoreCase);
+    }
+
+    public DynamicJsonValue ToJson()
+    {
+        DynamicJsonValue validatorsPerCollection = null;
+        if (ValidatorsPerCollection != null)
+        {
+            validatorsPerCollection = new DynamicJsonValue();
+            foreach (var validator in ValidatorsPerCollection)
+            {
+                validatorsPerCollection[validator.Key] = validator.Value.ToJson();
+            }
+        }
+
+        return new DynamicJsonValue
+        {
+            [nameof(Disabled)] = Disabled,
+            [nameof(ValidatorsPerCollection)] = validatorsPerCollection
+        };
+    }
+}

src/Raven.Client/Documents/Smuggler/DatabaseItemType.cs

@@ -68,5 +68,6 @@ public enum DatabaseRecordItemType : long
         AiConnectionStrings = 1L << 33,
         GenAiEtls = 1L << 34,
         AiAgents = 1L << 35,
+        SchemaValidation = 1L << 36
     }
 }

src/Raven.Client/Documents/Smuggler/DatabaseSmugglerOptions.cs

@@ -54,7 +54,8 @@ public class DatabaseSmugglerOptions : IDatabaseSmugglerOptions
                                                                                   DatabaseRecordItemType.EmbeddingsGenerations |
                                                                                   DatabaseRecordItemType.AiConnectionStrings |
                                                                                   DatabaseRecordItemType.GenAiEtls |
-                                                                                  DatabaseRecordItemType.AiAgents;
+                                                                                  DatabaseRecordItemType.AiAgents |
+                                                                                  DatabaseRecordItemType.SchemaValidation;
 
         internal const DatabaseItemType OperateOnFirstShardOnly = DatabaseItemType.Indexes |
                                                               DatabaseItemType.DatabaseRecord |

src/Raven.Client/Documents/Smuggler/SmugglerProgressBase.cs

@@ -95,6 +95,8 @@ public sealed class DatabaseRecordProgress : Counts
 
         public bool ConflictSolverConfigUpdated { get; set; }
 
+        public bool SchemaValidationConfigUpdated { get; set; }
+
         public bool TimeSeriesConfigurationUpdated { get; set; }
 
         public bool DocumentsCompressionConfigurationUpdated { get; set; }
@@ -184,6 +186,9 @@ public override DynamicJsonValue ToJson()
             if (ConflictSolverConfigUpdated)
                 json[nameof(ConflictSolverConfigUpdated)] = ConflictSolverConfigUpdated;
 
+            if (SchemaValidationConfigUpdated)
+                json[nameof(SchemaValidationConfigUpdated)] = SchemaValidationConfigUpdated;
+
             if (PeriodicBackupsUpdated)
                 json[nameof(PeriodicBackupsUpdated)] = PeriodicBackupsUpdated;
 
@@ -286,6 +291,9 @@ public override string ToString()
             if (ConflictSolverConfigUpdated)
                 sb.AppendLine("- Conflicts Solvers");
 
+            if (SchemaValidationConfigUpdated)
+                sb.AppendLine("- Schema Validation Configurations");
+
             if (PeriodicBackupsUpdated)
                 sb.AppendLine("- Periodic Backups");
 

src/Raven.Client/Exceptions/SchemaValidation/SchemaValidationException.cs

@@ -0,0 +1,12 @@
+namespace Raven.Client.Exceptions.SchemaValidation;
+
+public class SchemaValidationException : RavenException
+{
+    /// <summary>
+    /// Initializes a new instance of the <see cref="SchemaValidationException"/> class.
+    /// </summary>
+    /// <param name="message">The message.</param>
+    public SchemaValidationException(string message) : base(message)
+    {
+    }
+}

src/Raven.Client/Json/Serialization/JsonDeserializationClient.cs

@@ -30,6 +30,7 @@
 using Raven.Client.Documents.Operations.Refresh;
 using Raven.Client.Documents.Operations.Replication;
 using Raven.Client.Documents.Operations.Revisions;
+using Raven.Client.Documents.Operations.SchemaValidation;
 using Raven.Client.Documents.Operations.TimeSeries;
 using Raven.Client.Documents.Operations.TransactionsRecording;
 using Raven.Client.Documents.Queries;
@@ -198,6 +199,8 @@ internal sealed class JsonDeserializationClient : JsonDeserializationBase
         internal static readonly Func<BlittableJsonReaderObject, ConfigureRevisionsBinCleanerOperationResult> ConfigureRevisionsBinCleanerOperationResult = GenerateJsonDeserializationRoutine<ConfigureRevisionsBinCleanerOperationResult>();
 
         internal static readonly Func<BlittableJsonReaderObject, ConfigureDataArchivalOperationResult> ConfigureDataArchivalOperationResult = GenerateJsonDeserializationRoutine<ConfigureDataArchivalOperationResult>();
+
+        internal static readonly Func<BlittableJsonReaderObject, ConfigureSchemaValidationOperationResult> ConfigureSchemaValidationOperationResult = GenerateJsonDeserializationRoutine<ConfigureSchemaValidationOperationResult>();
 
         internal static readonly Func<BlittableJsonReaderObject, DocumentCompressionConfigurationResult> DocumentCompressionConfigurationOperationResult = GenerateJsonDeserializationRoutine<DocumentCompressionConfigurationResult>();
 
@@ -270,7 +273,7 @@ internal sealed class JsonDeserializationClient : JsonDeserializationBase
         internal static readonly Func<BlittableJsonReaderObject, GetClientConfigurationOperation.Result> ClientConfigurationResult = GenerateJsonDeserializationRoutine<GetClientConfigurationOperation.Result>();
 
         internal static readonly Func<BlittableJsonReaderObject, ConflictSolver> ConflictSolverConfiguration = GenerateJsonDeserializationRoutine<ConflictSolver>();
-
+        
         internal static readonly Func<BlittableJsonReaderObject, S3Settings> S3Settings = GenerateJsonDeserializationRoutine<S3Settings>();
 
         internal static readonly Func<BlittableJsonReaderObject, GlacierSettings> GlacierSettings = GenerateJsonDeserializationRoutine<GlacierSettings>();
@@ -297,7 +300,9 @@ internal sealed class JsonDeserializationClient : JsonDeserializationBase
         internal static readonly Func<BlittableJsonReaderObject, GetRevisionsCountOperation.DocumentRevisionsCount> DocumentRevisionsCount = GenerateJsonDeserializationRoutine<GetRevisionsCountOperation.DocumentRevisionsCount>();
 
         internal static readonly Func<BlittableJsonReaderObject, DatabaseSettings> DatabaseSettings = GenerateJsonDeserializationRoutine<DatabaseSettings>();
-
+
+        internal static readonly Func<BlittableJsonReaderObject, GetSchemaValidationConfigurationResult> GetSchemaValidationConfiguration = GenerateJsonDeserializationRoutine<GetSchemaValidationConfigurationResult>();
+
         public static readonly Func<BlittableJsonReaderObject, PutTrafficWatchConfigurationOperation.Parameters> GetTrafficWatchConfigurationResult = GenerateJsonDeserializationRoutine<PutTrafficWatchConfigurationOperation.Parameters>();
 
         internal static readonly Func<BlittableJsonReaderObject, ConfigurePostgreSqlOperationResult> ConfigurePostgreSqlOperationResult = GenerateJsonDeserializationRoutine<ConfigurePostgreSqlOperationResult>();
@@ -341,7 +346,6 @@ internal sealed class JsonDeserializationClient : JsonDeserializationBase
         public static readonly Func<BlittableJsonReaderObject, EmbeddingsGeneration> GetOngoingTaskEmbeddingsGenerationResult = GenerateJsonDeserializationRoutine<EmbeddingsGeneration>();
 
         public static readonly Func<BlittableJsonReaderObject, GenAi> GetOngoingTaskGenAiResult = GenerateJsonDeserializationRoutine<GenAi>();
-
         public static readonly Func<BlittableJsonReaderObject, AiAgentConfiguration> AiAgentConfiguration = GenerateJsonDeserializationRoutine<AiAgentConfiguration>();
 
         public static readonly Func<BlittableJsonReaderObject, GetAiAgentsResponse> GetAiAgentsResponse = GenerateJsonDeserializationRoutine<GetAiAgentsResponse>();

src/Raven.Client/ServerWide/DatabaseRecord.cs

@@ -21,6 +21,7 @@
 using Raven.Client.Documents.Operations.Refresh;
 using Raven.Client.Documents.Operations.Replication;
 using Raven.Client.Documents.Operations.Revisions;
+using Raven.Client.Documents.Operations.SchemaValidation;
 using Raven.Client.Documents.Operations.TimeSeries;
 using Raven.Client.Documents.Queries.Sorting;
 using Raven.Client.Exceptions.Documents.Indexes;
@@ -76,6 +77,8 @@ public DatabaseRecord(string databaseName)
 
         public ConflictSolver ConflictSolverConfig;
 
+        public SchemaValidationConfiguration SchemaValidation;
+
         public DocumentsCompressionConfiguration DocumentsCompression;
 
         public Dictionary<string, SorterDefinition> Sorters = new Dictionary<string, SorterDefinition>();

src/Raven.Server/Documents/DocumentDatabase.cs

@@ -70,10 +70,8 @@
 using MountPointUsage = Raven.Client.ServerWide.Operations.MountPointUsage;
 using Size = Raven.Client.Util.Size;
 using System.Diagnostics.CodeAnalysis;
-using Raven.Server.Documents.AI;
 using Raven.Server.Documents.AI.Embeddings;
-using Raven.Server.Logging;
-using Raven.Server.Rachis;
+using Raven.Server.Documents.SchemaValidation;
 using Sparrow.Server.Logging;
 using Sparrow.Server.Utils;
 
@@ -311,6 +309,8 @@ internal virtual void SetIds(DatabaseTopology topology, string shardedDatabaseId
 
         public PeriodicBackupRunner PeriodicBackupRunner { get; private set; }
 
+        public SchemaValidatorCache SchemaValidatorCache { get; private set; }
+
         public TombstoneCleaner TombstoneCleaner { get; private set; }
 
         public RevisionsBinCleaner RevisionsBinCleaner { get; set; }
@@ -446,6 +446,7 @@ record = _serverStore.Cluster.ReadDatabase(context, Name, out index);
 
                 ReplicationLoader = CreateReplicationLoader();
                 PeriodicBackupRunner = new PeriodicBackupRunner(this, _serverStore, wakeup);
+                SchemaValidatorCache = new SchemaValidatorCache(DocumentsStorage.ContextPool, Loggers.GetLogger<SchemaValidatorCache>());
 
                 _addToInitLog(LogLevel.Debug, "Initializing IndexStore (async)");
                 _indexStoreTask = IndexStore.InitializeAsync(record, index, _addToInitLog);
@@ -1241,6 +1242,13 @@ private void DisposeBackgroundWorkers(ExceptionAggregator exceptionAggregator)
             });
             ForTestingPurposes?.DisposeLog?.Invoke(Name, "Disposed PeriodicBackupRunner");
 
+            ForTestingPurposes?.DisposeLog?.Invoke(Name, "Disposing SchemaValidatorCache");
+            exceptionAggregator.Execute(() =>
+            {
+                SchemaValidatorCache?.Dispose();
+            });
+            ForTestingPurposes?.DisposeLog?.Invoke(Name, "Disposed SchemaValidatorCache");
+
             ForTestingPurposes?.DisposeLog?.Invoke(Name, "Disposing TombstoneCleaner");
             exceptionAggregator.Execute(() =>
             {
@@ -1739,6 +1747,7 @@ public async Task UpdateOnStateChange(DatabaseRecord record, long index)
             try
             {
                 PeriodicBackupRunner?.UpdateConfigurations(record.PeriodicBackups);
+                SchemaValidatorCache?.Update(record.SchemaValidation);
                 EmbeddingsGeneratorQueries?.HandleDatabaseRecordChange(record);
                 EmbeddingsGeneratorEtl?.HandleDatabaseRecordChange(record);
                 EtlLoader?.HandleDatabaseRecordChange(record);

src/Raven.Server/Documents/DocumentPutAction.cs

@@ -133,7 +133,9 @@ public PutOperationResults PutDocument(DocumentsOperationContext context, string
 
                 var collectionName = _documentsStorage.ExtractCollectionName(context, document);
                 _documentsStorage._forTestingPurposes?.OnBeforeOpenTableWhenPutDocumentWithSpecificId?.Invoke(id);
-
+
+                _documentDatabase.SchemaValidatorCache?.Validate(collectionName.Name, document, nonPersistentFlags, context);
+
                 var table = context.Transaction.InnerTransaction.OpenTable(_documentDatabase.GetDocsSchemaForCollection(collectionName, newFlags), collectionName.GetTableName(CollectionTableType.Documents));
 
                 var oldValue = default(TableValueReader);

src/Raven.Server/Documents/Handlers/Debugging/ServerWideDebugInfoPackageHandler.cs

@@ -65,6 +65,7 @@ public sealed class ServerWideDebugInfoPackageHandler : ServerRequestHandler
             nameof(DatabaseRecord.Analyzers),
             nameof(DatabaseRecord.TimeSeries),
             nameof(DatabaseRecord.SupportedFeatures),
+            nameof(DatabaseRecord.SchemaValidation),
 
             nameof(DatabaseRecord.Sharding),
             nameof(DatabaseRecord.RevisionsBin),