Performance improvements (#1330)

* Security fixes.

* Fix build.

* Fix build.

* UI fixes.

* Fix asset tags.

* Info the save the query.

* Fix first batches.

* More improvements

* More fixes

* Improve cache keys

* More fixes

* More fixes

* Fix

* Fixes

* Fixes

* More fixes

* Fix issues

* More progress

* Temp

* Update packages.

* Fix formatting.

* Fix db context configuration.

Author: SebastianStehle

CLAUDE.md

@@ -0,0 +1,55 @@
+# Squidex
+
+Headless CMS. Angular frontend in `frontend/`, ASP.NET Core backend in `backend/`.
+
+## Frontend
+
+- Angular app in `frontend/`, source under `src/app`:
+  - `framework/` — generic, reusable UI components and utilities (no domain knowledge).
+  - `shared/` — Squidex-specific services, state stores and components.
+  - `features/` — the actual screens (apps, assets, content, rules, schemas, settings, teams, ...).
+  - `shell/` — app frame, navigation, layout.
+- State is handled with the state store pattern from `framework/state.ts` (immutable value objects + `State<T>` subclasses), not with a third-party store library.
+- Commands:
+
+```bash
+npm start
+```
+
+```bash
+npm test
+```
+
+```bash
+npm run lint
+```
+
+### Best Practices
+
+- i18n texts live in `backend/i18n`, translations are generated into the frontend — do not edit generated translation files by hand.
+- Do not write JsDoc comments.
+
+## Backend
+
+- .NET solution `backend/Squidex.slnx`. Projects under `backend/src`, tests under `backend/tests`, optional integrations under `backend/extensions`.
+- Layering: `Squidex.Infrastructure` (generic building blocks) → `Squidex.Domain.Apps.*` (core model, operations, events, entities) → `Squidex.Web` / `Squidex` (API host).
+- Event-sourced domain: aggregates emit events from `Squidex.Domain.Apps.Events`, state is projected into MongoDB or EF Core (`Squidex.Data.MongoDb`, `Squidex.Data.EntityFramework`).
+- Run tests with the filter below — some tests need external setup (real databases, Docker/Testcontainers) and will fail without it:
+
+### Tests 
+
+Some tests need test setup or test containers which are slow. Run the tests like this to skip these tests.
+
+```bash
+dotnet test --filter "Category!=Dependencies & Category!=TestContainer"
+```
+
+### Best Practices
+
+- Code style is enforced by StyleCop (`backend/stylecop.json`) and `.editorconfig` — follow the surrounding file's conventions.
+- Do not write XML comments.
+
+## Shared best practices
+
+- Do write precise short comments and only when needed.
+- Do not comment a class or a method, only put comments inside functions or above variables.

backend/src/Squidex.Data.EntityFramework/Infrastructure/Extensions.cs

@@ -54,9 +54,15 @@ public static string Prefix(this DbContextOptions options)
         return options.GetExtension<PrefixExtension>().Prefix;
     }
 
-    public static DbContextOptionsBuilder SetDefaultWarnings(this DbContextOptionsBuilder builder)
+    public static DbContextOptionsBuilder SetDefaults(this DbContextOptionsBuilder builder)
     {
         builder.ConfigureWarnings(w => w.Ignore(CoreEventId.CollectionWithoutComparer));
+
+        // Almost everything is read only or written by inserting new entities, so tracking would
+        // only cost a snapshot of every entity that is read. The few stores that update an entity
+        // they have queried ask for it with AsTracking. This cannot be done in OnConfiguring,
+        // because the contexts are pooled and pooling forbids to modify the options there.
+        builder.UseQueryTrackingBehavior(QueryTrackingBehavior.NoTracking);
         return builder;
     }
 

backend/src/Squidex.Data.EntityFramework/ServiceExtensions.cs

