Enhance Vector Record Serialization and Deserialization

- Updated VectorRecord and QdrantVectorRecord classes to support AOT compatibility by adding overloads for JSON serialization and deserialization that accept JsonSerializerOptions and JsonTypeInfo.
- Modified the Create methods in both classes to utilize the new serialization options.
- Introduced runtime-configured dimensions and distance functions in PostgresVectorIndexer and QdrantVectorIndexer by creating VectorStoreCollectionDefinition.
- Added a PromptInjectionDetector class to identify potential prompt injection patterns in user input, enhancing security measures.
- Updated SemanticSearchDataSource to log potential injection attempts and sanitize inputs accordingly.
- Improved documentation and comments throughout the code for clarity and security practices.
- Adjusted unit tests to reflect changes in method signatures and added necessary reflection logic for testing.

Author: mashrulhaque

Directory.Build.props

@@ -24,8 +24,8 @@
     <PackageTags>blazor;autocomplete;component;ai;semantic-search;performance;trimming;aot;wcag;accessibility;theming;virtualization</PackageTags>
     <PackageReadmeFile>README.md</PackageReadmeFile>
     <PackageIcon>icon.png</PackageIcon>
-    <Version>1.0.6</Version>
-    <PackageReleaseNotes>Version 1.0.6 - Updated all package READMEs with focused documentation for each package. Added READMEs for vector database providers (PostgreSQL, Azure AI Search, Pinecone, Qdrant, CosmosDB).</PackageReleaseNotes>
+    <Version>1.0.7</Version>
+    <PackageReleaseNotes>Version 1.0.7 - Added AOT-compatible JSON serialization overloads for all vector database providers. Fixed exception handling in GetItem to return default on deserialization failure. Added cancellation token propagation in Azure Search hybrid search. Improved robustness and trimming compatibility.</PackageReleaseNotes>
     <Copyright>Copyright (c) 2025 EasyAppDev</Copyright>
 
     <!-- Documentation -->

src/EasyAppDev.Blazor.AutoComplete.AI.AzureSearch/AzureSearchVectorIndexer.cs

@@ -1,6 +1,8 @@
 using Azure.Search.Documents;
 using Microsoft.Extensions.AI;
+using Microsoft.Extensions.VectorData;
 using Microsoft.SemanticKernel.Connectors.AzureAISearch;
+using VectorDataDistanceFunction = Microsoft.Extensions.VectorData.DistanceFunction;
 using EasyAppDev.Blazor.AutoComplete.AI.Abstractions;
 using EasyAppDev.Blazor.AutoComplete.AI.Models;
 using EasyAppDev.Blazor.AutoComplete.AI.AzureSearch.Models;
@@ -53,7 +55,46 @@ public AzureSearchVectorIndexer(
         _textSelector = textSelector;
         _titleSelector = titleSelector;
         _idSelector = idSelector;
-        _collection = vectorStore.GetCollection<string, AzureSearchVectorRecord>(options.IndexName);
+
+        // Create record definition with runtime-configured dimensions and distance function
+        var definition = CreateRecordDefinition(options);
+        _collection = vectorStore.GetCollection<string, AzureSearchVectorRecord>(options.IndexName, definition);
+    }
+
+    /// <summary>
+    /// Creates a VectorStoreCollectionDefinition with runtime-configured dimensions and distance function.
+    /// This overrides the hardcoded values in the AzureSearchVectorRecord attributes.
+    /// </summary>
+    private static VectorStoreCollectionDefinition CreateRecordDefinition(AzureSearchVectorSearchOptions options)
+    {
+        return new VectorStoreCollectionDefinition
+        {
+            Properties =
+            [
+                new VectorStoreKeyProperty("Id", typeof(string)),
+                new VectorStoreDataProperty("ItemJson", typeof(string)),
+                new VectorStoreDataProperty("Content", typeof(string)),
+                new VectorStoreDataProperty("Title", typeof(string)),
+                new VectorStoreVectorProperty("Embedding", typeof(ReadOnlyMemory<float>), options.EmbeddingDimensions)
+                {
+                    DistanceFunction = MapDistanceFunction(options.DistanceFunction)
+                }
+            ]
+        };
+    }
+
+    /// <summary>
+    /// Maps the library's DistanceFunction enum to Semantic Kernel's DistanceFunction string.
+    /// </summary>
+    private static string MapDistanceFunction(AI.Models.DistanceFunction distanceFunction)
+    {
+        return distanceFunction switch
+        {
+            AI.Models.DistanceFunction.Cosine => VectorDataDistanceFunction.CosineSimilarity,
+            AI.Models.DistanceFunction.Euclidean => VectorDataDistanceFunction.EuclideanDistance,
+            AI.Models.DistanceFunction.DotProduct => VectorDataDistanceFunction.DotProductSimilarity,
+            _ => VectorDataDistanceFunction.CosineSimilarity
+        };
     }
 
     /// <inheritdoc />

