fix: CI failures — remove unnecessary System.Text.Json ref, fix frontend lint, address PR code quality feedback

- Remove System.Text.Json PackageReference (NU1510 warning-as-error in .NET 10 CI)
- Fix ESLint errors: perfectionist import/export ordering, curly braces, escape chars,
  svelte/require-each-key across custom-fields and event components
- Fix prettier formatting in custom-fields Svelte/TS files
- PersistentEvent.GetCustomFields(): use LINQ Where, return DataDictionary (Copilot feedback)
- EventCustomFieldService: filter before foreach loop (CodeQL Where suggestion),
  narrow catch clauses to non-cancellation exceptions and typed conversion errors
- OrganizationMaintenanceWorkItemHandler: narrow catch to non-cancellation exceptions
- Fix ref.session query resolution: system fields use deterministic slots without tenant context
- Regenerate OpenAPI baseline for CustomFieldDefinitionResponse DTO changes

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: niemyjski

src/Exceptionless.Core/Exceptionless.Core.csproj

@@ -40,7 +40,4 @@
       Condition="'$(ReferenceFoundatioRepositoriesSource)' == 'true'" />
   </ItemGroup>
 
-  <ItemGroup Label="Transitive dependency updates to resolve vulnerability warnings">
-    <PackageReference Include="System.Text.Json" Version="9.0.1" />
-  </ItemGroup>
 </Project>

src/Exceptionless.Core/Jobs/WorkItemHandlers/OrganizationMaintenanceWorkItemHandler.cs

@@ -64,7 +64,7 @@ public override async Task HandleItemAsync(WorkItemContext context)
                     {
                         await _eventCustomFieldService.EnsureSystemFieldsAsync(organization.Id);
                     }
-                    catch (Exception ex)
+                    catch (Exception ex) when (ex is not OperationCanceledException)
                     {
                         Log.LogError(ex, "Error ensuring system custom fields for organization {OrganizationId}", organization.Id);
                     }

src/Exceptionless.Core/Models/PersistentEvent.cs

@@ -60,11 +60,11 @@ public class PersistentEvent : Event, IOwnedByOrganizationAndProjectAndStackWith
 
     public IDictionary<string, object?> GetCustomFields()
     {
+        if (Data is null) return new DataDictionary();
         var result = new Dictionary<string, object?>(StringComparer.OrdinalIgnoreCase);
-        if (Data is null) return result;
-        foreach (var kvp in Data)
+        foreach (var kvp in Data.Where(kvp => !String.IsNullOrEmpty(kvp.Key)
+            && (!kvp.Key.StartsWith('@') || kvp.Key.StartsWith("@ref:", StringComparison.OrdinalIgnoreCase))))
         {
-            if (String.IsNullOrEmpty(kvp.Key) || kvp.Key.StartsWith('@')) continue;
             if (kvp.Value is string or bool or int or long or float or double or decimal or DateTime or DateTimeOffset)
                 result[kvp.Key] = kvp.Value;
         }

src/Exceptionless.Core/Repositories/Configuration/ExceptionlessElasticConfiguration.cs

@@ -50,7 +50,6 @@ ILoggerFactory loggerFactory
         AddIndex(Tokens = new TokenIndex(this));
         AddIndex(Users = new UserIndex(this));
         AddIndex(WebHooks = new WebHookIndex(this));
-        AddCustomFieldIndex(_appOptions.ElasticsearchOptions.ScopePrefix + "customfields", appOptions.ElasticsearchOptions.NumberOfReplicas);
     }
 
     public Task RunAsync(CancellationToken shutdownToken = default)

src/Exceptionless.Core/Repositories/Configuration/Indexes/EventIndex.cs

