Add reversed order context creation methods and tests for UseExpressives

Author: koenbeuk

src/ExpressiveSharp.EntityFrameworkCore.RelationalExtensions/RelationalExpressivePlugin.cs

@@ -3,6 +3,7 @@
 using ExpressiveSharp.EntityFrameworkCore.RelationalExtensions.Infrastructure.Internal;
 using ExpressiveSharp.EntityFrameworkCore.RelationalExtensions.Transformers;
 using Microsoft.EntityFrameworkCore.Query;
+using Microsoft.EntityFrameworkCore.Query.Internal;
 using Microsoft.Extensions.DependencyInjection;
 using Microsoft.Extensions.DependencyInjection.Extensions;
 
@@ -37,21 +38,37 @@ public void ApplyServices(IServiceCollection services)
     public IExpressionTreeTransformer[] GetTransformers() =>
         [new RewriteIndexedSelectToRowNumber()];
 
+    [SuppressMessage("Usage", "EF1001:Internal EF Core API usage.", Justification = "Required to decorate EF Core services")]
     private static void DecorateParameterBasedSqlProcessorFactory(IServiceCollection services)
     {
         var targetDescriptor = services.FirstOrDefault(
             x => x.ServiceType == typeof(IRelationalParameterBasedSqlProcessorFactory));
-        if (targetDescriptor is null) return;
 
-        services.Replace(ServiceDescriptor.Describe(
-            typeof(IRelationalParameterBasedSqlProcessorFactory),
-            sp =>
+        if (targetDescriptor is not null)
+        {
+            // Provider registered first — decorate immediately
+            services.Replace(ServiceDescriptor.Describe(
+                typeof(IRelationalParameterBasedSqlProcessorFactory),
+                sp =>
+                {
+                    var inner = CreateTargetInstance<IRelationalParameterBasedSqlProcessorFactory>(sp, targetDescriptor);
+                    var dependencies = sp.GetRequiredService<RelationalParameterBasedSqlProcessorDependencies>();
+                    return new WindowFunctionParameterBasedSqlProcessorFactory(inner, dependencies);
+                },
+                targetDescriptor.Lifetime));
+        }
+        else
+        {
+            // UseExpressives() called before provider — deferred decoration.
+            // Pre-register so the provider's TryAdd becomes a no-op.
+            // At resolution time, create the default factory and wrap it.
+            services.AddScoped<IRelationalParameterBasedSqlProcessorFactory>(sp =>
             {
-                var inner = CreateTargetInstance<IRelationalParameterBasedSqlProcessorFactory>(sp, targetDescriptor);
+                var inner = ActivatorUtilities.CreateInstance<RelationalParameterBasedSqlProcessorFactory>(sp);
                 var dependencies = sp.GetRequiredService<RelationalParameterBasedSqlProcessorDependencies>();
                 return new WindowFunctionParameterBasedSqlProcessorFactory(inner, dependencies);
-            },
-            targetDescriptor.Lifetime));
+            });
+        }
     }
 
     private static T CreateTargetInstance<T>(IServiceProvider services, ServiceDescriptor descriptor)

src/ExpressiveSharp.EntityFrameworkCore/Infrastructure/Internal/ExpressiveOptionsExtension.cs

@@ -45,17 +45,27 @@ public void ApplyServices(IServiceCollection services)
         services.AddScoped<IConventionSetPlugin, ExpressiveExpandQueryFiltersConventionPlugin>();
 
         // Decorate IQueryCompiler with ExpressiveQueryCompiler
-        var targetDescriptor = services.FirstOrDefault(x => x.ServiceType == typeof(IQueryCompiler))
-            ?? throw new InvalidOperationException(
-                "No QueryCompiler is configured. Ensure a database provider is configured before calling UseExpressives().");
+        var targetDescriptor = services.FirstOrDefault(x => x.ServiceType == typeof(IQueryCompiler));
 
         var decoratorFactory = ActivatorUtilities.CreateFactory(
-            typeof(ExpressiveQueryCompiler), [targetDescriptor.ServiceType]);
+            typeof(ExpressiveQueryCompiler), [typeof(IQueryCompiler)]);
 
