fix initial query bug

Author: pwelter34

src/LoreSoft.Blazor.Controls/Data/DataComponentBase.cs

@@ -22,6 +22,7 @@ public abstract class DataComponentBase<TItem> : ComponentBase, IDisposable
     private IEnumerable<TItem>? _data;
     private bool _isLoading;
     private DataSort? _currentSort;
+    private QueryGroup? _initialQuery;
 
     /// <summary>
     /// Gets or sets the JavaScript runtime for interop calls.
@@ -157,12 +158,18 @@ public abstract class DataComponentBase<TItem> : ComponentBase, IDisposable
     [Parameter]
     public QueryGroup? Query { get; set; }
 
+    /// <summary>
+    /// Event triggered when the data grid is initialized.
+    /// </summary>
+    [Parameter]
+    public EventCallback<DataGrid<TItem>> Initialized { get; set; }
+
     /// <summary>
     /// Gets the root query group for filtering and searching.
     /// This is the primary filter container that holds all active filters and query groups.
     /// It's automatically managed by the component's filter operations but can be accessed for advanced scenarios.
     /// </summary>
-    public QueryGroup RootQuery { get; private set; } = new();
+    public QueryGroup RootQuery { get; } = new();
 
     /// <summary>
     /// Gets or sets a value indicating whether the component is currently loading data.
@@ -295,18 +302,22 @@ public async Task ClearFilters()
     /// This method allows programmatic application of filters without user interaction with the filter UI.
     /// </summary>
     /// <param name="rules">The collection of filter rules to apply. Each rule defines a specific filter condition.</param>
-    /// <param name="replace">When true, existing filters are cleared before applying new rules.
-    /// When false, new rules are added to existing filters.</param>
+    /// <param name="replace">
+    /// When true, existing filters are cleared before applying new rules.
+    /// When false, new rules are added to existing filters.
+    /// </param>
+    /// <param name="refresh">Whether to refresh the data display after applying the filter.</param>
     /// <returns>A task representing the asynchronous filter application and data refresh operation.</returns>
-    public async Task ApplyFilters(IEnumerable<QueryRule> rules, bool replace = false)
+    public async Task ApplyFilters(IEnumerable<QueryRule> rules, bool replace = false, bool refresh = true)
     {
         if (replace)
             RootQuery.Filters.Clear();
 
         if (rules != null)
             RootQuery.Filters.AddRange(rules);
 
-        await RefreshAsync(true);
+        if (refresh)
+            await RefreshAsync(true);
     }
 
     /// <summary>
