FlexQuery.NET.OpenApi 4.0.0-preview.3

This is a prerelease version of FlexQuery.NET.OpenApi.

dotnet add package FlexQuery.NET.OpenApi --version 4.0.0-preview.3

NuGet\Install-Package FlexQuery.NET.OpenApi -Version 4.0.0-preview.3

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.OpenApi" Version="4.0.0-preview.3" />

For projects that support PackageReference, copy this XML node into the project file to reference the package.

<PackageVersion Include="FlexQuery.NET.OpenApi" Version="4.0.0-preview.3" />
                    

                            Directory.Packages.props

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

                            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.OpenApi --version 4.0.0-preview.3

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

#r "nuget: FlexQuery.NET.OpenApi, 4.0.0-preview.3"

#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.OpenApi@4.0.0-preview.3

#: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.OpenApi&version=4.0.0-preview.3&prerelease
                    

                            Install as a Cake Addin

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

                            Install as a Cake Tool

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

FlexQuery.NET.OpenApi

OpenAPI/Swagger documentation and examples for FlexQuery.NET endpoints.

When to Use This Package

Install this package when you expose FlexQuery-enabled endpoints and want automatic OpenAPI schema descriptions, parameter documentation, and canonical request/response examples in your Swagger UI or OpenAPI document.

Installation

dotnet add package FlexQuery.NET.OpenApi

Registration

builder.Services.AddFlexQueryOpenApi();

This registers schema and operation transformers that enrich your OpenAPI document with:

Descriptions for all FlexQuery model types (FlexQueryRequest, FlexQueryParameters, QueryResult<T>, etc.)
Descriptions for query parameters (filter, select, sort, page, pageSize, includeCount)
Canonical, production-quality examples for FlexQueryRequest, FlexQueryParameters, and QueryResult<T>

Quick Start

var builder = WebApplication.CreateBuilder(args);

builder.Services.AddControllers();
builder.Services.AddFlexQueryOpenApi();

builder.Services.AddOpenApi(options =>
{
    options.AddFlexQuery();
});

var app = builder.Build();

app.MapOpenApi();
app.Run();

Features

Schema Descriptions — Human-readable descriptions for all FlexQuery model types (FlexQueryRequest, FlexQueryParameters, QueryResult<T>, FilterGroup, FilterCondition, SortNode, PagingOptions, AggregateModel, HavingCondition, IncludeNode, ProjectionMode, LogicOperator, AggregateFunction)
Parameter Documentation — Descriptions for query parameters (filter, select, sort, page, pageSize, includeCount)
Canonical Examples — Production-quality, strongly typed examples for FlexQueryRequest, FlexQueryParameters, and QueryResult<T> that immediately demonstrate FlexQuery capabilities
Zero Configuration — Single registration call, no options, no builders
Minimal Public API — Two extension methods, everything else internal

FlexQuery.NET — Core query engine
FlexQuery.NET.AspNetCore — ASP.NET Core integration
FlexQuery.NET.EntityFrameworkCore — EF Core execution
FlexQuery.NET.Dapper — Dapper execution

Documentation

Product	Compatible and additional computed target framework versions.
.NET	net9.0 is compatible. 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.

Product

.NET

Compatible target framework(s)

Included target framework(s) (in package)

Learn more about Target Frameworks and .NET Standard.

net10.0
- FlexQuery.NET (>= 4.0.0-preview.3)
- Microsoft.AspNetCore.OpenApi (>= 10.0.0)
net9.0
- FlexQuery.NET (>= 4.0.0-preview.3)
- Microsoft.AspNetCore.OpenApi (>= 9.0.0)

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	35	7/18/2026
4.0.0-preview.2	43	7/14/2026
4.0.0-preview.1	51	7/12/2026

