Merge pull request #58 from PandaTechAM/development

column distinct values polishing.

Author: HaikAsatryan

src/GridifyExtensions/Extensions/QueryableExtensions.cs

@@ -3,6 +3,8 @@
 using GridifyExtensions.Enums;
 using GridifyExtensions.Models;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.Extensions.DependencyInjection;
 
 namespace GridifyExtensions.Extensions;
 
@@ -236,56 +238,40 @@ public static async Task<PagedResponse<object>> ColumnDistinctValuesAsync<TEntit
 
       if (!mapper.IsEncrypted(model.PropertyName))
       {
-         var baseQuery = query
-                         .ApplyFiltering(gridifyModel, mapper)
-                         .ApplySelect(model.PropertyName, mapper);
+         var selectedNonEncrypted = query
+                                    .ApplyFiltering(gridifyModel, mapper)
+                                    .ApplySelect(model.PropertyName, mapper)
+                                    .Distinct();
 
-         var filterEmpty = string.IsNullOrWhiteSpace(gridifyModel.Filter);
-         var hasNull = false;
-         var take = model.PageSize;
-
-         if (filterEmpty)
+         var term = ExtractStarContainsTerm(model.Filter, model.PropertyName);
+         if (!string.IsNullOrEmpty(term) && IsStringColumn(query, mapper, model.PropertyName))
          {
-            // ReSharper disable once ConditionIsAlwaysTrueOrFalseAccordingToNullableAPIContract
-            hasNull = await baseQuery.AnyAsync(x => x == null, cancellationToken);
-            if (hasNull && take > 0)
-            {
-               take -= 1;
-            }
+            var termLower = term.ToLower();
+
+            var projected = query
+                            .ApplyFiltering(gridifyModel, mapper)
+                            .Select(StringSelector(query, mapper, model.PropertyName))
+                            .Distinct();
+
+            var data = await projected
+                             .OrderBy(x => x == null ? 0 : 1)
+                             .ThenBy(x => x != null && x.ToLower() == termLower ? 0 : 1)
+                             .ThenBy(x => x == null ? int.MaxValue : x.Length)
+                             .ThenBy(x => x)
+                             .Take(model.PageSize)
+                             .ToListAsync(cancellationToken);
+
+            return new CursoredResponse<object?>(data.Cast<object?>()
+                                                     .ToList(),
+               model.PageSize);
          }
 
-         // smart ordering for string values ---
-         var orderedQuery = baseQuery.Distinct();
-
-         if (typeof(string).IsAssignableFrom(orderedQuery.ElementType))
-         {
-            var stringQuery = (IQueryable<string?>)orderedQuery;
-
-            orderedQuery = stringQuery
-                           .OrderBy(x => x == null ? int.MaxValue : x.Length) // shorter first
-                           .ThenBy(x => x)!; // then lexicographic
-         }
-         else
-         {
-            orderedQuery = orderedQuery.OrderBy(x => x);
-         }
-
-         var result = await orderedQuery
-                            .Take(take)
-                            .ToListAsync(cancellationToken);
-
-         if (!filterEmpty || !hasNull)
-         {
-            return new CursoredResponse<object?>(result!, model.PageSize);
-         }
+         var data2 = await selectedNonEncrypted
+                           .OrderBy(x => (object?)x == null ? 0 : 1)
+                           .Take(model.PageSize)
+                           .ToListAsync(cancellationToken);
 
-         if (result.Count > 0 && ReferenceEquals(result[^1], null))
-         {
-            result.RemoveAt(result.Count - 1);
-         }
-
-         result.Insert(0, null!);
-         return new CursoredResponse<object?>(result!, model.PageSize);
+         return new CursoredResponse<object?>(data2!, model.PageSize);
       }
 
       // Encrypted path
@@ -397,4 +383,92 @@ public static IEnumerable<MappingModel> GetMappings<TEntity>()
                        }
                     });
    }