-        services.Replace(ServiceDescriptor.Describe(
-            targetDescriptor.ServiceType,
-            serviceProvider => decoratorFactory(serviceProvider, [CreateTargetInstance(serviceProvider, targetDescriptor)]),
-            targetDescriptor.Lifetime));
+        if (targetDescriptor is not null)
+        {
+            // Provider registered first (e.g. UseSqlite().UseExpressives()) — decorate immediately
+            services.Replace(ServiceDescriptor.Describe(
+                targetDescriptor.ServiceType,
+                serviceProvider => decoratorFactory(serviceProvider, [CreateTargetInstance(serviceProvider, targetDescriptor)]),
+                targetDescriptor.Lifetime));
+        }
+        else
+        {
+            // UseExpressives() called before provider (e.g. AddSqlite optionsAction) — deferred decoration.
+            // Pre-register IQueryCompiler so the provider's TryAdd becomes a no-op.
+            // At resolution time, all provider services (IDatabase, IModel, etc.) are available.
+            services.AddScoped<IQueryCompiler>(sp =>
+                (IQueryCompiler)decoratorFactory(sp, [ActivatorUtilities.CreateInstance<QueryCompiler>(sp)]));
+        }
 
         // Apply plugin services
         foreach (var plugin in _plugins)

tests/ExpressiveSharp.EntityFrameworkCore.RelationalExtensions.Tests/WindowFunctionIntegrationTests.cs

@@ -38,6 +38,18 @@ private WindowTestDbContext CreateContext()
         return ctx;
     }
 
+    private WindowTestDbContext CreateContextReversedOrder()
+    {
+        // UseExpressives() before UseSqlite() — simulates AddSqlite optionsAction ordering
+        var options = new DbContextOptionsBuilder<WindowTestDbContext>()
+            .UseExpressives(o => o.UseRelationalExtensions())
+            .UseSqlite(_connection)
+            .Options;
+        var ctx = new WindowTestDbContext(options);
+        ctx.Database.EnsureCreated();
+        return ctx;
+    }
+
     private static void SeedTestData(WindowTestDbContext ctx)
     {
         ctx.Customers.AddRange(
@@ -229,4 +241,30 @@ public async Task IndexedSelect_ReturnsZeroBasedIndices()
         var positions = results.Select(r => r.Position).OrderBy(p => p).ToList();
         CollectionAssert.AreEqual(new[] { 0, 1, 2 }, positions);
     }
+
+    // ── Reversed ordering tests (UseExpressives before UseSqlite) ─────
+
+    [TestMethod]
+    public async Task RowNumber_BeforeProvider_ReturnsCorrectSequentialNumbers()
+    {
+        using var ctx = CreateContextReversedOrder();
+        SeedTestData(ctx);
+
+        var results = await ctx.Orders
+            .Select(o => new
+            {
+                o.Id,
+                o.Price,
+                RowNum = WindowFunction.RowNumber(Window.OrderBy(o.Price))
+            })
+            .OrderBy(x => x.RowNum)
+            .ToListAsync();
+
+        Assert.AreEqual(10, results.Count);
+        for (var i = 0; i < results.Count; i++)
+        {
+            Assert.AreEqual(i + 1, results[i].RowNum,
+                $"Expected RowNum {i + 1} at index {i}, got {results[i].RowNum}");
+        }
+    }
 }

tests/ExpressiveSharp.EntityFrameworkCore.Tests/UseExpressivesTests.cs

@@ -34,6 +34,18 @@ private TestDbContext CreateContext()
         return ctx;
     }
 