src/EasyAppDev.Blazor.AutoComplete.AI.AzureSearch/AzureSearchVectorSearchProvider.cs

@@ -1,6 +1,8 @@
 using Azure.Search.Documents;
 using Azure.Search.Documents.Models;
+using Microsoft.Extensions.VectorData;
 using Microsoft.SemanticKernel.Connectors.AzureAISearch;
+using VectorDataDistanceFunction = Microsoft.Extensions.VectorData.DistanceFunction;
 using EasyAppDev.Blazor.AutoComplete.AI.Abstractions;
 using EasyAppDev.Blazor.AutoComplete.AI.AzureSearch.Models;
 
@@ -38,7 +40,46 @@ public AzureSearchVectorSearchProvider(
 
         _searchClient = searchClient;
         _options = options;
-        _collection = vectorStore.GetCollection<string, AzureSearchVectorRecord>(options.IndexName);
+
+        // Create record definition with runtime-configured dimensions and distance function
+        var definition = CreateRecordDefinition(options);
+        _collection = vectorStore.GetCollection<string, AzureSearchVectorRecord>(options.IndexName, definition);
+    }
+
+    /// <summary>
+    /// Creates a VectorStoreCollectionDefinition with runtime-configured dimensions and distance function.
+    /// This overrides the hardcoded values in the AzureSearchVectorRecord attributes.
+    /// </summary>
+    private static VectorStoreCollectionDefinition CreateRecordDefinition(AzureSearchVectorSearchOptions options)
+    {
+        return new VectorStoreCollectionDefinition
+        {
+            Properties =
+            [
+                new VectorStoreKeyProperty("Id", typeof(string)),
+                new VectorStoreDataProperty("ItemJson", typeof(string)),
+                new VectorStoreDataProperty("Content", typeof(string)),
+                new VectorStoreDataProperty("Title", typeof(string)),
+                new VectorStoreVectorProperty("Embedding", typeof(ReadOnlyMemory<float>), options.EmbeddingDimensions)
+                {
+                    DistanceFunction = MapDistanceFunction(options.DistanceFunction)
+                }
+            ]
+        };
+    }
+
+    /// <summary>
+    /// Maps the library's DistanceFunction enum to Semantic Kernel's DistanceFunction string.
+    /// </summary>
+    private static string MapDistanceFunction(AI.Models.DistanceFunction distanceFunction)
+    {
+        return distanceFunction switch
+        {
+            AI.Models.DistanceFunction.Cosine => VectorDataDistanceFunction.CosineSimilarity,
+            AI.Models.DistanceFunction.Euclidean => VectorDataDistanceFunction.EuclideanDistance,
+            AI.Models.DistanceFunction.DotProduct => VectorDataDistanceFunction.DotProductSimilarity,
+            _ => VectorDataDistanceFunction.CosineSimilarity
+        };
     }
 
     /// <inheritdoc />
