FlexQuery.NET.AspNetCore 4.0.0-preview.1

.NET 6.0 This package targets .NET 6.0. The package is compatible with this framework or higher.
This is a prerelease version of FlexQuery.NET.AspNetCore.
There is a newer prerelease version of this package available.
See the version list below for details. 
dotnet add package FlexQuery.NET.AspNetCore --version 4.0.0-preview.1
                    


                    

                
NuGet\Install-Package FlexQuery.NET.AspNetCore -Version 4.0.0-preview.1
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package. 
<PackageReference Include="FlexQuery.NET.AspNetCore" Version="4.0.0-preview.1" />
For projects that support PackageReference, copy this XML node into the project file to reference the package. 
<PackageVersion Include="FlexQuery.NET.AspNetCore" Version="4.0.0-preview.1" />
                    


                            Directory.Packages.props
                        

                    

                
<PackageReference Include="FlexQuery.NET.AspNetCore" />
                    


                            Project file
For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package. 
paket add FlexQuery.NET.AspNetCore --version 4.0.0-preview.1
                    


                    

                
#r "nuget: FlexQuery.NET.AspNetCore, 4.0.0-preview.1"
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package. 
#:package FlexQuery.NET.AspNetCore@4.0.0-preview.1
#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package. 
#addin nuget:?package=FlexQuery.NET.AspNetCore&version=4.0.0-preview.1&prerelease
                    


                            Install as a Cake Addin
                        

                    

                
#tool nuget:?package=FlexQuery.NET.AspNetCore&version=4.0.0-preview.1&prerelease
                    


                            Install as a Cake Tool

FlexQuery.NET.AspNetCore

NuGet Version

ASP.NET Core integration with declarative field-access security.

When to Use This Package

Install this package when you want to use [FieldAccess] attributes on your API controllers to declare per-endpoint security rules, or when you need automatic model binding for FlexQueryParameters.

Installation

dotnet add package FlexQuery.NET.AspNetCore

Registration

builder.Services.AddFlexQuery();
builder.Services.AddFlexQuerySecurity();

// Or combine with MVC:
builder.Services.AddControllers()
    .AddFlexQuerySecurity();

Quick Start

[ApiController]
[Route("api/[controller]")]
public class UsersController : ControllerBase
{
    [HttpGet]
    [FieldAccess(AllowedFields = new[] { "Id", "Name", "Email", "Status" },
                 MaxFieldDepth = 2)]
    public async Task<IActionResult> GetUsers([FromQuery] FlexQueryParameters parameters)
    {
        // FieldAccess settings are automatically resolved from HttpContext.
        var result = await _context.Users.FlexQueryAsync(parameters, HttpContext);
        return Ok(result);
    }
}