- docs: update OpenAPI documentation registry and schema docs
- test: update tests for HAVING expression tree, parsers, validators, and SQL generation
- docs: update OpenAPI documentation, adapters, and sample diagnostics
- fix: update validation rules and request model for aggregate refactor
- refactor: update fluent builders and extensions for new Aggregate model
- feat: update HAVING expression builder and SQL generation for nested conditions
- refactor: replace AggregateModel with Aggregate and update aggregate parsers
- feat: add HAVING validation rules and update validator pipeline
- feat: add recursive-descent HAVING parsers for DSL and FQL with AND/OR/parentheses
- refactor: introduce HAVING expression tree models and AST nodes
- refactor(groupby): extract GroupByParser from FQL-specific parser
- test(parser-dsl): add identifier grammar tests for select and aggregate
- test(parser-fql): add identifier grammar tests for select and aggregate
- refactor(parser-dsl): enforce single identifier grammar in select and aggregate
- refactor(parser-fql): enforce single identifier grammar in select and aggregate
- refactor(parser): unify identifier grammar in ParserUtilities
- test: update SelectTests for SelectNode canonical AST
- refactor: minor cleanup in FqlAggregateParser
- refactor: cleanup shared validation helpers
- refactor: update validation and builder layers for SelectNode AST
- refactor: make SelectNode the canonical parser AST for nested projections
- feat: introduce SelectValidationRule for SELECT projection semantics
- refactor: rename projection SelectModel to SelectNode
- test(remaining): update validation, caching, security, dapper, and builder tests
- test(projection): update projection and integration tests for SelectModel
- test(parsers): update parser tests to assert SelectModel objects
- feat(source): wire remaining builders and extensions to SelectModel
- refactor(projection): update downstream consumers to use SelectModel
- feat(parsers): update all select parsers to emit List<SelectModel>
- feat(projection): introduce SelectModel AST and update QueryOptions.Select type
- tests: add end-to-end having validation tests to parser test suites
- tests: update Dapper having integration test to DSL syntax
- tests: update HAVING validation tests for aggregate declaration checks
- tests: update DSL having parser tests for new grammar
- validation: enforce declared aggregate references in HAVING
- parsers: centralize DSL aggregate grammar in AggregateGrammar
- Tests: add parser-level validation tests for DSL and FQL
- ExpressionBuilder: use FilterOperators for operator support check
- DSL: document AST contract and use FilterOperators for grammar validation
- FQL: complete HAVING operator set and remove redundant converter validation
- feat(parser): reject unsupported operators in DSL Having parser
- Revert "test(integration): update sort syntax in mixed aggregate sort test"
- test: add comprehensive aggregate parser tests and reorganize sort parser tests
- refactor(models): rename SortOption to SortNode
- test(integration): update sort syntax in mixed aggregate sort test
- test(validation): add COUNT target validation tests for aggregate sort
- test(parser): update DSL sort parser tests for new aggregate syntax
- feat(validation): enforce COUNT targets collection-only in sort
- feat(parser): add descriptive comments to aggregate sort parser
- refactor(parser): replace legacy aggregate sort syntax with colon-separated format
- refactor(validation): remove AggregateAliasValidationRule
- test(aggregate-sort): update tests for wildcard rejection and normalized AST
- refactor(builders): update aggregate and sort builders for enum-based AST
- feat(validation): add aggregate validation rules and error codes
- feat(parsers): reject wildcard aggregates and normalize aggregate sort AST
- refactor: rename SortParser to DslSortParser
- test(projection): add alias integration tests
- test(fql): add nested alias parser tests
- test(dsl): add nested alias parser tests
- feat(builder): propagate aliases and detect conflicts in MergeTree
- feat(fql): add nested alias parsing to FqlSelectParser
- feat(dsl): add nested alias parsing to DslSelectParser
- test(di): fix namespace to match folder structure
- test(projection): add nested projection integration tests
- test(fql): add nested projection parser tests
- test(dsl): add nested projection parser tests
- fix(governance): skip ValidateOrThrow in non-strict mode
- feat(fql): add ParseToSelectionTree for nested projection support
- feat(dsl): add ParseToSelectionTree for nested projection support
- test: add aggregate alias validation and builder tests
- test: add DSL and FQL parser aggregate alias tests
- feat: update AggregateBuilder fluent API for optional aliases
- feat: enforce non-empty alias syntax in FQL aggregate parser
- feat: enforce non-empty alias syntax in DSL aggregate parser
- feat: add aggregate alias semantic validation
- fix(tests): align Dapper integration and FQL parser tests with colon alias syntax
- feat(select): add DSL colon alias parsing to DslSelectParser
- refactor(parser): rename HavingParser to DslHavingParser
- refactor: restrict include to navigation property paths only
- merge: shared model migration and test modernization (#11)
- test: finalize DialectTests migration to shared model registry
- test: update remaining test files for shared model compatibility
- test: update integration, projection, security, and validation tests
- test: update Dapper integration and security tests for shared model
- test: update Dapper SQL translation tests for shared model
- test: update builders, caching, filters, and resolver expectations
- test: add new test infrastructure for shared model
- refactor: remove old per-test fixtures and legacy FlexQueryCore tests
- feat: add cycle detection and shared model metadata
- merge feature/regression test to main branch (#10)
- feat(dsl): adopt function-first aggregate grammar
- refactor(parsers): split shared SelectParser by language
- refactor: unify parser exceptions under FlexQueryException
- test(dapper): add SqlJoinBuilder unit tests
- test(dapper): add SqlCountBuilder, SqlHavingBuilder, SqlSelectBuilder unit tests
- refactor(tests): split ValidationRuleTests into one file per rule
- refactor(tests): reorganize test files into structured feature folders
- test: add comprehensive unit test suites for Core, AspNetCore, OpenApi, and Diagnostics
- refactor(core): make global config immutable after first call; add thread-safe registries and tests