@@ -26,8 +26,6 @@ public EventIndex(ExceptionlessElasticConfiguration configuration, IServiceProvi
         _configuration = configuration;
         _serviceProvider = serviceProvider;
 
-        AddStandardCustomFieldTypes();
-
         if (appOptions.MaximumRetentionDays > 0)
             MaxIndexAge = TimeSpan.FromDays(appOptions.MaximumRetentionDays);
 

src/Exceptionless.Core/Repositories/EventRepository.cs

@@ -16,12 +16,17 @@ namespace Exceptionless.Core.Repositories;
 
 public class EventRepository : RepositoryOwnedByOrganizationAndProject<PersistentEvent>, IEventRepository
 {
+    private const string LegacySessionEndIdxField = "sessionend-d";
     private readonly TimeProvider _timeProvider;
+    private readonly IProjectRepository _projectRepository;
+    private readonly IStackRepository _stackRepository;
 
-    public EventRepository(ExceptionlessElasticConfiguration configuration, AppOptions options, MiniValidationValidator validator)
+    public EventRepository(ExceptionlessElasticConfiguration configuration, AppOptions options, MiniValidationValidator validator, IProjectRepository projectRepository, IStackRepository stackRepository)
         : base(configuration.Events, validator, options)
     {
         _timeProvider = configuration.TimeProvider;
+        _projectRepository = projectRepository;
+        _stackRepository = stackRepository;
 
         DisableCache(); // NOTE: If cache is ever enabled, then fast paths for patching/deleting with scripts will be super slow!
         BatchNotifications = true;
@@ -38,7 +43,9 @@ public EventRepository(ExceptionlessElasticConfiguration configuration, AppOptio
 
     public Task<FindResults<PersistentEvent>> GetOpenSessionsAsync(DateTime createdBeforeUtc, CommandOptionsDescriptor<PersistentEvent>? options = null)
     {
-        var filter = Query<PersistentEvent>.Term(e => e.Type, Event.KnownTypes.Session) && !Query<PersistentEvent>.Exists(f => f.Field(e => e.Idx![EventCustomFieldService.SessionEndIdxField]));
+        var filter = Query<PersistentEvent>.Term(e => e.Type, Event.KnownTypes.Session)
+            && !Query<PersistentEvent>.Exists(f => f.Field(e => e.Idx![EventCustomFieldService.SessionEndIdxField]))
+            && !Query<PersistentEvent>.Exists(f => f.Field($"idx.{LegacySessionEndIdxField}"));
         if (createdBeforeUtc.Ticks > 0)
             filter &= Query<PersistentEvent>.DateRange(r => r.Field(e => e.Date).LessThanOrEquals(createdBeforeUtc));
 
@@ -67,7 +74,7 @@ public Task<long> RemoveAllAsync(string organizationId, string? clientIpAddress,
 
         var query = new RepositoryQuery<PersistentEvent>().Organization(organizationId);
         if (utcStart.HasValue && utcEnd.HasValue)
-            query = query.DateRange(utcStart, utcEnd, InferField(e => e.Date)).Index(utcStart, utcEnd);
+            query = query.DateRange(utcStart, utcEnd, InferField(e => e.Date));
         else if (utcEnd.HasValue)
             query = query.ElasticFilter(Query<PersistentEvent>.DateRange(r => r.Field(e => e.Date).LessThan(utcEnd)));
         else if (utcStart.HasValue)
@@ -218,33 +225,83 @@ protected override Task OnCustomFieldsDocumentsChanging(object sender, Documents
 
     /// <summary>
     /// Custom field query resolution: resolves idx.fieldName and data.fieldName to idx.{type}-{slot}.
-    /// Returns null for unrecognized fields so the global resolver (field aliases) still works.
+    /// Blocks raw slot access (e.g., idx.keyword-7) to prevent querying deleted or other tenants' fields.
+    /// Returns null for non-idx/data fields so the global resolver (field aliases) still works.
     /// </summary>
+    // Well-known system field slot mappings (deterministic — always slot 1 for each type).
+    private static readonly Dictionary<string, string> _systemFieldSlots = new(StringComparer.OrdinalIgnoreCase)
+    {
+        ["@ref:session"] = EventCustomFieldService.SessionReferenceIdxField,
+        [Event.KnownDataKeys.SessionEnd] = EventCustomFieldService.SessionEndIdxField,
+        [Event.KnownDataKeys.SessionHasError] = EventCustomFieldService.SessionHasErrorIdxField,
+    };
+
     protected override async Task OnCustomFieldsBeforeQuery(object sender, BeforeQueryEventArgs<PersistentEvent> args)
     {
-        var tenantKey = GetTenantKey(args.Query);
-        if (String.IsNullOrEmpty(tenantKey))
-            return;
+        var tenantKey = await ResolveTenantKeyAsync(args.Query);
 
         var definitionRepo = ElasticIndex.Configuration.CustomFieldDefinitionRepository;
-        if (definitionRepo is null)
-            return;
 
-        var fieldMapping = await definitionRepo.GetFieldMappingAsync(EntityTypeName, tenantKey);
-        var mapping = fieldMapping.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.GetIdxName(), StringComparer.OrdinalIgnoreCase);
+        // Lazy-load field mapping only when a query actually references idx.* or data.* fields.
+        // Most queries (count, date histograms, simple filters) never hit custom fields,
+        // so deferring this avoids a cache/ES lookup on every hot-path query.
+        Dictionary<string, string>? mapping = null;
 
-        args.Options.QueryFieldResolver((field, _) =>
+        args.Options.QueryFieldResolver(async (field, _) =>
         {
             string? fieldName = null;
             if (field.StartsWith("idx.", StringComparison.OrdinalIgnoreCase))
                 fieldName = field.Substring(4);
             else if (field.StartsWith("data.", StringComparison.OrdinalIgnoreCase))
                 fieldName = field.Substring(5);
+            else if (field.StartsWith("ref.", StringComparison.OrdinalIgnoreCase))
+                fieldName = $"@ref:{field.Substring(4)}";
+
+            if (fieldName is null)
+                return null;
+
+            // System fields have deterministic slots that don't require tenant resolution.
+            if (_systemFieldSlots.TryGetValue(fieldName, out var systemSlot))
+                return $"idx.{systemSlot}";
 
-            if (fieldName is not null && mapping.TryGetValue(fieldName, out var idxName))
-                return Task.FromResult<string?>($"idx.{idxName}");
+            // Non-system fields require a tenant key to look up their slot assignment.
+            if (String.IsNullOrEmpty(tenantKey) || definitionRepo is null)
+            {
+                // Without tenant context, block raw idx access; data.* fields fall through.
+                return field.StartsWith("idx.", StringComparison.OrdinalIgnoreCase) ? "idx.__blocked__" : null;
+            }
+
+            mapping ??= (await definitionRepo.GetFieldMappingAsync(EntityTypeName, tenantKey))
+                .ToDictionary(kvp => kvp.Key, kvp => kvp.Value.GetIdxName(), StringComparer.OrdinalIgnoreCase);
+
+            if (mapping.TryGetValue(fieldName, out var idxName))
+                return $"idx.{idxName}";
+
+            // Block raw slot access (e.g., idx.keyword-7) and unknown idx fields.
+            // Redirect to a non-existent field so the clause matches nothing.
+            if (field.StartsWith("idx.", StringComparison.OrdinalIgnoreCase))
+                return "idx.__blocked__";
 
-            return Task.FromResult<string?>(null);
+            // For data.* and ref.* fields that don't map to a custom field, return null to let
+            // other resolvers handle legitimate data paths (e.g., data.@version).
+            return null;
         });
     }
+
+    private async Task<string?> ResolveTenantKeyAsync(IRepositoryQuery query)
+    {
+        var organizationIds = query.GetOrganizations();
+        if (organizationIds.Count == 1)
+            return organizationIds.Single();
+
+        var projectIds = query.GetProjects();
+        if (projectIds.Count == 1)
+            return (await _projectRepository.GetByIdAsync(projectIds.Single()))?.OrganizationId;
+
+        var stackIds = query.GetStacks();
+        if (stackIds.Count == 1)
+            return (await _stackRepository.GetByIdAsync(stackIds.Single()))?.OrganizationId;
+
+        return null;
+    }
 }

src/Exceptionless.Core/Services/EventCustomFieldService.cs

@@ -23,6 +23,7 @@ public class EventCustomFieldService : IStartupAction
     /// </summary>
     public static readonly IReadOnlyList<(string Name, string IndexType)> SystemFields =
     [
+        ("@ref:session", "keyword"),
         (Event.KnownDataKeys.SessionEnd, "date"),
         (Event.KnownDataKeys.SessionHasError, "bool")
     ];
@@ -31,6 +32,7 @@ public class EventCustomFieldService : IStartupAction
     /// Well-known idx field names for system fields. These are deterministic because system fields
     /// are always provisioned first via EnsureSystemFieldsAsync (slot 1 for each type).
     /// </summary>
+    public const string SessionReferenceIdxField = "keyword-1";
     public const string SessionEndIdxField = "date-1";
     public const string SessionHasErrorIdxField = "bool-1";
 
@@ -97,13 +99,11 @@ private async Task OnDocumentsChangingAsync(object sender, DocumentsChangeEventA
         var documentsByOrganization = args.Documents
             .Select(d => d.Value)
             .Where(d => d is not null)
-            .GroupBy(d => d.OrganizationId);
+            .GroupBy(d => d.OrganizationId)
+            .Where(g => !String.IsNullOrEmpty(g.Key));
 
         foreach (var organizationGroup in documentsByOrganization)
         {
-            if (String.IsNullOrEmpty(organizationGroup.Key))
-                continue;
-
             IDictionary<string, CustomFieldDefinition>? fieldMapping = null;
             try
             {
@@ -117,22 +117,19 @@ private async Task OnDocumentsChangingAsync(object sender, DocumentsChangeEventA
                     fieldMapping = await _customFieldDefinitionRepository.GetFieldMappingAsync(nameof(PersistentEvent), organizationGroup.Key);
                 }
             }
-            catch (Exception ex)
+            catch (Exception ex) when (ex is not OperationCanceledException)
             {
                 _logger.LogError(ex, "Error loading custom field definitions for organization {OrganizationId}", organizationGroup.Key);
                 continue;
             }
 
-            foreach (var document in organizationGroup)
+            foreach (var document in organizationGroup.Where(d => d is not null))
             {
-                if (document is null)
-                    continue;
-
                 try
                 {
                     ProcessEventCustomFields(document, fieldMapping);
                 }
-                catch (Exception ex)
+                catch (Exception ex) when (ex is not OperationCanceledException)
                 {
                     _logger.LogError(ex, "Error processing custom fields for event {EventId}", document.Id);
                 }
@@ -142,6 +139,8 @@ private async Task OnDocumentsChangingAsync(object sender, DocumentsChangeEventA
 
     private void ProcessEventCustomFields(PersistentEvent ev, IDictionary<string, CustomFieldDefinition> fieldMapping)
     {
+        ClearManagedCustomFieldSlots(ev);
+
         if (fieldMapping.Count == 0 || ev.Data is null || ev.Data.Count == 0)
             return;
 
@@ -168,11 +167,39 @@ private void ProcessEventCustomFields(PersistentEvent ev, IDictionary<string, Cu
                 if (value is not null)
                     idx[definition.GetIdxName()] = value;
             }
-            catch (Exception ex)
+            catch (Exception ex) when (ex is FormatException or InvalidCastException or OverflowException)
             {
                 _logger.LogDebug(ex, "Skipping custom field {FieldName}: type mismatch for index type {IndexType}", fieldName, definition.IndexType);
             }
         }
+
+        if (ev.Idx?.Count == 0)
+            ev.Idx = null;
+    }
+
+    private static void ClearManagedCustomFieldSlots(PersistentEvent ev)
+    {
+        if (ev.Idx is null || ev.Idx.Count == 0)
+            return;
+
+        foreach (var idxKey in ev.Idx.Keys.Where(IsManagedCustomFieldSlotKey).ToArray())
+            ev.Idx.Remove(idxKey);
+
+        if (ev.Idx.Count == 0)
+            ev.Idx = null;
+    }
+
+    private static bool IsManagedCustomFieldSlotKey(string idxKey)
+    {
+        if (String.IsNullOrWhiteSpace(idxKey))
+            return false;
+
+        int separatorIndex = idxKey.LastIndexOf('-');
+        if (separatorIndex <= 0 || separatorIndex == idxKey.Length - 1)
+            return false;
+
+        return SupportedIndexTypes.Contains(idxKey[..separatorIndex])
+            && Int32.TryParse(idxKey.AsSpan(separatorIndex + 1), out _);
     }
 
     /// <summary>
@@ -324,13 +351,7 @@ public static bool IsValidFieldName(string name)
             return false;
 
         // Only ASCII alphanumeric, underscore, dot, and dash — no Unicode identifiers
-        foreach (var c in name)
-        {
-            if (!Char.IsAsciiLetterOrDigit(c) && c != '_' && c != '.' && c != '-')
-                return false;
-        }
-
-        return true;
+        return name.All(c => Char.IsAsciiLetterOrDigit(c) || c == '_' || c == '.' || c == '-');
     }
 
 }