@@ -82,7 +82,7 @@ public static void AddSquidexEntityFramework(this IServiceCollection services, I
 
                 services.AddPooledDbContextFactory<MySqlAppDbContext>(builder =>
                 {
-                    builder.SetDefaultWarnings();
+                    builder.SetDefaults();
                     builder.UseMySql(connectionString, version, options =>
                     {
                         options.UseNetTopologySuite();
@@ -93,7 +93,7 @@ public static void AddSquidexEntityFramework(this IServiceCollection services, I
 
                 services.AddNamedDbContext<MySqlContentDbContext>((builder, name) =>
                 {
-                    builder.SetDefaultWarnings();
+                    builder.SetDefaults();
                     builder.UseBulkInsertMySql();
                     builder.UseMySql(connectionString, version, options =>
                     {
@@ -118,7 +118,7 @@ public static void AddSquidexEntityFramework(this IServiceCollection services, I
             {
                 services.AddPooledDbContextFactory<PostgresAppDbContext>(builder =>
                 {
-                    builder.SetDefaultWarnings();
+                    builder.SetDefaults();
                     builder.UseBulkInsertPostgreSql();
                     builder.UseNpgsql(connectionString, options =>
                     {
@@ -128,7 +128,7 @@ public static void AddSquidexEntityFramework(this IServiceCollection services, I
 
                 services.AddNamedDbContext<PostgresContentDbContext>((builder, name) =>
                 {
-                    builder.SetDefaultWarnings();
+                    builder.SetDefaults();
                     builder.UseBulkInsertPostgreSql();
                     builder.UseNpgsql(connectionString, options =>
                     {
@@ -152,7 +152,7 @@ public static void AddSquidexEntityFramework(this IServiceCollection services, I
             {
                 services.AddPooledDbContextFactory<SqlServerAppDbContext>(builder =>
                 {
-                    builder.SetDefaultWarnings();
+                    builder.SetDefaults();
                     builder.UseSqlServer(connectionString, options =>
                     {
                         options.UseNetTopologySuite();
@@ -162,7 +162,7 @@ public static void AddSquidexEntityFramework(this IServiceCollection services, I
 
                 services.AddNamedDbContext<SqlServerContentDbContext>((builder, name) =>
                 {
-                    builder.SetDefaultWarnings();
+                    builder.SetDefaults();
                     builder.UseBulkInsertSqlServer();
                     builder.UseSqlServer(connectionString, options =>
                     {

backend/src/Squidex.Data.EntityFramework/Squidex.Data.EntityFramework.csproj

@@ -43,13 +43,13 @@
     <PackageReference Include="Microting.EntityFrameworkCore.MySql.Json.Microsoft" Version="10.0.6" />
     <PackageReference Include="Microting.EntityFrameworkCore.MySql.NetTopologySuite" Version="10.0.6" />
     <PackageReference Include="RefactoringEssentials" Version="5.6.0" PrivateAssets="all" />
-    <PackageReference Include="Squidex.AI.EntityFramework" Version="8.0.3" />
-    <PackageReference Include="Squidex.Assets.EntityFramework" Version="8.0.3" />
-    <PackageReference Include="Squidex.Assets.TusAdapter" Version="8.0.3" />
-    <PackageReference Include="Squidex.Events.EntityFramework" Version="8.0.3" />
-    <PackageReference Include="Squidex.Flows.EntityFramework" Version="8.0.3" />
-    <PackageReference Include="Squidex.Hosting" Version="8.0.3" />
-    <PackageReference Include="Squidex.Messaging.EntityFramework" Version="8.0.3" />
+    <PackageReference Include="Squidex.AI.EntityFramework" Version="8.0.4" />
+    <PackageReference Include="Squidex.Assets.EntityFramework" Version="8.0.4" />
+    <PackageReference Include="Squidex.Assets.TusAdapter" Version="8.0.4" />
+    <PackageReference Include="Squidex.Events.EntityFramework" Version="8.0.4" />
+    <PackageReference Include="Squidex.Flows.EntityFramework" Version="8.0.4" />
+    <PackageReference Include="Squidex.Hosting" Version="8.0.4" />
+    <PackageReference Include="Squidex.Messaging.EntityFramework" Version="8.0.4" />
     <PackageReference Include="Squidex.OpenIdDict.EntityFramework" Version="7.2.1" />
     <PackageReference Include="StyleCop.Analyzers" Version="1.1.118" PrivateAssets="all" />
     <PackageReference Include="System.ValueTuple" Version="4.6.2" />

backend/src/Squidex.Data.MongoDb/Domain/Apps/Entities/Assets/MongoAssetRepository.cs

@@ -109,7 +109,7 @@ await Collection.Find(filter)
                         {
                             assetTotal = -1;
                         }
-                        else
+                        else if (query.NeedsTotalById(q.Ids.Count))
                         {
                             assetTotal = await Collection.Find(filter).CountDocumentsAsync(ct);
                         }

backend/src/Squidex.Data.MongoDb/Domain/Apps/Entities/Contents/CollectionProvider.cs

@@ -13,15 +13,39 @@ namespace Squidex.Domain.Apps.Entities.Contents;
 
 internal class CollectionProvider(IMongoClient mongoClient, string prefixDatabase, string prefixCollection)
 {
-    private readonly ConcurrentDictionary<(DomainId, DomainId), Task<IMongoCollection<MongoContentEntity>>> collections =
-        new ConcurrentDictionary<(DomainId, DomainId), Task<IMongoCollection<MongoContentEntity>>>();
+    private readonly ConcurrentDictionary<(DomainId AppId, DomainId SchemaId), Lazy<Task<IMongoCollection<MongoContentEntity>>>> collections =
+        new ConcurrentDictionary<(DomainId AppId, DomainId SchemaId), Lazy<Task<IMongoCollection<MongoContentEntity>>>>();
 
-    public Task<IMongoCollection<MongoContentEntity>> GetCollectionAsync(DomainId appId, DomainId schemaId)
+    public async Task<IMongoCollection<MongoContentEntity>> GetCollectionAsync(DomainId appId, DomainId schemaId)
     {
-        return collections.GetOrAdd((appId, schemaId), CreateCollectionAsync);
+        var key = (appId, schemaId);
+
+        // The lazy ensures that the indexes are only created once, even when the same collection is
+        // requested concurrently. GetOrAdd alone can run the factory several times for one key.
+        var collection = collections.GetOrAdd(key, CreateLazyCollection);
+
+        try
+        {
+            return await collection.Value;
+        }
+        catch
+        {
+            // A failed attempt must not stay in the cache. Creating the indexes can fail for a
+            // transient reason and the collection would be unusable until the process is restarted.
+            // Only remove our own entry, so that a newer successful one is not thrown away.
+            collections.TryRemove(new KeyValuePair<(DomainId AppId, DomainId SchemaId), Lazy<Task<IMongoCollection<MongoContentEntity>>>>(key, collection));
+            throw;
+        }
+    }
+
+    private Lazy<Task<IMongoCollection<MongoContentEntity>>> CreateLazyCollection((DomainId AppId, DomainId SchemaId) key)
+    {
+        return new Lazy<Task<IMongoCollection<MongoContentEntity>>>(
+            () => CreateCollectionAsync(key),
+            LazyThreadSafetyMode.ExecutionAndPublication);
     }
 
-    private async Task<IMongoCollection<MongoContentEntity>> CreateCollectionAsync((DomainId, DomainId) key)
+    private async Task<IMongoCollection<MongoContentEntity>> CreateCollectionAsync((DomainId AppId, DomainId SchemaId) key)
     {
         var (appId, schemaId) = key;
 

backend/src/Squidex.Data.MongoDb/Domain/Apps/Entities/Contents/MongoContentRepository_SnapshotStore.cs

@@ -135,7 +135,7 @@ async Task ISnapshotStore<WriteContent>.WriteManyAsync(IEnumerable<SnapshotWrite
                 collectionUpdates.GetOrAddNew(collection).Add(entity);
             });
 
-            foreach (var job in jobs)
+            foreach (var job in validJobs)
             {
                 if (job.Value.ShouldWritePublished())
                 {

backend/src/Squidex.Data.MongoDb/Domain/Apps/Entities/Contents/Operations/QueryByIds.cs

@@ -56,7 +56,7 @@ public async Task<IResultList<Content>> QueryAsync(App app, List<Schema> schemas
             {
                 contentTotal = -1;
             }
-            else
+            else if (query.NeedsTotalById(q.Ids.Count))
             {
                 contentTotal = await Collection.Find(filter).CountDocumentsAsync(ct);
             }

backend/src/Squidex.Data.MongoDb/Domain/Apps/Entities/Contents/Operations/QueryByQuery.cs

@@ -64,6 +64,13 @@ public async Task<IResultList<Content>> QueryAsync(App app, List<Schema> schemas
             {
                 contentTotal = -1;
             }
+            else if (isDefault)
+            {
+                // Cache total count by app and schemas because no other filters are applied (aka default).
+                var totalKey = CreateTotalKey(app, schemas);
+
+                contentTotal = await countCollection.GetOrAddAsync(totalKey, ct => Collection.Find(filter).CountDocumentsAsync(ct), ct);
+            }
             else if (query.IsSatisfiedByIndex())
             {
                 // It is faster to filter with sorting when there is an index, because it forces the index to be used.
@@ -78,6 +85,16 @@ public async Task<IResultList<Content>> QueryAsync(App app, List<Schema> schemas
         return ResultList.Create<Content>(contentTotal, contentEntities);
     }
 
+    private static string CreateTotalKey(App app, List<Schema> schemas)
+    {
+        // The schemas depend on the permissions of the user and are not in a stable order, so the ids
+        // are sorted. They are also hashed, because the key is the ID of the count document and there
+        // can be enough schemas to exceed the maximum key size of MongoDB.
+        var schemaIds = schemas.Select(x => x.Id.ToString()).Order(StringComparer.Ordinal);
+
+        return $"{app.Id}_Schemas_{string.Join('_', schemaIds).ToSha256Base64()}";
+    }
+
     public async Task<IResultList<Content>> QueryAsync(Schema schema, Q q,
         CancellationToken ct)
     {

backend/src/Squidex.Data.MongoDb/Infrastructure/Queries/LimitExtensions.cs

@@ -11,6 +11,13 @@ namespace Squidex.Infrastructure.Queries;
 
 public static class LimitExtensions
 {
+    public static bool NeedsTotalById(this ClrQuery query, int idCount)
+    {
+        // A query by ID can never match more documents than the number of requested IDs, so the result
+        // already contains all of them unless skip, take or the random selection could have cut it off.
+        return query.Skip > 0 || query.Take < idCount || query.Random > 0;
+    }
+
     public static IAggregateFluent<T> QueryLimit<T>(this IAggregateFluent<T> cursor, ClrQuery query)
     {
         if (query.Take < long.MaxValue)