@@ -141,7 +182,9 @@ public AzureSearchVectorSearchProvider(
 
         var results = new List<AI.Models.VectorSearchResult<TItem>>();
 
-        await foreach (var result in response.Value.GetResultsAsync().ConfigureAwait(false))
+        await foreach (var result in response.Value.GetResultsAsync()
+            .WithCancellation(cancellationToken)
+            .ConfigureAwait(false))
         {
             var score = (float)(result.Score ?? 0);
 

src/EasyAppDev.Blazor.AutoComplete.AI.AzureSearch/EasyAppDev.Blazor.AutoComplete.AI.AzureSearch.csproj

@@ -32,6 +32,7 @@
   <ItemGroup>
     <!-- Semantic Kernel Azure AI Search connector (prerelease) -->
     <PackageReference Include="Microsoft.SemanticKernel.Connectors.AzureAISearch" Version="*-*" />
+    <PackageReference Include="Microsoft.Extensions.VectorData.Abstractions" Version="9.*-*" />
     <PackageReference Include="Azure.Search.Documents" Version="11.*" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="8.0.0" Condition="'$(TargetFramework)' == 'net8.0'" />
     <PackageReference Include="Microsoft.Extensions.Configuration.Binder" Version="9.0.0" Condition="'$(TargetFramework)' == 'net9.0'" />

src/EasyAppDev.Blazor.AutoComplete.AI.AzureSearch/Models/AzureSearchVectorRecord.cs

@@ -1,4 +1,5 @@
 using System.Text.Json;
+using System.Text.Json.Serialization.Metadata;
 using Microsoft.Extensions.VectorData;
 
 namespace EasyAppDev.Blazor.AutoComplete.AI.AzureSearch.Models;
@@ -8,6 +9,10 @@ namespace EasyAppDev.Blazor.AutoComplete.AI.AzureSearch.Models;
 /// The TItem is serialized as JSON for flexible storage.
 /// Note: Must be public for Azure Search SDK JSON serialization to work.
 /// </summary>
+/// <remarks>
+/// For AOT compatibility, use the overloads that accept <see cref="JsonSerializerOptions"/>
+/// or <see cref="JsonTypeInfo{T}"/> with a source-generated context.
+/// </remarks>
 public sealed class AzureSearchVectorRecord
 {
     /// <summary>
@@ -36,7 +41,7 @@ public sealed class AzureSearchVectorRecord
 
     /// <summary>
     /// The embedding vector.
-    /// Dimensions are configured at runtime.
+    /// Dimensions are configured at runtime via VectorStoreCollectionDefinition.
     /// </summary>
     [VectorStoreVector(Dimensions: 1536, DistanceFunction = DistanceFunction.CosineSimilarity)]
     public required ReadOnlyMemory<float> Embedding { get; init; }
@@ -45,13 +50,73 @@ public sealed class AzureSearchVectorRecord
     /// Deserializes the item from JSON.
     /// </summary>
     /// <typeparam name="TItem">The item type to deserialize to.</typeparam>
-    /// <returns>The deserialized item, or null if deserialization fails.</returns>
+    /// <returns>The deserialized item, or default if deserialization fails.</returns>
+    /// <remarks>
+    /// This method uses reflection-based deserialization and is NOT AOT-compatible.
+    /// For AOT scenarios, use <see cref="GetItem{TItem}(JsonSerializerOptions)"/> or
+    /// <see cref="GetItem{TItem}(JsonTypeInfo{TItem})"/> instead.
+    /// </remarks>
     public TItem? GetItem<TItem>()
+    {
+        return GetItemCore<TItem>(null, null);
+    }
+
+    /// <summary>
+    /// Deserializes the item from JSON using the specified options.
+    /// </summary>
+    /// <typeparam name="TItem">The item type to deserialize to.</typeparam>
+    /// <param name="options">JSON serializer options with a configured TypeInfoResolver for AOT compatibility.</param>
+    /// <returns>The deserialized item, or default if deserialization fails.</returns>
+    /// <remarks>
+    /// For AOT compatibility, configure options with a source-generated JsonSerializerContext:
+    /// <code>
+    /// var options = new JsonSerializerOptions { TypeInfoResolver = MyJsonContext.Default };
+    /// var item = record.GetItem&lt;MyType&gt;(options);
+    /// </code>
+    /// </remarks>
+    public TItem? GetItem<TItem>(JsonSerializerOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        return GetItemCore<TItem>(options, null);
+    }
+
+    /// <summary>
+    /// Deserializes the item from JSON using the specified type info.
+    /// </summary>
+    /// <typeparam name="TItem">The item type to deserialize to.</typeparam>
+    /// <param name="jsonTypeInfo">The JSON type info from a source-generated context.</param>
+    /// <returns>The deserialized item, or default if deserialization fails.</returns>
+    /// <remarks>
+    /// This is the preferred method for AOT-compatible deserialization:
+    /// <code>
+    /// var item = record.GetItem(MyJsonContext.Default.MyType);
+    /// </code>
+    /// </remarks>
+    public TItem? GetItem<TItem>(JsonTypeInfo<TItem> jsonTypeInfo)
+    {
+        ArgumentNullException.ThrowIfNull(jsonTypeInfo);
+        return GetItemCore<TItem>(null, jsonTypeInfo);
+    }
+
+    private TItem? GetItemCore<TItem>(JsonSerializerOptions? options, JsonTypeInfo<TItem>? jsonTypeInfo)
     {
         if (string.IsNullOrEmpty(ItemJson))
             return default;
 
-        return JsonSerializer.Deserialize<TItem>(ItemJson);
+        try
+        {
+            if (jsonTypeInfo is not null)
+                return JsonSerializer.Deserialize(ItemJson, jsonTypeInfo);
+
+            if (options is not null)
+                return JsonSerializer.Deserialize<TItem>(ItemJson, options);
+
+            return JsonSerializer.Deserialize<TItem>(ItemJson);
+        }
+        catch (JsonException)
+        {
+            return default;
+        }
     }
 
     /// <summary>
@@ -64,17 +129,94 @@ public sealed class AzureSearchVectorRecord
     /// <param name="title">Optional title for filtering.</param>
     /// <param name="embedding">The embedding vector.</param>
     /// <returns>A new AzureSearchVectorRecord instance.</returns>
+    /// <remarks>
+    /// This method uses reflection-based serialization and is NOT AOT-compatible.
+    /// For AOT scenarios, use <see cref="Create{TItem}(string, TItem, string, string?, ReadOnlyMemory{float}, JsonSerializerOptions)"/>
+    /// or <see cref="Create{TItem}(string, TItem, string, string?, ReadOnlyMemory{float}, JsonTypeInfo{TItem})"/> instead.
+    /// </remarks>
     public static AzureSearchVectorRecord Create<TItem>(
         string id,
         TItem item,
         string content,
         string? title,
         ReadOnlyMemory<float> embedding)
     {
+        return CreateCore(id, item, content, title, embedding, null, null);
+    }
+
+    /// <summary>
+    /// Creates an AzureSearchVectorRecord from an item using the specified options.
+    /// </summary>
+    /// <typeparam name="TItem">The item type.</typeparam>
+    /// <param name="id">Unique identifier.</param>
+    /// <param name="item">The item to store.</param>
+    /// <param name="content">Text content for full-text search.</param>
+    /// <param name="title">Optional title for filtering.</param>
+    /// <param name="embedding">The embedding vector.</param>
+    /// <param name="options">JSON serializer options with a configured TypeInfoResolver for AOT compatibility.</param>
+    /// <returns>A new AzureSearchVectorRecord instance.</returns>
+    public static AzureSearchVectorRecord Create<TItem>(
+        string id,
+        TItem item,
+        string content,
+        string? title,
+        ReadOnlyMemory<float> embedding,
+        JsonSerializerOptions options)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        return CreateCore(id, item, content, title, embedding, options, null);
+    }
+
+    /// <summary>
+    /// Creates an AzureSearchVectorRecord from an item using the specified type info.
+    /// </summary>
+    /// <typeparam name="TItem">The item type.</typeparam>
+    /// <param name="id">Unique identifier.</param>
+    /// <param name="item">The item to store.</param>
+    /// <param name="content">Text content for full-text search.</param>
+    /// <param name="title">Optional title for filtering.</param>
+    /// <param name="embedding">The embedding vector.</param>
+    /// <param name="jsonTypeInfo">The JSON type info from a source-generated context.</param>
+    /// <returns>A new AzureSearchVectorRecord instance.</returns>
+    /// <remarks>
+    /// This is the preferred method for AOT-compatible serialization:
+    /// <code>
+    /// var record = AzureSearchVectorRecord.Create(id, item, content, title, embedding, MyJsonContext.Default.MyType);
+    /// </code>
+    /// </remarks>
+    public static AzureSearchVectorRecord Create<TItem>(
+        string id,
+        TItem item,
+        string content,
+        string? title,
+        ReadOnlyMemory<float> embedding,
+        JsonTypeInfo<TItem> jsonTypeInfo)
+    {
+        ArgumentNullException.ThrowIfNull(jsonTypeInfo);
+        return CreateCore(id, item, content, title, embedding, null, jsonTypeInfo);
+    }
+
+    private static AzureSearchVectorRecord CreateCore<TItem>(
+        string id,
+        TItem item,
+        string content,
+        string? title,
+        ReadOnlyMemory<float> embedding,
+        JsonSerializerOptions? options,
+        JsonTypeInfo<TItem>? jsonTypeInfo)
+    {
+        string itemJson;
+        if (jsonTypeInfo is not null)
+            itemJson = JsonSerializer.Serialize(item, jsonTypeInfo);
+        else if (options is not null)
+            itemJson = JsonSerializer.Serialize(item, options);
+        else
+            itemJson = JsonSerializer.Serialize(item);
+
         return new AzureSearchVectorRecord
         {
             Id = id,
-            ItemJson = JsonSerializer.Serialize(item),
+            ItemJson = itemJson,
             Content = content,
             Title = title,
             Embedding = embedding