Features

  • [FieldAccess] Attribute — Declare Allowed, Blocked, Filterable, Sortable, Selectable, Groupable, Aggregatable fields per-endpoint
  • FieldAccessFilter — Action filter that applies attribute settings to QueryExecutionOptions
  • **Automatic Security Resolution** — Extension method accepting HttpContext` for automatic options resolution
  • Swagger Integration — Works with Swagger/Swashbuckle for API documentation

Documentation

Product Compatible and additional computed target framework versions.
.NET net6.0 is compatible.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 is compatible.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed.  net9.0 was computed.  net9.0-android was computed.  net9.0-browser was computed.  net9.0-ios was computed.  net9.0-maccatalyst was computed.  net9.0-macos was computed.  net9.0-tvos was computed.  net9.0-windows was computed.  net10.0 is compatible.  net10.0-android was computed.  net10.0-browser was computed.  net10.0-ios was computed.  net10.0-maccatalyst was computed.  net10.0-macos was computed.  net10.0-tvos was computed.  net10.0-windows was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last Updated
4.0.0-preview.3 21 7/18/2026
4.0.0-preview.2 36 7/14/2026
4.0.0-preview.1 49 7/12/2026
3.1.1 99 7/4/2026
3.1.0 107 6/26/2026
3.0.6 102 6/24/2026
3.0.5 102 6/24/2026
3.0.4 101 6/23/2026
3.0.3 106 6/23/2026
3.0.2 110 6/22/2026
3.0.1 111 6/22/2026
2.5.0 111 5/13/2026
2.4.0 109 5/10/2026
2.3.1 112 5/8/2026
2.3.0 103 5/7/2026
2.2.0 122 5/6/2026
2.1.0 101 5/6/2026
2.0.1 96 5/6/2026
1.7.2 103 5/4/2026
Loading failed

- docs: added open api readme
- fix: web api program.cs
- test: update non-DI smoke test for renamed facade and parser APIs
- refactor(parsers): rename FqlParser to Fql and MiniODataParser to MiniOData
- refactor(efcore): move FlexQueryEFCore to root namespace and add global option resolution
- refactor(dapper): move FlexQueryDapper to Configuration namespace and add global options
- refactor(core): rename FlexQueryConfiguration to FlexQueryCore and update facade references
- test: replace DI registration tests with static initialization and configuration tests
- samples(webapi): use static FlexQueryConfiguration.Configure for startup
- fix(openapi): align ExampleProvider with renamed QueryOptions members
- refactor(miniodata): replace DI registration with static MiniODataParser.Register
- refactor(fql): replace DI registration with static FqlParser.Register
- refactor(efcore): replace DI registration with static FlexQueryEFCore.Setup
- refactor(dapper): replace DI registration with static FlexQueryDapper.BuildModel
- refactor(aspnetcore): drop AddFlexQuery DI wrapper, keep security filter
- refactor(core): replace FlexQuery facade with FlexQueryConfiguration and internalize processor
- refactor(di): remove DI registration from Core package and unify namespaces to Microsoft.Extensions.DependencyInjection
- feat: add FlexQuery.NET.OpenApi package for OpenAPI/Swagger documentation
- fix(tests): update FQL imports after namespace change
- refactor(fql): move ServiceCollectionExtensions to DependencyInjection directory
- refactor(core): change QueryOptionsParser.Parse to accept IReadOnlyDictionary
- refactor(miniodata): extract dedicated parser classes and add test coverage
- fix(tests): update Parse helper to use IReadOnlyDictionary overload
- feat(tests): add DI registration unit tests for IServiceCollection extensions
- refactor(miniodata): move OData token types into dedicated Models namespace
- refactor: rename test files and references from JQL to FQL
- refactor: update benchmarks from JQL to FQL references
- refactor: rename QuerySyntax.Jql enum value and update XML docs to FQL
- refactor: rename JQL parser package from FlexQuery.NET.Parsers.Jql to FlexQuery.NET.Parsers.Fql
- refactor: convert exception classes to primary constructors
- test: update tests for strict validation behavior
- docs: add XML documentation comments to all parse exception classes
- feat: add JQL query parser groupBy exception wrapping
- feat: add JQL sort, groupBy, aggregate, having, and include validation
- feat: add DSL query parser exception wrapping for all parameters
- feat: add include path validation through error factory pattern
- feat: add DSL aggregate and having validation
- feat: add select field grammar validation
- feat: add DSL sort validation with property path checking
- refactor: remove syntax-specific parsing from shared QueryOptionsFactory
- feat: add strict validation for page, pageSize, and distinct parameters
- feat: add IsValidPropertyPath shared property path validation helper
- test: update tests for strict QuerySyntax validation and include refactoring
- feat: enforce strict QuerySyntax validation across all parameters
- refactor: move include parsing into language-specific parsers
- feat: introduce public exception hierarchy for query parsing
- test: update Dapper tests to use AggregateFunction enum
- test: update parser and execution tests to use AggregateFunction enum
- fix: update Dapper providers to use AggregateFunction enum
- fix: update builders and validators to use AggregateFunction enum comparisons
- feat: update JQL, Kendo, and AgGrid parsers to use AggregateFunction enum
- feat: replace string aggregate function with typed AggregateFunction enum
- test: update adapter tests for PascalCase aggregate aliases
- test: update parser tests for PascalCase aliases and dedicated aggregates parameter
- fix: resolve HAVING alias using actual AggregateModel alias
- feat: move DSL aggregates from select to dedicated aggregates parameter
- feat: generate aggregate aliases using PascalCase convention
- test: add JQL sort, aggregate, having, groupBy, and integration tests
- feat: integrate JQL aggregate parsing into the query pipeline
- feat: add JQL sort, aggregate, having, and groupBy parsers
- feat: extend JQL tokenizer with sort, aggregate, and alias tokens
- refactor: encapsulate parser infrastructure behind public APIs
- test: consolidate ParserTests to ParserUtilities only
- test: add dedicated DslQueryParserTests and JqlQueryParserTests
- test: update for RawParameters internalization and MiniOData pipeline
- refactor: remove RawParameters from Dapper query-string overload
- refactor: update MiniOData and Jql DI to register via QueryParserRegistry
- fix: correct keyset pagination state in FluentQueryBuilder
- fix: wire FlexOptions.QuerySyntax to parser via SetGlobalSyntax in DI
- refactor: remove RawKey from cache, wire QueryOptionsParser to registry
- refactor: make RawParameters internal, add PreserveRawOrder flag
- refactor: remove CanParse from IQueryParser and all parsers, remove AutoDetect
- feat: add QueryParserRegistry with per-syntax parser resolution
- refactor: rename FlexQueryOptions.FilterSyntax to QuerySyntax
- fix: add null checks to ToQueryOptions extension methods
- refactor: remove legacy JSON, Generic, and Indexed query syntax support
- Feature/dapper sql refactor (#8)
- feat: add FlexQueryRequestExtensions fluent API and strongly-typed FlexQueryRequest
- fix: update FlexQueryBase and test files for incompatible API changes
- chore: inline dialect in benchmarks and remove UseSqlite from sample
- test(dapper): add SqlDialectResolverTests for all supported providers
- test(dapper): remove Dialect property overrides from test fixtures and test classes
- refactor(dapper): remove manual Dialect configuration, use auto-detection from DbConnection
- docs: update
- refactor(parsers): move MiniOData ServiceCollectionExtensions to DependencyInjection and update namespace
- refactor(aspnetcore): update ServiceCollectionExtensions using statements for renamed namespace
- refactor(core): move FlexQueryOptions from Configurations to Configuration namespace and update all references
- fix(efcore): add keyset paging support in FlexQueryEfCoreExecutor
- fix(core): guard null executionContext in grouped query notification path
- refactor(core): update QueryableExtensions to use async Processor
- chore: update samples and tests for refactored execution pipeline
- refactor(core): clean up diagnostics, validation, and query models
- refactor(efcore): extract FlexQueryEfCoreExecutor and consolidate options
- refactor(dapper): extract DapperQueryExecutor and DapperResultMaterializer
- refactor: update DI registrations and remove obsolete AspNetCore extension
- refactor(core): simplify IFlexQueryProcessor and extract grouped query execution
- refactor: rename and relocate core types
- refactor(dapper and EF Core): rename Dapper and EF Core extension parameters and simplify internal signature
- refactor(efcore): rename EF Core extension parameters for consistency
- refactor(core): consolidate query pipeline into FlexQueryProcessor
- refactor(dapper): use BuildQueryResult helper and add XML doc comments
- refactor: simplify hasProjection check across core and EF Core
- refactor(efcore): rename FlexQueryEfCoreConfiguration to FlexQueryEfCoreOptions
- refactor(core): relocate FlexQueryOptions to Configurations namespace
- refactor(dapper): rename FlexQueryDapperConfigurer to FlexQueryDapperOptions
- refactor(dapper): extract shared query preparation logic
- feat(dapper): add SQL adapter and utility infrastructure
- feat(dapper): add execution evaluators and result materialization layer
- feat(dapper): extract dedicated count and having clause builders
- refactor(dapper): migrate SqlValueConverter to Sql/Converters namespace
- refactor(dapper): replace SqlDialectHelper with dedicated SqlSyntaxBuilder
- refactor(dapper): relocate SQL model types to Sql/Models namespace
- refactor: move the FlexQueryDapperExtensions to extensions namespace
- refactor: rename FlexQueryServiceCollectionExtensions to ServiceCollectionExtensions
- fix: update tests and sample for consolidated option model
- refactor: rename QueryExecutionOptions to BaseQueryOptions in validation rules
- refactor(aspnetcore): align with consolidated option model
- refactor(dapper): simplify DapperQueryOptions via BaseQueryOptions inheritance
- refactor(efcore): adopt consolidated option model with EfCoreQueryOptions
- refactor(core): restructure option model with FlexQueryOptions-driven defaults
- refactor: remove dead codes
- refactor: consolidate MergeFilters implementation
- refactor: move SelectTreeBuilder to Builders namespace and clean up references
- refactor: move Query Fluent Builder class to FlexQuery.NET.Builders.Fluent namespace
- refactor: move IsNavigationProperty to TypeHelper
- refactor(efcore): move IncludeBuilder to Includes namespace and refactor for SOLID principles
- refactor(ns): update test and sample imports for Dapper namespace changes
- refactor(dapper): restructure Dapper project namespace hierarchy
- refactor: update downstream packages and tests for restructured namespace hierarchy
- refactor(core): restructure namespace hierarchy and add configuration/execution entry points
- refactor(expressions): move ExpressionPrinter and ExpressionTreeVisualizer to Expressions namespace
- refactor(core): remove legacy Query property in favor of Filter
- feat(dapper): redesign mapping configuration API with convention-first model builder
- refactor: move to the namespace from Extensions to rootnamespace
- refactor: move filter components to Filters namespace
- refactor: reorganize model files into subfolders
- refactor(models): simplify PagingOptions using field-backed properties
- refactor(projection): move ProjectionEnhancer to Projection namespace
- refactor(builders): rename and relocate projection expression builder
- refactor: remove unused class / dead code
- refactor: move DynamicTypeBuilder to Builders namespace
- refactor: move HavingExpressionBuilder to Expressions namespace
- refactor: move ExpressionBuilder to Expressions namespace
- test: fix the error, parse the json string to jsonelement
- refactor(expressions): relocate and rename filter expression builder
- refactor(core): relocate resolver types to Resolvers namespace
- refactor: rename method name to ToQueryOptions and change the argument tpye from string to JsonElement
- docs: update for internalized mapping types
- chore: exclude benchmark depending on internalized types
- refactor(samples): migrate Dapper config from inline to global DI
- refactor(dapper): rename configureDapper parameter and consolidate overloads
- refactor(dapper): update mapping surface by making internal implementation
- refactor(dapper): split translator types into dedicated files
- refactor: separate jql and dsl ast models into individual files
- refactor(core): separate types into individual files
- style: apply code cleanup
- refactor(dapper): simplify Dapper architecture
- refactor(api): hide internal implementation types
- refactor(validation): relocate GovernanceValidator to Validation namespace
- feat(dapper): add HasKey() fluent mapping
- refactor(api): seal builder types and restrict construction
- refactor: reduce public API surface by making internal implementation and correct name space
- refactor: simplify exception hierarchy, remove dead exception classes
- refactor: reduce public API surface by making internal implementation types internal
- feat: add Dapper keyset pagination with shared cursor validation
- feat: add keyset (cursor-based) pagination with predicate generation and auto NextCursorToken
- feat: add MiniODataRequest.ToQueryOptions() extension method
- refactor: introduce MiniODataRequest canonical DTO, separate transport from parsing
- feat: add CancellationToken support across all async overloads
- rename FilteredIncludes to Expand, make Items/CaseInsensitive/EnableCache internal
- remove all deprecated members from QueryOptions and FluentQueryBuilder
- refactor: migrate execution-oriented properties from QueryOptions to QueryExecutionOptions
- fix: Add XML doc comments across DiagnosticsDuration
- feat: add fluent query builder API with model refactoring and tests
- test: add unit tests for normalize, validation rules, case-insensitive SQL, and pipeline ordering
- docs: update changelog and added release notes for v3.1.1