Make sure to return only the projected fields #55

Author: pmoleri

NorthwindCRUD/Controllers/QueryBuilderController.cs

@@ -4,6 +4,7 @@ namespace QueryBuilder;
 using Microsoft.AspNetCore.Mvc;
 using Newtonsoft.Json;
 using NorthwindCRUD;
+using NorthwindCRUD.Models.DbModels;
 using NorthwindCRUD.Models.Dtos;
 using System.Diagnostics.CodeAnalysis;
 using System.Globalization;
@@ -51,19 +52,26 @@ public ActionResult<QueryBuilderResult> ExecuteQuery(Query query)
         var sanitizedEntity = query.Entity.Replace("\r", string.Empty).Replace("\n", string.Empty);
         logger.LogInformation("Executing query for entity: {Entity}", sanitizedEntity);
         var t = query.Entity.ToLower(CultureInfo.InvariantCulture);
-        return Ok(new QueryBuilderResult
+        return Ok(new Dictionary<string, object[]?>
         {
-            Addresses    = t == "addresses"    ? mapper.Map<AddressDto[]>(dataContext.Addresses.Run(query))        : null,
-            Categories   = t == "categories"   ? mapper.Map<CategoryDto[]>(dataContext.Categories.Run(query))      : null,
-            Products     = t == "products"     ? mapper.Map<ProductDto[]>(dataContext.Products.Run(query))         : null,
-            Regions      = t == "regions"      ? mapper.Map<RegionDto[]>(dataContext.Regions.Run(query))           : null,
-            Territories  = t == "territories"  ? mapper.Map<TerritoryDto[]>(dataContext.Territories.Run(query))    : null,
-            Employees    = t == "employees"    ? mapper.Map<EmployeeDto[]>(dataContext.Employees.Run(query))       : null,
-            Customers    = t == "customers"    ? mapper.Map<CustomerDto[]>(dataContext.Customers.Run(query))       : null,
-            Orders       = t == "orders"       ? mapper.Map<OrderDto[]>(dataContext.Orders.Run(query))             : null,
-            OrderDetails = t == "orderdetails" ? mapper.Map<OrderDetailDto[]>(dataContext.OrderDetails.Run(query)) : null,
-            Shippers     = t == "shippers"     ? mapper.Map<ShipperDto[]>(dataContext.Shippers.Run(query))         : null,
-            Suppliers    = t == "suppliers"    ? mapper.Map<SupplierDto[]>(dataContext.Suppliers.Run(query))       : null,
+            {
+                t,
+                t switch
+                {
+                    "addresses" => dataContext.Addresses.Run<AddressDb, AddressDto>(query, mapper),
+                    "categories" => dataContext.Categories.Run<CategoryDb, CategoryDto>(query, mapper),
+                    "products" => dataContext.Products.Run<ProductDb, ProductDto>(query, mapper),
+                    "regions" => dataContext.Regions.Run<RegionDb, RegionDto>(query, mapper),
+                    "territories" => dataContext.Territories.Run<TerritoryDb, TerritoryDto>(query, mapper),
+                    "employees" => dataContext.Employees.Run<EmployeeDb, EmployeeDto>(query, mapper),
+                    "customers" => dataContext.Customers.Run<CustomerDb, CustomerDto>(query, mapper),
+                    "orders" => dataContext.Orders.Run<OrderDb, OrderDto>(query, mapper),
+                    "orderdetails" => dataContext.OrderDetails.Run<OrderDetailDb, OrderDetailDto>(query, mapper),
+                    "shippers" => dataContext.Shippers.Run<ShipperDb, ShipperDto>(query, mapper),
+                    "suppliers" => dataContext.Suppliers.Run<SupplierDb, SupplierDto>(query, mapper),
+                    _ => throw new InvalidOperationException($"Unknown entity ${t}")
+                }
+            },
         });
     }
-}
+}

NorthwindCRUD/QueryBuilder/QueryExecutor.cs