+   
+
+   private static Expression<Func<TEntity, string?>> EfStringSelector<TEntity>(string propertyName)
+      where TEntity : class
+   {
+      var e = Expression.Parameter(typeof(TEntity), "e");
+      var body = Expression.Call(
+         typeof(EF),
+         nameof(EF.Property),
+         [
+            typeof(string)
+         ],
+         e,
+         Expression.Constant(propertyName));
+
+      return Expression.Lambda<Func<TEntity, string?>>(body, e);
+   }
+
+   private static string? ExtractStarContainsTerm(string? filter, string propertyName)
+   {
+      if (string.IsNullOrWhiteSpace(filter)) return null;
+
+      var m = System.Text.RegularExpressions.Regex.Match(
+         filter,
+         $@"(?i)\b{System.Text.RegularExpressions.Regex.Escape(propertyName)}\s*=\s*\*(?<term>[^;,)]+)");
+
+      if (!m.Success) return null;
+
+      var term = m.Groups["term"]
+                  .Value
+                  .Trim();
+      return term.Length == 0 ? null : term;
+   }
+
+   private static bool IsStringColumn<TEntity>(IQueryable<TEntity> query, FilterMapper<TEntity> mapper, string name)
+      where TEntity : class
+   {
+      var db = TryGetDbContext(query);
+      var et = db?.Model.FindEntityType(typeof(TEntity));
+      var p = et?.FindProperty(name);
+      if (p != null)
+      {
+         return p.ClrType == typeof(string);
+      }
+
+      var map = mapper.GetCurrentMaps()
+                      .FirstOrDefault(m => m.From == name);
+      if (map == null)
+      {
+         return false;
+      }
+
+      var body = map.To.Body is UnaryExpression { NodeType: ExpressionType.Convert } ue ? ue.Operand : map.To.Body;
+      return body.Type == typeof(string);
+   }
+
+   private static Expression<Func<TEntity, string?>> StringSelector<TEntity>(IQueryable<TEntity> query,
+      FilterMapper<TEntity> mapper,
+      string name)
+      where TEntity : class
+   {
+      var db = TryGetDbContext(query);
+      var et = db?.Model.FindEntityType(typeof(TEntity));
+      var p = et?.FindProperty(name);
+
+      if (p != null)
+      {
+         return EfStringSelector<TEntity>(name);
+      }
+
+      var map = mapper.GetCurrentMaps()
+                      .FirstOrDefault(m => m.From == name)
+                ?? throw new KeyNotFoundException($"No map found for '{name}'.");
+
+      var param = map.To.Parameters[0];
+      var body = map.To.Body is UnaryExpression { NodeType: ExpressionType.Convert } ue ? ue.Operand : map.To.Body;
+
+      return body.Type != typeof(string)
+         ? throw new InvalidOperationException($"Map '{name}' must return string. Actual: {body.Type}.")
+         : Expression.Lambda<Func<TEntity, string?>>(body, param);
+   }
+
+   private static DbContext? TryGetDbContext<TEntity>(IQueryable<TEntity> query)
+   {
+      if (query is not IInfrastructure<IServiceProvider> infra) return null;
+      return infra.Instance.GetService<ICurrentDbContext>()
+                  ?.Context;
+   }
 }

src/GridifyExtensions/GridifyExtensions.csproj

@@ -8,13 +8,13 @@
         <PackageReadmeFile>Readme.md</PackageReadmeFile>
         <Authors>Pandatech</Authors>
         <Copyright>MIT</Copyright>
-        <Version>2.1.5</Version>
+        <Version>2.1.6</Version>
         <PackageId>Pandatech.GridifyExtensions</PackageId>
         <Title>Pandatech.Gridify.Extensions</Title>
         <PackageTags>Pandatech, library, Gridify, Pagination, Filters</PackageTags>
         <Description>Pandatech.Gridify.Extensions simplifies and extends the functionality of the Gridify NuGet package. It provides additional extension methods and functionality to streamline data filtering and pagination, making it more intuitive and powerful to use in .NET applications. Our enhancements ensure more flexibility, reduce boilerplate code, and improve overall developer productivity when working with Gridify.</Description>
         <RepositoryUrl>https://github.com/PandaTechAM/be-lib-gridify-extensions</RepositoryUrl>
-        <PackageReleaseNotes>ColumnDistinctValue String Ordering Became More Friendly</PackageReleaseNotes>
+        <PackageReleaseNotes>ColumnDistinctValue polishing</PackageReleaseNotes>
     </PropertyGroup>
 
     <ItemGroup>

test/GridifyExtensions.Demo/Context/EstateMapper.cs