+    private TestDbContext CreateContextReversedOrder()
+    {
+        // UseExpressives() before UseSqlite() — simulates AddSqlite optionsAction ordering
+        var options = new DbContextOptionsBuilder<TestDbContext>()
+            .UseExpressives()
+            .UseSqlite(_connection)
+            .Options;
+        var ctx = new TestDbContext(options);
+        ctx.Database.EnsureCreated();
+        return ctx;
+    }
+
     private TestDbContextWithQueryFilter CreateContextWithQueryFilter()
     {
         var options = new DbContextOptionsBuilder<TestDbContextWithQueryFilter>()
@@ -45,6 +57,17 @@ private TestDbContextWithQueryFilter CreateContextWithQueryFilter()
         return ctx;
     }
 
+    private TestDbContextWithQueryFilter CreateContextWithQueryFilterReversedOrder()
+    {
+        var options = new DbContextOptionsBuilder<TestDbContextWithQueryFilter>()
+            .UseExpressives()
+            .UseSqlite(_connection)
+            .Options;
+        var ctx = new TestDbContextWithQueryFilter(options);
+        ctx.Database.EnsureCreated();
+        return ctx;
+    }
+
     [TestMethod]
     public void UseExpressives_MarksExpressivePropertiesAsUnmapped()
     {
@@ -161,4 +184,70 @@ public void ExpressiveDbSet_GroupByWithNullConditional()
         Assert.IsTrue(sql.Contains("Name", StringComparison.OrdinalIgnoreCase),
             $"Expected 'Name' in SQL, got: {sql}");
     }
+
+    // ── Reversed ordering tests (UseExpressives before UseSqlite) ─────
+
+    [TestMethod]
+    public void UseExpressives_BeforeProvider_MarksExpressivePropertiesAsUnmapped()
+    {
+        using var ctx = CreateContextReversedOrder();
+        var model = ctx.Model;
+        var orderEntity = model.FindEntityType(typeof(Order))!;
+
+        Assert.IsNull(orderEntity.FindProperty(nameof(Order.Total)));
+        Assert.IsNull(orderEntity.FindProperty(nameof(Order.CustomerName)));
+        Assert.IsNotNull(orderEntity.FindProperty(nameof(Order.Price)));
+        Assert.IsNotNull(orderEntity.FindProperty(nameof(Order.Quantity)));
+    }
+
+    [TestMethod]
+    public void UseExpressives_BeforeProvider_ExpandsExpressiveProperties()
+    {
+        using var ctx = CreateContextReversedOrder();
+
+        var query = ctx.Set<Order>()
+            .Where(o => o.Customer != null)
+            .Select(o => o.Total);
+        var sql = query.ToQueryString();
+
+        Assert.IsTrue(sql.Contains("*"),
+            $"Expected multiplication in SQL, got: {sql}");
+    }
+
+    [TestMethod]
+    public void UseExpressives_BeforeProvider_AppliesNullConditionalTransformer()
+    {
+        using var ctx = CreateContextReversedOrder();
+
+        var query = ctx.Set<Order>().Select(o => o.CustomerName);
+        var sql = query.ToQueryString();
+
+        Assert.IsNotNull(sql);
+    }
+
+    [TestMethod]
+    public void UseExpressives_BeforeProvider_AppliesFlattenBlockTransformer()
+    {
+        using var ctx = CreateContextReversedOrder();
+
+        var query = ctx.Set<Order>().Select(o => o.GetCategory());
+        var sql = query.ToQueryString();
+
+        Assert.IsTrue(
+            sql.Contains("WHEN", StringComparison.OrdinalIgnoreCase) ||
+            sql.Contains("IIF", StringComparison.OrdinalIgnoreCase) ||
+            sql.Contains("CASE", StringComparison.OrdinalIgnoreCase),
+            $"Expected conditional in SQL, got: {sql}");
+    }
+
+    [TestMethod]
+    public void UseExpressives_BeforeProvider_ExpandsQueryFilters()
+    {
+        using var ctx = CreateContextWithQueryFilterReversedOrder();
+
+        var query = ctx.Orders.ToQueryString();
+
+        Assert.IsTrue(query.Contains("*"),
+            $"Expected multiplication in query filter SQL, got: {query}");
+    }
 }