@@ -315,8 +326,9 @@ public async Task ApplyFilters(IEnumerable<QueryRule> rules, bool replace = fals
     /// This allows for easy updates to existing filters without duplicating filter conditions.
     /// </summary>
     /// <param name="rule">The filter rule to apply. If null, no action is taken.</param>
+    /// <param name="refresh">Whether to refresh the data display after applying the filter.</param>
     /// <returns>A task representing the asynchronous filter application and data refresh operation.</returns>
-    public async Task ApplyFilter(QueryRule rule)
+    public async Task ApplyFilter(QueryRule? rule, bool refresh = true)
     {
         if (rule == null)
             return;
@@ -325,7 +337,9 @@ public async Task ApplyFilter(QueryRule rule)
             RootQuery.Filters.RemoveAll(f => f.Id == rule.Id);
 
         RootQuery.Filters.Add(rule);
-        await RefreshAsync(true);
+
+        if (refresh)
+            await RefreshAsync(true);
     }
 
     /// <summary>
@@ -400,6 +414,12 @@ protected override void OnInitialized()
     /// <inheritdoc />
     protected override async Task OnParametersSetAsync()
     {
+        if (_initialQuery != Query)
+        {
+            await ApplyFilter(Query, false);
+            _initialQuery = Query;
+        }
+
         if (DataProvider != null)
         {
             if (Data != null || DataLoader != null)
@@ -439,6 +459,9 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         if (!firstRender)
             return;
 
+        // notify initialized
+        await Initialized.InvokeAsync((DataGrid<TItem>)this);
+
         // re-render due to columns being added
         await RefreshAsync();
     }
@@ -626,7 +649,7 @@ protected virtual IQueryable<TItem> SortData(IQueryable<TItem> queryable, DataRe
         if (!Sortable || request.Sorts == null || request.Sorts.Length == 0)
             return queryable;
 
-       return queryable.Sort(request.Sorts);
+        return queryable.Sort(request.Sorts);
     }
 
     /// <summary>

src/LoreSoft.Blazor.Controls/Data/DataGrid.razor.cs

@@ -23,7 +23,6 @@ public partial class DataGrid<TItem> : DataComponentBase<TItem>
     private readonly HashSet<TItem> _expandedItems = [];
     private readonly HashSet<string> _expandedGroups = [];
 
-    private QueryGroup? _initialQuery;
     private BreakpointProvider? _breakpointProvider;
 
     /// <summary>
@@ -345,24 +344,6 @@ protected override async Task OnAfterRenderAsync(bool firstRender)
         await base.OnAfterRenderAsync(firstRender);
     }
 
-    /// <inheritdoc />
-    protected override void OnParametersSet()
-    {
-        base.OnParametersSet();
-
-        // only update RootQuery if Query changed
-        if (_initialQuery != Query)
-        {
-            _initialQuery = Query;
-            // RootQuery is managed by the base class, we can only access it if it exists
-            if (Query != null)
-            {
-                // The base class handles RootQuery initialization and management
-                // We just track the initial query for change detection
-            }
-        }
-    }
-
     /// <inheritdoc />
     protected override void OnInitialized()
     {

src/LoreSoft.Blazor.Controls/Query/QueryFilter.cs

@@ -6,7 +6,7 @@ namespace LoreSoft.Blazor.Controls;
 /// Represents a single filter condition for a query in a data-bound component.
 /// Inherits from <see cref="QueryRule"/> and specifies the field, operator, and value for filtering.
 /// </summary>
-public class QueryFilter : QueryRule
+public class QueryFilter : QueryRule, IEquatable<QueryFilter?>
 {
     /// <summary>
     /// Gets or sets the name of the field to filter on.
@@ -26,4 +26,25 @@ public class QueryFilter : QueryRule
     /// </summary>
     [JsonPropertyName("value")]
     public object? Value { get; set; }
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+    {
+        return Equals(obj as QueryFilter);
+    }
+
+    /// <inheritdoc/>
+    public bool Equals(QueryFilter? other)
+    {
+        return other is not null &&
+               Field == other.Field &&
+               Operator == other.Operator &&
+               EqualityComparer<object?>.Default.Equals(Value, other.Value);
+    }
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+    {
+        return HashCode.Combine(Field, Operator, Value);
+    }
 }

src/LoreSoft.Blazor.Controls/Query/QueryGroup.cs

@@ -7,7 +7,7 @@ namespace LoreSoft.Blazor.Controls;
 /// A group can contain multiple filters and/or subgroups, combined using a logical operator (AND/OR).
 /// Inherits from <see cref="QueryRule"/>.
 /// </summary>
-public class QueryGroup : QueryRule
+public class QueryGroup : QueryRule, IEquatable<QueryGroup?>
 {
     /// <summary>
     /// Gets or sets the logical operator used to combine the filters in this group.
@@ -22,4 +22,29 @@ public class QueryGroup : QueryRule
     /// </summary>
     [JsonPropertyName("filters")]
     public List<QueryRule> Filters { get; set; } = [];
+
+    /// <inheritdoc/>
+    public override bool Equals(object? obj)
+    {
+        return Equals(obj as QueryGroup);
+    }
+
+    /// <inheritdoc/>
+    public bool Equals(QueryGroup? other)
+    {
+        return other is not null &&
+               Logic == other.Logic &&
+               Filters.SequenceEqual(other.Filters);
+    }
+
+    /// <inheritdoc/>
+    public override int GetHashCode()
+    {
+        var hash = new HashCode();
+        hash.Add(Logic);
+        foreach (var filter in Filters)
+            hash.Add(filter);
+
+        return hash.ToHashCode();
+    }
 }

test/LoreSoft.Blazor.Controls.Tests/Snapshots/PublicApiTest.PublicApiHasNotChanged.verified.txt

@@ -259,6 +259,8 @@ namespace LoreSoft.Blazor.Controls
         protected bool FilterOpen { get; }
         [Microsoft.AspNetCore.Components.Parameter]
         public bool Filterable { get; set; }
+        [Microsoft.AspNetCore.Components.Parameter]
+        public Microsoft.AspNetCore.Components.EventCallback<LoreSoft.Blazor.Controls.DataGrid<TItem>> Initialized { get; set; }
         public bool IsLoading { get; set; }
         [Microsoft.AspNetCore.Components.Inject]
         public required Microsoft.JSInterop.IJSRuntime JavaScript { get; set; }
@@ -277,9 +279,9 @@ namespace LoreSoft.Blazor.Controls
         public int VirtualOverscan { get; set; }
         [Microsoft.AspNetCore.Components.Parameter]
         public bool Virtualize { get; set; }
-        public System.Threading.Tasks.Task ApplyFilter(LoreSoft.Blazor.Controls.QueryRule rule) { }
+        public System.Threading.Tasks.Task ApplyFilter(LoreSoft.Blazor.Controls.QueryRule? rule, bool refresh = true) { }
         protected System.Threading.Tasks.Task ApplyFilters() { }
-        public System.Threading.Tasks.Task ApplyFilters(System.Collections.Generic.IEnumerable<LoreSoft.Blazor.Controls.QueryRule> rules, bool replace = false) { }
+        public System.Threading.Tasks.Task ApplyFilters(System.Collections.Generic.IEnumerable<LoreSoft.Blazor.Controls.QueryRule> rules, bool replace = false, bool refresh = true) { }
         public System.Threading.Tasks.Task ClearFilters() { }
         public void CloseFilter() { }
         public virtual LoreSoft.Blazor.Controls.DataRequest CreateDataRequest(System.Threading.CancellationToken cancellationToken = default) { }
@@ -392,7 +394,6 @@ namespace LoreSoft.Blazor.Controls
         protected bool IsRowSelected(TItem item) { }
         protected override System.Threading.Tasks.Task OnAfterRenderAsync(bool firstRender) { }
         protected override void OnInitialized() { }
-        protected override void OnParametersSet() { }
         public System.Threading.Tasks.Task QuickSearch(string? searchText, bool clearFilter = false) { }
         public override System.Threading.Tasks.Task RefreshAsync(bool resetPager = false, bool forceReload = false) { }
         protected void SelectAll() { }
@@ -1108,7 +1109,7 @@ namespace LoreSoft.Blazor.Controls
         protected override void OnParametersSet() { }
         public void Refresh() { }
     }
-    public class QueryFilter : LoreSoft.Blazor.Controls.QueryRule
+    public class QueryFilter : LoreSoft.Blazor.Controls.QueryRule, System.IEquatable<LoreSoft.Blazor.Controls.QueryFilter?>
     {
         public QueryFilter() { }
         [System.Text.Json.Serialization.JsonPropertyName("field")]
@@ -1117,14 +1118,20 @@ namespace LoreSoft.Blazor.Controls
         public string? Operator { get; set; }
         [System.Text.Json.Serialization.JsonPropertyName("value")]
         public object? Value { get; set; }
+        public bool Equals(LoreSoft.Blazor.Controls.QueryFilter? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
     }
-    public class QueryGroup : LoreSoft.Blazor.Controls.QueryRule
+    public class QueryGroup : LoreSoft.Blazor.Controls.QueryRule, System.IEquatable<LoreSoft.Blazor.Controls.QueryGroup?>
     {
         public QueryGroup() { }
         [System.Text.Json.Serialization.JsonPropertyName("filters")]
         public System.Collections.Generic.List<LoreSoft.Blazor.Controls.QueryRule> Filters { get; set; }
         [System.Text.Json.Serialization.JsonPropertyName("logic")]
         public string? Logic { get; set; }
+        public bool Equals(LoreSoft.Blazor.Controls.QueryGroup? other) { }
+        public override bool Equals(object? obj) { }
+        public override int GetHashCode() { }
     }
     public static class QueryLogic
     {