@@ -0,0 +1,45 @@
+using GridifyExtensions.Demo.Domain;
+using GridifyExtensions.Extensions;
+using GridifyExtensions.Models;
+
+namespace GridifyExtensions.Demo.Context;
+
+public class EstateMapper : FilterMapper<Estate>
+{
+   public EstateMapper()
+   {
+      GenerateMappings();
+
+      // Direct scalar
+      AddMap("Id", x => x.Id);
+      AddMap("Status", x => x.Status);
+      AddMap("Sqm", x => x.Sqm);
+      AddMap("ResidentsQuantity", x => x.ResidentsQuantity);
+      AddMap("Balance", x => x.Balance);
+      AddMap("CreatedAt", x => x.CreatedAt, x => x.ToUtcDateTime());
+
+      // Strings with null/""/"   "
+      AddMap("Comment", x => x.Comment);
+      AddMap("NonNullText", x => x.NonNullText);
+      AddMap("NumberText", x => x.NumberText);
+
+      // Join-based scalar (ok)
+      AddMap("BuildingAddress", x => x.Building.Address);
+
+      // N:M example (collection) - STILL NOT SUPPORTED!
+      AddMap("TagNames", x => x.Tags.Select(t => t.Name));
+
+      // ✅ Critical: derived scalar (avoid collection map here)
+      AddMap("PrimaryOwnerId",
+         x => x.EstateOwnerAssignments
+               .Where(a => a.IsPrimary && a.EndDate == null && !a.Deleted)
+               .Max(a => (long?)a.PartnerId));
+
+      AddMap("PrimaryOwnerFullName",
+         x => x.EstateOwnerAssignments
+               .Where(a => a.IsPrimary && a.EndDate == null && !a.Deleted)
+               .Max(a => a.Partner.FullName));
+
+      AddDefaultOrderByDescending("Id");
+   }
+}

test/GridifyExtensions.Demo/Context/PostgresContext.cs

@@ -0,0 +1,73 @@
+using GridifyExtensions.Demo.Domain;
+using Microsoft.EntityFrameworkCore;
+
+namespace GridifyExtensions.Demo.Context;
+
+public class PostgresContext(DbContextOptions<PostgresContext> options) : DbContext(options)
+{
+   public DbSet<Estate> Estates => Set<Estate>();
+   public DbSet<Building> Buildings => Set<Building>();
+   public DbSet<Partner> Partners => Set<Partner>();
+   public DbSet<EstateOwnerAssignment> EstateOwnerAssignments => Set<EstateOwnerAssignment>();
+   public DbSet<Tag> Tags => Set<Tag>();
+
+   protected override void OnModelCreating(ModelBuilder b)
+   {
+      b.Entity<Partner>(e =>
+      {
+         e.Property(x => x.FullName)
+          .HasMaxLength(200);
+      });
+
+      b.Entity<Building>(e =>
+      {
+         e.Property(x => x.Address)
+          .HasMaxLength(300);
+         e.HasOne(x => x.Partner)
+          .WithMany()
+          .HasForeignKey(x => x.PartnerId);
+      });
+
+      b.Entity<Estate>(e =>
+      {
+         e.Property(x => x.Comment)
+          .HasMaxLength(500);
+
+         e.HasOne(x => x.Building)
+          .WithMany(x => x.Estates)
+          .HasForeignKey(x => x.BuildingId);
+
+         // N:M (skip navigation)
+         e.HasMany(x => x.Tags)
+          .WithMany(x => x.Estates)
+          .UsingEntity(j => j.ToTable("estate_tags"));
+      });
+
+      b.Entity<EstateOwnerAssignment>(e =>
+      {
+         e.HasOne(x => x.Estate)
+          .WithMany(x => x.EstateOwnerAssignments)
+          .HasForeignKey(x => x.EstateId);
+         e.HasOne(x => x.Partner)
+          .WithMany()
+          .HasForeignKey(x => x.PartnerId);
+
+         // Helps the demo reproduce/avoid slow plans:
+         e.HasIndex(x => new
+         {
+            x.EstateId,
+            x.IsPrimary,
+            x.EndDate,
+            x.Deleted
+         });
+      });
+
+      b.Entity<Tag>(e =>
+      {
+         e.Property(x => x.Name)
+          .HasMaxLength(80);
+         e.HasIndex(x => x.Name)
+          .IsUnique();
+      });
+   }
+}