@@ -4,7 +4,10 @@
 using System.Globalization;
 using System.Linq.Expressions;
 using System.Reflection;
+using System.Reflection.Emit;
+using AutoMapper;
 using AutoMapper.Internal;
+using AutoMapper.QueryableExtensions;
 using Microsoft.EntityFrameworkCore;
 using Microsoft.EntityFrameworkCore.Infrastructure;
 using NorthwindCRUD;
@@ -16,16 +19,21 @@
 [SuppressMessage("StyleCop.CSharp.SpacingRules", "SA1025:Code should not contain multiple whitespace in a row", Justification = "...")]
 public static class QueryExecutor
 {
-    public static TEntity[] Run<TEntity>(this IQueryable<TEntity> source, Query? query)
+    public static object[] Run<TEntity>(this IQueryable<TEntity> source, Query? query)
+    {
+        return source.Run<TEntity, TEntity>(query);
+    }
+
+    public static object[] Run<TSource, TTarget>(this IQueryable<TSource> source, Query? query, IMapper? mapper = null)
     {
         var infrastructure = source as IInfrastructure<IServiceProvider>;
         var serviceProvider = infrastructure!.Instance;
         var currentDbContext = serviceProvider.GetService(typeof(ICurrentDbContext)) as ICurrentDbContext;
         var db = currentDbContext!.Context as DataContext;
-        return db is not null ? BuildQuery(db, source, query).ToArray() : Array.Empty<TEntity>();
+        return db is not null ? BuildQuery<TSource, TTarget>(db, source, query, mapper).ToArray() : Array.Empty<object>();
     }
 
-    private static IQueryable<TEntity> BuildQuery<TEntity>(DataContext db, IQueryable<TEntity> source, Query? query)
+    private static IQueryable<object> BuildQuery<TSource, TTarget>(DataContext db, IQueryable<TSource> source, Query? query, IMapper? mapper = null)
     {
         if (query is null)
         {
@@ -36,12 +44,24 @@ private static IQueryable<TEntity> BuildQuery<TEntity>(DataContext db, IQueryabl
         var filteredQuery = source.Where(filterExpression);
         if (query.ReturnFields != null && query.ReturnFields.Any())
         {
-            var projectionExpression = BuildProjectionExpression<TEntity>(query.ReturnFields);
-            return filteredQuery.Select(projectionExpression).Cast<TEntity>();
+            if (mapper is not null)
+            {
+                var projectionExpression = BuildProjectionExpression<TTarget, TTarget>(query.ReturnFields);
+                return filteredQuery.ProjectTo<TTarget>(mapper.ConfigurationProvider).Select(projectionExpression);
+            }
+            else
+            {
+                var projectionExpression = BuildProjectionExpression<TSource, TTarget>(query.ReturnFields);
+                return filteredQuery.Select(projectionExpression);
+            }
+        }
+        else if (mapper is not null)
+        {
+            return (IQueryable<object>)filteredQuery.ProjectTo<TTarget>(mapper.ConfigurationProvider);
         }
         else
         {
-            return filteredQuery;
+            return filteredQuery.Cast<object>();
         }
     }
 
@@ -71,7 +91,7 @@ private static Expression<Func<TEntity, bool>> BuildExpression<TEntity>(DataCont
 
     private static Expression BuildConditionExpression<TEntity>(DataContext db, IQueryable<TEntity> source, QueryFilter filter, ParameterExpression parameter)
     {
-        if (filter.FieldName is not null && filter.IgnoreCase is not null && filter.Condition is not null)
+        if (filter.FieldName is not null && filter.Condition is not null)
         {
             var property = source.ElementType.GetProperty(filter.FieldName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance)
                                  ?? throw new InvalidOperationException($"Property '{filter.FieldName}' not found on type '{source.ElementType}'");
@@ -117,7 +137,7 @@ private static Expression BuildConditionExpression<TEntity>(DataContext db, IQue
                 "false"                 => Expression.Equal(field, Expression.Constant(false)),
                 _                       => throw new NotImplementedException("Not implemented"),
             };
-            if (filter.IgnoreCase.Value && field.Type == typeof(string))
+            if (filter.IgnoreCase == true && field.Type == typeof(string))
             {
                 // TODO: Implement case-insensitive comparison
             }
@@ -247,17 +267,69 @@ private static Expression GetEmptyValue(Type targetType)
         return Expression.Constant(targetType == typeof(string) ? string.Empty : targetType.GetDefaultValue());
     }
 
-    private static Expression<Func<TEntity, dynamic>> BuildProjectionExpression<TEntity>(string[] returnFields)
+    private static Expression<Func<TSource, object>> BuildProjectionExpression<TSource, TTarget>(string[] returnFields)
     {
-        var parameter = Expression.Parameter(typeof(TEntity), "entity");
-        var bindings = returnFields.Select(field =>
+        var tagetEntityType = typeof(TTarget);
+        var dbEntityType = typeof(TSource);
+
+        // Create the anonymous projection type
+        var projectionType = CreateProjectionType(tagetEntityType, returnFields);
+
+        var parameter = Expression.Parameter(dbEntityType, "entity");
+
+        var bindings = returnFields.Select(fieldName =>
         {
-            var property = typeof(TEntity).GetProperty(field, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance) ?? throw new InvalidOperationException($"Property '{field}' not found on type '{typeof(TEntity)}'");
+            var property = dbEntityType.GetProperty(fieldName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance) ?? throw new InvalidOperationException($"Property '{fieldName}' not found on type '{dbEntityType}");
+            var field = projectionType.GetField(fieldName, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance) ?? throw new InvalidOperationException($"Property '{fieldName}' not found on type '{projectionType}'");
             var propertyAccess = Expression.Property(parameter, property);
-            return Expression.Bind(property, propertyAccess);
+            return Expression.Bind(field, propertyAccess);
         }).ToArray();
 
-        var body = Expression.MemberInit(Expression.New(typeof(TEntity)), bindings);
-        return Expression.Lambda<Func<TEntity, dynamic>>(body, parameter);
+        // Get Microsoft.CSharp assembly where anonymous types are defined
+        var dynamicAssembly = typeof(Microsoft.CSharp.RuntimeBinder.Binder).Assembly;
+
+        var createExpression = Expression.MemberInit(Expression.New(projectionType), bindings);
+
+        return Expression.Lambda<Func<TSource, object>>(createExpression, parameter);
     }
+
+    private static Type CreateProjectionType(Type input, string[] fields)
+    {
+        var fieldsList = fields.Select(field =>
+        {
+            var property = input.GetProperty(field, BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance)
+                    ?? throw new InvalidOperationException($"Property '{field}' not found on type '{input}'");
+            return new Field
+            {
+                Name = property.Name,
+                Type = property.GetMemberType(),
+            };
+        }).ToList();
+
+        var name = input.Name + "Projection";
+        return CreateAnonymousType(name, fieldsList);
+    }
+
+    private static Type CreateAnonymousType(string name, ICollection<Field> fields)
+    {
+        AssemblyName dynamicAssemblyName = new AssemblyName("TempAssembly");
+        AssemblyBuilder dynamicAssembly = AssemblyBuilder.DefineDynamicAssembly(dynamicAssemblyName, AssemblyBuilderAccess.Run);
+        ModuleBuilder dynamicModule = dynamicAssembly.DefineDynamicModule("TempAssembly");
+
+        TypeBuilder dynamicAnonymousType = dynamicModule.DefineType(name, TypeAttributes.Public);
+
+        foreach (var field in fields)
+        {
+            dynamicAnonymousType.DefineField(field.Name, field.Type, FieldAttributes.Public);
+        }
+
+        return dynamicAnonymousType.CreateType() !;
+    }
+}
+
+internal class Field
+{
+    public string Name { get; set; }
+
+    public Type Type { get; set; }
 }