6.2.4

Fixes

• Fixed No generic method 'SelectWithNullCheck' for a sub-selection on a field returning IAsyncEnumerable<T> or ValueTask<TCollection> - { people { tags { name } } } where tags has a ResolveAsync returning either. MakeSelectWithDynamicType emits a SelectWithNullCheck whose overload is resolved by the exact type of the expression it projects, and only IEnumerable<T> and Task<IEnumerable<T>> had one. IAsyncEnumerable<T> now has an overload of its own that projects lazily, so the stream is still buffered by the engine with the request's CancellationToken rather than being enumerated during compilation, and ValueTask<T> is handed on as the Task<T> the rest of the pipeline already handles, next to the existing Task<TCollection> normalization.
• Fixed Object of type 'Dynamic_...' cannot be converted to type 'Dynamic_...' when buffering an IAsyncEnumerable<T> whose items are rebuilt - the list rebuild mismatch below, one layer down. BufferAsyncEnumerable created a List<T> from the declared element type before resolving anything and added each resolved item to it, so an item rebuilt to carry an awaited member no longer fit. Items are now resolved first and the list type chosen from them, which is what the IEnumerable path already did - both paths now share that step. The same guard added above for Task<T> and ValueTask<T> in GetResolvedFieldType applies to IAsyncEnumerable<T>, which is reachable now that these shapes compile.
• Fixed Object of type 'System.Collections.Generic.List1[System.Object]' cannot be converted to type 'System.Collections.Generic.IEnumerable1[Dynamic_...]' for a query selecting an async service field below an async service list field - { people { tags { name label } } } where tags has a ResolveAsync returning a list and label on the item type has one of its own. Resolving an item of the outer list rebuilds it, because the item projection holds an async member, so the finished list no longer holds the item type the outer field was declared with and correctly falls back to List<object>. GetResolvedFieldType unwrapped Task<T> to T unconditionally, so the rebuilt parent still declared the member IEnumerable<T> and setting the resolved list on it threw. T is now only kept when the resolved value still is one, otherwise the resolved value's own type is used - which is what the non-async path in the same method already did. ValueTask<T> had the same hole and takes the same guard.

6.2.3

Fixes

• Fixed An item with the same key has already been added when a service field's resolver builds an object from more than one context member as an argument to the service call - (ctx, srv) => srv.Get(new Key(ctx.A, ctx.B)). ExpressionExtractor credited both member reads to the enclosing construction rather than to themselves, so it emitted the same Expression instance twice under the one name and ExpressionReplacer added each of them to a dictionary keyed by node identity. A construction is now walked through rather than treated as a leaf, so each read is extracted on its own. ExpressionReplacer also tolerates a repeated expression, which the extractor still emits for other shapes (a conditional argument, where the branch reads are both credited to the conditional).

6.2.2

Fixes

• Fixed a field whose dotnet type is a nullable value type (Instant?, DateTime?, int?) resolving to default(T) instead of null, for a query that also selects an async field. Results are rebuilt after any async field is awaited, and each member's new type was taken from the resolved value's runtime type.

6.2.1

Fixes

• Fixed IsNullable() (and any other change to a field's return type) on a field whose dotnet type has an AddTypeMapping leaking to every other field of that type. The mapping's GqlTypeInfo was handed out as the field's own ReturnType, and that object is mutable - IsNullable() writes to it - so one AddField(...).IsNullable(true) rewrote the registered mapping itself, changing every field already using it and every field added afterwards. Fields now get a copy, so an explicit IsNullable() after AddField() applies to that field only and the mapping stays the default it describes.

6.2.0

Changes

• A resolver can now be told what the engine will read off the objects it returns, so it can fetch only that instead of everything - the point of batching with ResolveBulk when the data comes from another database or service. Take an IFieldSelection parameter and the engine supplies it, the way it supplies CancellationToken and QueryRequestContext; new two-service ResolveBulk/ResolveBulkAsync overloads let a loader take it alongside its own service. It is not the caller's selection set: a selected field that is itself resolved from a service is replaced by the member its resolver reads, nested objects come through as paths (Address.City), @skip/@include are applied, fragments are expanded, aliases collapse, __typename is excluded, and one load is told the union of every place the field is selected. See Fetching only the fields that will be used.
• New [GraphQLFromContext] on a [GraphQLField] method parameter binds it to a member of the field's context instead of exposing it as a GraphQL argument. This lets a static method with a body - one that loops, branches or awaits, where an Expression<Func<>> cannot be used - be a service field on a type other than the root query type: the declared members (navigation properties included) are selected in the database-bound pass and the call is rewritten against that result, the same as .Resolve() dependency extraction, so nothing else on the entity is selected. Every dependency must be declared: a parameter taking the whole entity is rejected at schema build, as it would select the entity itself and a body reading a navigation property would silently see an empty collection. Instance methods on the entity remain unsupported - the entity is the call target and does not survive that pass - and now fail with a message naming the alternatives instead of an ArgumentException about a Dynamic_ type. See Declaring what a method reads from the context.
• A field with a ResolveBulk/ResolveBulkAsync resolver that has to resolve per item instead of bulk loading now logs a warning to the ILogger the schema was built with, naming the field and why the bulk load could not run - the query shape usually controls it, so it is something a caller can act on. Turn it off with ExecutionOptions.WarnOnBulkResolverFallback = false. ISchemaProvider.Logger is new (exceptions keep going through LogException); it returns null by default so existing implementations are unaffected.
• New field.SetMaxAliases(n) caps how many times a single field may be aliased in one operation, alongside the document-wide ExecutionOptions.MaxFieldAliases. Useful for the few fields a batched-alias attack would target (a login mutation, an expensive report) without tightening the limit for everything. Counts aliased selections of that field, fragment contents included. QueryLimitExceededContext.FieldName names the field for report-only mode. See Query limits.
• ToGraphQLSchemaString() takes an optional includeDescriptions argument. Pass false to leave the """...""" descriptions out of the generated SDL.

Fixes

• Fixed an IArgumentsTracker parameter on a mutation or subscription method failing with Service IArgumentsTracker not found for dependency injection whenever a service provider is passed to ExecuteRequest - i.e. in any real app. The engine builds and populates the tracker per call, but the branch binding it to the parameter sat below the dependency-injection catch-all, so it was only reachable with a null service provider (which is how the existing tests exercised it). Registering IArgumentsTracker in DI was not a workaround: it bound a different, empty tracker, so IsSet returned false for every argument and the mutation silently took the "nothing was supplied" path. It is now bound before the DI branch, the same as CancellationToken.
• An IArgumentsTracker parameter now works on query fields built from methods ([GraphQLField] methods, AddFieldsFrom), not just mutations - it previously fell through to the service provider and failed with Service IArgumentsTracker not found in service provider. The field's arguments object is built deriving from ArgumentsTracker when a parameter asks for one, and the parameter binds to that object, so the tracker is not a service and a field that has no other services stays on the database-bound pass.
• An argument explicitly supplied as null on a query field is now reported as set by IArgumentsTracker - previously only a non-null value or a schema default counted, so IsSet could not tell an explicit null from an omitted argument, which is the distinction it exists to make. This also applies to [GraphQLArguments] / input types deriving from ArgumentsTracker. Mutation arguments already behaved this way.
• AddTypeMapping now applies to every field returning the mapped dotnet type, not only the ones auto-created from the context. A mapping like AddTypeMapping<NpgsqlPolygon>("[Point!]!") describes the whole GraphQL type - list-ness and nullability come from the mapping string, not from the dotnet type - but only the auto-populated path returned the mapping's GqlTypeInfo. Everything else went through SchemaBuilder.MakeGraphQlType, which resolved the type name (Point) and then recomputed IsList/TypeNotNullable from the dotnet type, so AddField(), AddField().Resolve(), root fields on Query(), [GraphQLField] methods and expression fields all described the field as Point instead of [Point!]!. Introspection, the SDL and any client generated from them were wrong; execution is unchanged. Two notes: the [GraphQLField] method case is a regression in 6.0 (the other paths never honoured the mapping), and an async [GraphQLField] method now matches the mapping too - the lookup used to be made with the declared Task<T> return type. Type mappings still need to be registered in SchemaBuilderOptions.PreBuildSchemaFromContext so they exist before the context is reflected.

6.1.7

Fixes

• Fixed a single-object field with a ResolveBulk resolver whose per-item resolver queries the schema context - e.g. .Resolve<MyContext>((p, ctx) => ctx.Site.Movies.FirstOrDefault(m => m.DirectorId == p.Id)) - failing with Could not find extension method Select on types System.Linq.Enumerable. A regression in 6.1.3: such a field was moved onto the collection selection path (to keep it translatable), but a bulk resolver's value on that pass is the loaded dictionary's entry, a single object, so there is no collection to select through. Bulk resolved fields stay on the single-object projection. Reported in #543 - thanks @soilidokay for the reproduction.
• Fixed a service field selected on the items of a paging field whose own resolver uses a service - e.g. .Resolve<MyService>((p, srv) => p.Tasks.Where(t => srv.Include(t))) with UseOffsetPaging()/UseConnectionPaging() on a nested type - failing with Could not find field egql__x_Id on type X. Such a paging field cannot be split across the two passes so it is built in one go on the services pass, from the entity rather than from a first-pass projection; a service field on its items had nowhere to read its own extracted dependency from. It now reads that dependency straight off the entity.

6.1.6

Fixes

• The field-error logging added in 6.1.5 is now covered for the case it exists for: outside development mode the caller gets only Field 'x' - Error occurred while the original exception - its own message and stack trace - reaches the ILogger. 6.1.5's test ran with the default IsDevelopment = true, where nothing is swallowed, so it did not check that.

6.1.5

Fixes

• Field-level exceptions are logged again, with the field name and stack trace, to the ILogger the schema was built with. A regression in 6.0: partial results turned a field failure into a GraphQL error instead of rethrowing it, so nothing reached the request-level log and the only way to see why a field failed was development mode or AllowedExceptions - both of which return the detail to the caller. Responses are unchanged. Document and validation errors, whose message the caller already gets in full, are not logged.

6.1.4

Fixes

• Fixed ResolveBulk / ResolveBulkAsync nested under a root service-resolved list (e.g. Query.apiKeys from .Resolve<TService>(...) rather than a context/DbSet property) so nested bulk fields load once instead of falling back to per-item Resolve (or previously failing with a null BulkParameter). Root service list fields now participate in the two-pass flow. UseFilter()/UseSort() on those root lists still apply on the first pass and are not re-applied against the first-pass Dynamic on the second. Regression tests in ServiceRootListBulkTests / ServiceBackedCollectionExtensionsTests. A root service list/object only takes the two-pass path when the selection actually has a bulk resolver in it (including through a fragment spread) - otherwise it stays on the single-pass path, as the extra pass costs a compile and a projection of every row for nothing. Note that for the fields that do take it, the service now runs during the first pass, so a BeforeExecuting hook sees two executions for them (isFinal false then true) where it saw one.
• Fixed ResolveBulk nested under a root service-resolved object that exposes a list (status-page shape: statusPage { items { bulkField } }). First pass used to return only ExtractedFieldsFromServices for root service objects, so nested list selection and bulk registration were skipped; the second pass then either N+1'd via Resolve or failed converting entity types to first-pass Dynamic_* types (No coercion operator...). Root service objects now participate in the two-pass flow (like root service lists), wrap once with ProjectWithNullCheck on the first pass, and on the second pass select from the materialized anon instead of re-invoking the service. Also rebinds the ResolveBulk DataSelector parameter (a different ParameterExpression than FieldParam) so multi-property keys no longer fail with variable 'row' ... is not defined. Nullable-nav bulk keys (row.DetexyBoard == null ? null : row.DetexyBoard.SerialNumber) are rewritten via ExpressionReplacer.VisitConditional onto the first-pass extracted field instead of leaving a second navigation MemberExpression unbound. Exact regression: HardwareSensorStatusPageBulkTests (mirrors Offline Active hardwareSensorStatusPage { items { lastSeen isOffline floor { currentFloorStatus } } }). Also: ServiceResolvedPage_ItemsWithResolveBulk_Works, ServiceResolvedPage_ItemsWithComplexResolveBulkKey_Works.

6.1.3

Fixes

• Fixed a field resolved from the query context - e.g. .Resolve<MyDbContext>((c, db) => db.Things.Where(t => t.ParentId == c.Id)), the pattern for a child collection that is not a navigation property - being projected with one of EntityGraphQL's own methods (SelectWithNullCheck, or ProjectWithNullCheck for a single object), which no database provider can translate. Selecting another such field below it failed the operation with The LINQ expression 'p_Thing => new Dynamic_things{...}' could not be translated. Lists keep a plain Select (a regression from 6.0.0-beta3), and a single object is projected inside the query - Where().Select().FirstOrDefault(), as it already was for a field like movie(id: 1). Fields using a service other than the query context still get the null check, as they can return null.

6.1.2

Fixes

• Fixed a ResolveBulk field selected on data that the first (no-service) pass never produces failing the whole root field with Field '<name>' - Error occurred (ArgumentException: Static property requires null instance..., or KeyNotFoundException for the bulk data key). The clearest case is a root field resolved from services - schema.Query().AddField("comments", ...).Resolve<IMyService, MyDbContext>(...) selecting { isReadByCurrentUser } - where the first pass produces no expression at all, so no bulk load is registered while the second pass still compiled the lookup; the same applied below another service field's selection and with ExecuteServiceFieldsSeparately = false. These fields now fall back to their per-item resolver (one service call per item) instead of failing. Bulk loading them needs the service-resolved parent executed before the keys are collected - a further execution pass, not implemented. Repro tests from #538.
• Fixed a ResolveBulk/ResolveBulkAsync resolver whose values are lists - e.g. ResolveBulk<MyService, string, IEnumerable<Item>>(...) returning IDictionary<string, IEnumerable<Item>> - failing with Specified cast is not valid (InvalidCastException) when the field was resolved. A list field's dotnet return type is promoted to IQueryable<T> and the bulk data lookup was built against Dictionary<TKey, IQueryable<Item>>, which the loaded Dictionary<TKey, IEnumerable<Item>> cannot be cast to (a dictionary's generic arguments are invariant). The lookup now takes its dictionary type from the resolver's own signature and casts to IDictionary<,>, so any dictionary implementation and value type the resolver declares works. Reported in #534 - thanks @soilidokay.
• ResolveBulk()/ResolveBulkAsync() on a field with no resolver now throws EntityGraphQLSchemaException naming the field and the fix, instead of a NullReferenceException from inside the schema-building call. A bulk resolver builds on a resolver rather than replacing it - the per-item resolver runs whenever the bulk load cannot (e.g. the field is selected below another service field), so a bulk-only field could not resolve at all. Also from #534.
• Fixed an async field (ResolveAsync, or a ResolveBulkAsync field falling back to its per-item resolver) below a root list resolved from services leaving an unawaited Task<T> in the response instead of its value - typically surfacing as a serialized empty object or {"result": ...}-shaped noise for that field. Nested async results were resolved only when services executed in a single pass or on the second pass of a two-pass execution; a root field resolved from services has no first pass to run, so its one execution is the final one while ExecuteServiceFieldsSeparately is still on and it matched neither case. Keyed off the final execution now. The same field below a context/DbSet root list was always awaited.
• Fixed the same ResolveBulk field selected at more than one level of a self-referencing type - comments { isReadByCurrentUser replies { isReadByCurrentUser } } - failing with KeyNotFoundException for a key that was never loaded. The loaded data is keyed by the bulk resolver name, and each level was loaded separately, so the last level's data replaced the previous level's. Every level's keys now go into one load call.
• schema.Validate() now checks field arguments as well as return types. An argument whose type is not in the schema, or that can never be built from a query variable because its GraphQL type is registered against a different dotnet type (AddTypeMapping is one-way), now fails at validate time naming the dotnet types and the fix, instead of on the first request with a message naming only the GraphQL types. Built-in mappings and list arguments are unaffected. Validate() is opt-in - call it once your schema is set up, see Validating your schema. A schema with either problem that passed Validate() before will now throw from it.
• A missing required argument on a field taking an arguments class is now reported by its schema name instead of its dotnet property name - missing required argument 'from', not 'From'. ArgType already used the schema name, so the two validation paths disagreed and a query missing one argument could produce both spellings. Reading the capitalised name naturally suggests the schema stopped applying SchemaFieldNamer to arguments, which sends you looking in the wrong place entirely.
• Variable or value used for argument 'x' does not match argument type 'Y' on field 'z' now carries the reason the value could not be built (e.g. Object must implement IConvertible.) when the schema is in development mode or the exception is allowed via AllowedExceptions/AllowedExceptionAttribute. Both types in that message are GraphQL types and are frequently the same on each side, so the message could describe a conversion failing between two dotnet types while naming neither - the underlying exception was caught and discarded. Messages outside development are unchanged. ISchemaProvider.IsAllowedException(Exception) is new (it was already the private gate behind AllowedExceptionMessage) - custom ISchemaProvider implementations need to add it.

6.1.1

Fixes

• Fixed ResolveBulk fields selected through a fragment spread or inline fragment failing with KeyNotFoundException (The given key 'bulk_Type.field' was not present in the dictionary) anywhere below a list-to-single selection - e.g. a mutation returning ctx.Things.First(...) selected as thing { child { ...ChildFields } }, or thing(id: 1) { ...ThingFields }. Apollo/Relay clients hoist selections into named fragments, so this showed up as soon as a bulk field was used from a real frontend. A fragment spread is parsed with the parent of the node it is spread on, so the "is this field selected directly on a list-to-single node?" check read the wrong node: bulk loading was skipped for the field while the second pass still compiled the lookup, leaving it reading data that was never loaded. Both the registration and the lookup now ask the compile context which node is compiling its selection set, so they always agree, and the per-compile copy of a list-to-single node keeps its to-single marker instead of looking like a plain list selection. A bulk field selected via a fragment directly on a list-to-single field now uses the per-item resolver, matching how it already behaved when selected directly. Repro and regression tests from #536 - thanks @alex-birch.

6.1.0

Changes

• New report-only mode and logging hook for query limits: ExecutionOptions.QueryLimitsMode (Enforce, the default, or ReportOnly) and ExecutionOptions.OnQueryLimitExceeded callback (or register an IQueryLimitObserver in the service provider for DI-injected observers - the explicit callback wins when both are present) with the limit kind, actual vs maximum value and operation name. ReportOnly reports the query's real depth/counts and lets the query execute. Use it to observe real client behavior, then flip to Enforce with confident numbers. The callback also fires in Enforce mode just before rejection, so enforced rejections can be logged with structured detail instead of matching error message text. Fully additive - defaults are unchanged.

Fixes

• Custom directives (DirectiveProcessor.VisitNode) that return a rebuilt field node no longer lose root-field handling - position-derived state (IsRootField) is now preserved on the returned node automatically. Previously a rebuilt root list node fell into nested-field handling on the second (services) pass and the engine tried to re-apply the root list expression (e.g. WhereWhen/OrderBy) against the already-materialised first-pass result, failing with No generic method 'WhereWhen' on type 'Queryable'.... Repro and regression tests from #527 - thanks @alex-birch.
• Multiple node-modifying directives on one field now chain correctly - each directive receives the previous directive's result instead of all receiving the original node (previously only the last directive's rebuild took effect), and a null (excluded) result short-circuits so a later directive cannot re-include a field excluded by e.g. @skip.
• Fixed ResolveAsync<TService>() fields returning an object type with sub-selections (e.g. widget(id: ...) { id name }) not propagating a null resolver result to the field - the response held a non-null object with default/null sub-fields instead of a null field. The two-pass service-field execution rebuilds the field's expression with contextChanged: true, which was used as a (incorrect) proxy for "this field's value is already resolved, not still a raw Task<T>" - for a field whose own resolver is the async work (not a value read back from a prior pass), the expression here is still genuinely Task<T> even though contextChanged is true, so the code built the object selection directly against the Task<T> parameter instead of its awaited result, and Expression.Call silently bound to the wrong (synchronous, always-"not null") overload of ProjectWithNullCheck. Now checked via the expression's actual type (IsAwaitableGenericType()) instead of contextChanged. .Resolve<TService>() (the sync API wrapping .GetAwaiter().GetResult()) was unaffected.

6.0.1

Fixes

• Package dependencies now use per-target-framework versions - the net8.0 build asks for Microsoft.Extensions.Logging.Abstractions/System.Runtime.Caching 8.x and net9.0 for 9.x, instead of all target frameworks demanding 10.x. 6.0.0 forced net8/net9 consumers onto 10.x runtime libraries, which collided with other packages' version bounds (e.g. NU1608 warning floods via transitive System.Diagnostics.DiagnosticSource where a dependency caps it below 9.0). No API changes.

6.0.0

EntityGraphQL 6.0 is the culmination of the 6.0.0-beta1 through 6.0.0-beta9 releases. The beta sections below carry the full, detailed lists of changes, fixes and migration notes - and see the upgrade guide for a consolidated migration path from 5.x.

6.0 Highlights

• GraphQL spec conformance - partial results per the spec (failing top-level fields no longer fail the whole operation), September 2025 GraphQL spec support (@oneOf, argument/input-field deprecation, document descriptions, stricter validation) and MapGraphQL() follows the GraphQL over HTTP spec by default.
• A real async model - ResolveAsync<TService>() fields, end-to-end CancellationToken support (into resolvers, mutations, subscriptions and the in-flight EF query), async database materialization for root list fields, and concurrency control per field, per service and per query (MaxQueryConcurrency defaults to 100).
• Security hardening - authorization fails closed, introspection respects authorization, a parser recursion backstop against deeply-nested document DoS, opt-in query guards (MaxQueryDepth, MaxFieldSelections, MaxFieldAliases, MaxQueryComplexity) and per-field rate limiting.
• New schema-building features - UseAggregate() for SQL-translated aggregates over collections, AddFieldsFrom<T>()/AddQueryFieldsFrom<T>() to group field definitions into classes, filter improvements (GraphQL variables, service fields, selectMany, filtering by paged child fields) and async subscription setup for external brokers.
• Performance - paging answers hasNextPage with a cheap EXISTS instead of COUNT(*), async result processing is compiled and targeted (~2x faster on async-heavy results), opt-in compiled-delegate caching, and WebSocket subscription delivery is ordered and non-blocking.
• Modern targets - net8.0, net9.0 and net10.0 with a dependency-light core package.

Breaking Changes from Beta 9

• MapGraphQL() HTTP status codes now fully follow the GraphQL over HTTP spec for the application/graphql-response+json media type (the default response type): a response with no data entry (a request error - e.g. document parse/validation failure) returns 400 instead of 200, and a response with both data and errors (partial success) returns 294 per the spec. Clean results remain 200. Responses negotiated as legacy application/json keep returning 200 for every well-formed request. Clients following the spec read the response body regardless of status code for application/graphql-response+json.

• AddFieldsFrom<TFrom>() / AddQueryFieldsFrom<TType>() (introduced in beta 9) now require the grouping class to implement the new IFieldsFor<TContext> marker interface declaring which type its [GraphQLField] methods are written against - the entity type for schema.Type<Person>().AddFieldsFrom<T>(), the query context for AddQueryFieldsFrom<T>(). Registering a class against the wrong schema type is now a compile error instead of a schema-build surprise, and the marker gives compile-time tooling the intended context type. The interface is contravariant, so a fields class written for a base type or shared interface can be added to types deriving from/implementing it. A class may also implement IFieldsFor<> for several contexts to group a feature across types (e.g. occupancy fields for Building, Floor and Space in one class) - each registration only adds the methods written for that context. See Grouping fields across multiple types. Migration: add : IFieldsFor<TheContextType> to each grouping class.

• A [GraphQLField] method parameter whose type is a schema entity type (and not the field's context type) now fails at schema build with a clear error instead of being silently classified as a DI service - that classification almost always meant a mistyped context parameter that resolved (or failed confusingly) at query time. The query context type is excluded (a DbContext parameter remains a service), and the new [GraphQLService] parameter attribute opts out for the rare case where an entity type really is a DI service.

Changes since Beta 9

• [GraphQLField] methods (via AddFieldsFrom<T>()/AddQueryFieldsFrom<T>() or static on a schema type) can now return an Expression<Func<TContext, ...>> instead of a value. The method is a factory invoked once at schema build time and the returned expression is registered exactly like AddField(...).Resolve(...) - a service-free expression composes fully into the database-bound pass (translates to SQL, only the columns it uses are selected), and extra expression parameters after the context are resolved as services with the standard two-pass execution and dependency extraction. The factory method itself takes no parameters. See Expression fields with AddFieldsFrom.

Bug Fixes since Beta 9

• Fixed ResolveBulk fields failing with KeyNotFoundException when selected via a fragment spread (...MyFragment) or an inline fragment (... on Type { bulkField }) - the bulk loader was never registered because fragments expand after bulk registration ran. Bulk fields are now registered through fragments at any nesting depth, the bulk list expression path is taken from the compile-time selection path rather than a field's parent-node chain (which for fragment-selected fields pointed at the fragment definition, not the selection point), and selecting the same bulk field both directly and via a fragment loads the data once, not twice.
• Fixed ResolveBulk fields failing when reached through a nested single-object navigation (e.g. tasks { project { createdBy } }) or a mutation result selection (e.g. mutation { updateTask { project { createdBy } } }) - single-object contexts are now wrapped for the bulk key batching, object navigations off a list context project per element, and the duplicate mutation result-selection path node is skipped by reference. Also released in 5.7.3. Thanks @alex-birch #526
• Fixed custom type converters (AddCustomTypeConverter) registered for a base type never matching values of derived types - the lookup was an exact type match, so the documented Newtonsoft pattern AddCustomTypeConverter<JToken>(...) never fired (JToken is abstract; runtime values are JArray/JValue/JObject), breaking e.g. list-of-enum variables sent through Newtonsoft.Json with Supplied variable can not be applied to defined variable type. From-type converter lookup now walks the base-type chain (the most derived registration wins).
• Fixed ResolveBulk fields reached through chained single-object navigations (e.g. projects { tasks { assignee { manager { bulkField } } } }) throwing Value cannot be null - the null-guard built while collecting the bulk keys assumed every navigation step was a list. Single-object steps are now null-guarded properly (a null parent yields null and is filtered before the bulk key selection). Also released in 5.7.3.

6.0.0-beta9

The final beta planned before 6.0.0.

Breaking Changes

• Dropped the netstandard2.1 target. EntityGraphQL now targets net8.0, net9.0 and net10.0. This also removes the System.Text.Json, Microsoft.CSharp and System.ComponentModel.Annotations package dependencies that only the netstandard target required.
• Security (fail closed) — authorization now denies by default when a requirement is present but cannot be satisfied. A bare [GraphQLAuthorize] / [Authorize] (no roles or policy) now correctly requires an authenticated user instead of being a silent no-op, and IsAuthorized requires Identity.IsAuthenticated. In EntityGraphQL.AspNet, a policy-protected field is now denied (rather than allowed through) when no IAuthorizationService is registered or the user is null. Fields/types with no authorization attribute are unaffected. This is a behavior change: previously-open access that relied on any of these gaps will now be blocked.
• Introspection now respects authorization — introspection queries (__schema / __type) only return the types and fields the requesting user is authorized to access, so anonymous users can no longer enumerate role/policy-protected type, field and argument names. schema.ToGraphQLSchemaString() is unchanged and always outputs the full schema (for SDL files / codegen). Note introspection output can now differ per user, which may affect schema-caching tooling running as an unprivileged user.
• ExecutionOptions.MaxQueryConcurrency now defaults to 100 (previously unlimited). An async field resolved for a list runs per item, so an unbounded default turned a large result set into an unbounded number of concurrent operations (socket/thread-pool exhaustion, hammering rate-limited APIs). Set MaxQueryConcurrency = null to restore unlimited. Note this does not make non-thread-safe services (e.g. a scoped DbContext) safe in async list fields — use ServiceConcurrencyLimits or maxConcurrency: 1 for those. Also fixed the concurrency wrapper for field shapes it previously failed on (value-type service parameters such as CancellationToken, rebound per-element parameters, nested list results — errors like unbound variable or No coercion operator), and IAsyncEnumerable fields are no longer wrapped (the stream's enumeration, not its creation, is the async work).
• API surface — LinqRuntimeTypeBuilder and ExpressionReplacer are now internal; ExpressionUtil.ListToSingleMethods is no longer public (it was a mutable static). GraphQLHelper.InjectServices gained optional parameters and accepts a null service provider. ConcurrencyLimitFieldExtension.ExecuteWithConcurrencyLimitAsync is now generic (<TResult>) so the wrapped expression keeps its static type.
• New GraphQL spec validations may reject previously accepted (invalid) documents — duplicate non-repeatable directives, conflicting field selection merges, @skip/@include on a subscription root field and deprecating a required argument are now errors. See the spec compliance entry under Changes.

Changes

• New schema.Query().AddFieldsFrom<T>() (and any object type) plus the schema.AddQueryFieldsFrom<T>() shortcut - group related field definitions into classes using [GraphQLField] marked methods instead of many AddField() calls. Method parameters of the declaring type bind to the field context (the query context for root fields - this also applies to existing [GraphQLField] methods on the context type, which previously resolved the context from the service provider), other complex types resolve as services and remaining parameters become GraphQL arguments. Methods returning IQueryable<T> compose with EF - filters and selections translate to SQL.
• Updated dependencies: Humanizer.Core 2.14.1 -> 3.0.10 (used for singularizing names when building schemas - inflection rule changes could alter a generated name in rare cases), Parlot 1.4.3 -> 1.5.7, System.Runtime.Caching and Microsoft.Extensions.Logging.Abstractions 9.0.9 -> 10.0.9.
• ParameterReplacer.ReplaceByType is marked obsolete and will be removed in 7.0 - it replaces any parameter of the matching type, which can capture parameters you did not intend. It remains functional in 6.x.
• Root-level list fields are now materialized asynchronously when the LINQ provider's query objects implement IAsyncEnumerable<T> - EF Core's do, so the database round-trip no longer blocks a thread and the request's CancellationToken can cancel the in-flight query. No EF dependency was added; in-memory data is enumerated synchronously as before. Note for ExecutionOptions.BeforeExecuting users: root list fields on the database-bound pass no longer end in an in-tree ToList() call - the deferred query is materialized after the expression executes.
• September 2025 GraphQL spec compliance (document descriptions, full Unicode and OneOf runtime behavior shipped in earlier betas):
  • __Type.isOneOf is now exposed per the spec (previously the non-standard name oneField). It is false for input object types, true for @oneOf types and null for other types.
  • __Directive.isRepeatable added to introspection (all built-in directives are non-repeatable). Custom IDirectiveProcessor implementations can override the new IsRepeatable property (defaults to false).
  • Using a non-repeatable directive more than once at a single location (e.g. @skip(...) @skip(...)) is now a validation error.
  • @skip/@include on the root field of a subscription operation is now a validation error per the spec.
  • Arguments and input fields can now be deprecated ([Obsolete] on an argument property or field.Deprecate(...) on an input field). They are hidden from introspection by default with new includeDeprecated arguments on __Field.args, __Directive.args and __Type.inputFields, __InputValue gains isDeprecated/deprecationReason, and the SDL output annotates them with @deprecated. Deprecating a required argument is a schema error per the spec.
  • Implements() now validates field covariance — a field on an implementing type must be the same type or a sub-type of the interface's field (only fields present at the time of the call are checked, so the add-fields-after-implements pattern is unaffected).
  • Field selection merging is now validated: selections with the same response name must be the same field with identical arguments ({ x: id x: name } or { project(id: 1) project(id: 2) } are errors — use different aliases), and across mutually exclusive fragments the response shapes must be compatible (... on Cat { value: lives } with ... on Dog { value: name } is an error).
• __type(name: ...) now returns null for an unknown type name per the GraphQL spec, instead of an execution error.
• Async result processing is now targeted and compiled instead of a full-result reflection walk: only branches of the result whose types can hold an async value are visited (non-async branches are returned untouched). On a 10,000-row result with one async field and non-async nested collections this cut request time from ~140ms to ~63ms in benchmarks (the no-async baseline being ~19ms). This also stops the walk reading every property of every result object, which could trigger EF lazy-loading of navigation properties the query never selected.
• Subscription events are no longer executed synchronously on the publisher's thread. Each subscription processes its events on an ordered background queue - observer.OnNext returns immediately instead of blocking while the (potentially async/service-backed) result selection executes for every subscriber. Event order per subscription is preserved, including the terminal error/complete messages.
• Policy evaluation is now truly async — PolicyOrRoleBasedAuthorization pre-evaluates all policies used in the schema once at the start of each request (properly awaited) instead of blocking with sync-over-async AuthorizeAsync calls per field/type check during compilation. New optional IGqlAuthorizationService.PrepareForRequestAsync hook (has a default implementation — custom implementations are unaffected).
• WebSocket hardening — new GraphQLWebSocketOptions (optional parameter on UseGraphQLWebSockets): incoming messages larger than MaxMessageSizeBytes (default 1 MB) close the connection with 1009 MessageTooBig instead of buffering unbounded; malformed JSON closes with 4400 instead of throwing out of the receive loop; and clients that never send connection_init are closed with 4408 after ConnectionInitTimeout (default 10s) per the graphql-ws protocol.
• Security (DoS) — the GraphQL document parser now enforces a hard recursion-depth backstop of 128 (nested selection sets and nested argument/input values) during parsing, returning a DocumentError before a maliciously deep document can exhaust the stack. This runs independently of, and before, the configurable ExecutionOptions.MaxQueryDepth.
• Hardening: the dynamic (projection) type cache now uses a full, collision-free key (field names, field types and parent type) instead of a 32-bit hash, removing an unlikely-but-possible hash collision handing a query a cached type with the wrong fields.

Bug Fixes

• Fixed a compiled-delegate cache key collision when CacheCompiledDelegates is enabled and an operation has multiple root fields - the second root field was served the first field's compiled delegate, returning the wrong field's data. The cache key now includes the root field name.
• Fixed async argument validators (IArgumentValidator via AddValidator<T>()) being fire-and-forgotten — a validator doing real async work before adding its errors raced the request and its errors could be silently lost. Validators are now stored as async delegates and genuinely awaited for mutation and subscription arguments. Note validators on query field arguments still run during (synchronous) query compilation — avoid I/O in those. Breaking: IField.Validators is now IReadOnlyCollection<Func<ArgumentValidatorContext, Task>>.
• Fixed per-request state being written onto the cached query document (EnableQueryCache, on by default) during execution. Concurrent requests of the same query text share the parsed document; the dynamic types built for an interface/union selection during a request's first (database) pass were stored on the shared AST node and read in its second (services) pass, so an interleaved request whose @include/@skip variables expanded a different selection could poison another request's second pass — failing it with No coercion operator is defined between types ... or silently dropping fragment fields. That state now lives on the per-request compile context, and mutations returning lists no longer write their per-request parameters onto the shared selection node.
• Fixed SchemaBuilder.FromObject registering an abstract base class as an interface but not linking its implementing types to it (unless AutoCreateInterfaceTypes was on). The half-configured schema made inline fragments on the interface silently mis-project — animals { ... on Cat { lives } } returned the whole Cat object for lives instead of the value. FromObject now links every object type to any of its base types/interfaces that are registered in the schema as interfaces, regardless of the order the types were discovered in.
• Fixed @include(if: $variable) / @skip(if: $variable) on an inline fragment failing with Variable or value used for argument 'if' does not match argument type 'Boolean!'. The parser executed inline-fragment directives at parse time — before variable values exist (literal values worked). Directives on inline fragments are now processed at execution time like field directives.
• Async result processing fixes: a Dictionary<,> value in a result with async fields now stays a dictionary (previously it was turned into a list of key/value pairs, changing the serialized shape); user types that happen to live in an EntityGraphQL.* namespace are no longer treated as the engine's internal projection types and rebuilt; a non-generic ValueTask value is awaited instead of being walked as an object.
• Mutation and subscription methods can now declare a CancellationToken parameter and receive the executing request's token (previously this failed with a service-not-found/argument error, despite query field resolvers supporting it). The parameter is not exposed as a GraphQL argument.
• Fixed UseFilter()/UseSort() being silently ignored on a nested field whose own resolver is service-backed (e.g. schema.Type<Project>().AddField(...).Resolve<Service>(...).UseFilter()). Such a collection only exists in the services execution pass, where both extensions assumed the filtering/sorting had already happened in the first (database) pass — the query returned unfiltered/unsorted data with no error. Root-level service-backed fields were unaffected.
• Fixed three issues in the async field concurrency limiting (maxConcurrency / MaxQueryConcurrency / ServiceConcurrencyLimits): the per-request CancellationToken and limiter registry were baked into the expression as constants, so with CacheCompiledDelegates on, request 1's token lived inside the cached delegate and, once cancelled, failed every later request of that query (they are now passed as per-request execution parameters); a cancelled semaphore acquire leaked the permits already acquired (acquisition now happens inside the try/finally); and the wrapped operation lambda was compiled per list element (now compiled once per expression and cached).
• Fixed the (opt-in) CacheCompiledDelegates cache key hashing variable values with ToString(). Collection values (List<>, arrays, Dictionary<,>) stringify to their type name — identical for different contents — so two requests differing only in such a variable (e.g. a sort input) could share one cache entry and the second request would be served the first request's compiled plan (wrong ORDER BY field/direction). Values are now hashed by content, and a request whose variable values cannot be represented by value skips delegate caching for that request instead of risking a wrong-plan hit.
• Fixed bulk resolvers (ResolveBulk) leaking across sibling root fields. In a query with multiple root fields, a bulk resolver registered while executing one root field was re-run during each following root field's execution — re-calling the service (extra bulk loads) and, when the sibling's data had a different shape, failing that field with Could not find field egql__... on type ....
• Fixed an operator-precedence bug in filter expression compilation that mis-detected string conversions: comparing a DateTime/DateTimeOffset/TimeSpan/DateOnly/TimeOnly field to a nullable value of the same type failed to compile, and a Guid vs Guid? comparison was built as Guid.Parse(x.ToString()) (in-memory only, not translatable to SQL). These now use simple nullable promotion.
• #378 - Filtering by a paged child field now works. Within a filter expression a field using UseOffsetPaging()/UseConnectionPaging() resolves to its underlying collection (the page wrapper only exists in the GraphQL schema), so enquiries(filter: "enquirerDaps.count() > 0"), "enquirerDaps.items.count() > 0" (items/edges are the collection) and "enquirerDaps.totalItems > 0" (totalItems/totalCount map to Count()) all compile and translate to SQL under EF. Previously these failed with Method 'count' not found on current context 'OffsetPage' or a NullReferenceException. Other page metadata (e.g. hasNextPage) raises a clear error when used in a filter.

6.0.0-beta8

New Features

• Added the UseAggregate() field extension for exposing aggregate data over a collection field — count plus min/max/sum/average over its fields, computed over the whole collection and translated to a single SQL query under EF. The shape is function-first: { count, min { fieldA }, max { fieldA }, sum { fieldA }, average { fieldA } }. min/max apply to any orderable field (numbers, dates, strings); sum/average to numerics (short, int, long, float, double, decimal and nullable forms). Aggregates over an empty set return null.
  • Placement is controlled by AggregatePlacement and defaults to Auto: a paged field attaches an aggregate field to the paging result (PagingWrapper), otherwise the field is wrapped as { items, aggregate } (OwnWrapper), which handles every field uniformly including service-backed resolvers and custom arguments. An additive sibling {field}Aggregate field (SiblingField) is available as an opt-in so aggregates can be added to an existing field without a breaking shape change; it carries the source field's arguments (filter and custom resolver arguments) but cannot be used on a service-backed collection resolver.
  • Pass a field selection to restrict the aggregatable fields, e.g. UseAggregate((Person p) => new { p.Height, p.Age }).
• A scalar field whose resolver reduces a collection using a service (e.g. (db, svc) => db.People.Sum(p => svc.Score(p.Id))) now executes via the two-pass model — the element values the service needs are projected and materialized in the first (DB) pass, and the reduction runs in memory in the second — instead of failing to translate under EF.
• UseAggregate can aggregate a service-backed element field (e.g. person.score resolved via Resolve<Service>(...)). The per-element service values are projected/materialized in the first pass and reduced in memory in the second, so aggregate { sum { score } } works under EF.
• Aggregating a bulk-resolved element field (ResolveBulk) uses the bulk loader: the keys are projected/materialized in the first pass and all values are fetched in a single bulk call in the second, then reduced in memory — so it doesn't fall back to one service call per element. (Sync, no-argument bulk resolvers; async/argument bulk resolvers use the per-element fallback.)

Changes

• Paging performance: hasNextPage no longer runs a COUNT(*) query when the total isn't otherwise needed. UseOffsetPaging (when totalItems isn't selected) and UseConnectionPaging (forward paging with a pageInfo selection of only hasNextPage/hasPreviousPage) answer it with a cheap EXISTS query — skip past the current page and check for any row. Selections needing the total (totalCount/totalItems, endCursor/startCursor, or the last/before arguments) behave as before.
• Connection paging cursor assignment no longer evaluates the (dynamic) cursor arguments per row — the cursor base is computed once per request (ConnectionHelper.ApplyCursors) and each edge's cursor derived from it while enumerating.

6.0.0-beta7

Bug Fixes

• Fixed ArgumentNullException ("Value cannot be null. (Parameter 'type')") when a service-resolved field on a parent type was queried together with a child collection field whose type uses AddTypeMapping to map a CLR type to a GraphQL list type (e.g. AddTypeMapping<NpgsqlPolygon>("[Point!]!")). The two-pass execution failed to infer the list element type for a non-generic CLR type that implements IEnumerable<T>.

6.0.0-beta6

Breaking Changes

• #515 - DefaultGraphQLResponseSerializer and DefaultGraphQLRequestDeserializer default JsonSerializerOptions now use JsonSerializerDefaults.Web. For the request deserializer this enables case-insensitive property matching and reading numbers from JSON strings. The response serializer's output is unchanged (it was already camelCase).
• ExecutionOptions.MaxQueryNodes renamed to MaxFieldSelections — it counts field selections (the GraphQL spec term) after fragment expansion, not AST or result nodes.
• ExecutionOptions.UserKeySelector renamed to RateLimitUserKeySelector to reflect that it only affects per-field rate limiters tagged userSpecific: true.

6.0.0-beta5

Breaking Changes

• AddGraphQLOptions<TContext> now exposes overloaded ConfigureSchema(...) methods instead of settable schema-configuration delegate properties. Use options.ConfigureSchema(schema => { ... }) for the common case, or options.ConfigureSchema((schema, services) => { ... }) when schema setup needs the active IServiceProvider.
• AddGraphQLSchema() in EntityGraphQL.AspNet now returns a dedicated GraphQLSchemaBuilder<TContext> instead of IServiceCollection. Schema-shape customization should now be chained with ConfigureGraphQLSchema(...), for example:
  • services.AddGraphQLSchema<MyContext>(options => { ... }).ConfigureGraphQLSchema<MyContext>(schema => { ... });

Changes

• #508 - Added a src/examples/tooling example showing GraphiQL and Hot Chocolate Nitro hosted against an EntityGraphQL.AspNet /api/graphql endpoint.
• Query/document errors now preserve structured source locations in addition to the existing message text, and GraphQLError responses now emit locations metadata when available. Also normalized invalid field-directive registration to throw EntityGraphQLSchemaException instead of InvalidOperationException on the public schema API surface.

6.0.0-beta4

Breaking Changes

• Simplified IFieldExtension compilation hooks by replacing long positional parameter lists with context objects:
  • GetExpressionAndArguments() now takes FieldExtensionExpressionContext
  • ProcessExpressionPreSelection() now takes FieldExtensionPreSelectionContext
  • ProcessExpressionSelection() now takes FieldExtensionSelectionContext

Changes

• #513 - AddGraphQLSchema() now supports configuring the registered SchemaProvider<TContext> lifetime via AddGraphQLOptions.SchemaLifetime. The default remains singleton, with scoped/transient lifetimes available for request-specific schema construction.

Fixes

• #498 - fix ExecutableDirectiveLocation naming regression introduced in beta3

6.0.0-beta3

Breaking Changes

• Fields in ExecutableDirectiveLocation enum have been renamed in C# style
• #476 - Introduce generic custom type converters (from-to, to-only, from-only) for flexible runtime value conversion.
  • Expand isAny to support additional types through the method provider
  • Removes ICustomTypeConverter. See updated docs and the more flexible converting methods available
• Renamed SchemaBuilderSchemaOptions to SchemaProviderOptions for better clarity between schema builder reflection options and schema provider configuration options
• AddGraphQLOptions<TSchemaContext> refactored from inheritance to composition:
  • Now exposes Builder property for SchemaBuilderOptions (controls building/reflection behavior)
  • Now exposes Schema property for SchemaProviderOptions (controls schema provider configuration like authorization, introspection, error handling, field naming)
  • Removed FieldNamer property - now accessed via options.Schema.FieldNamer
  • PreBuildSchemaFromContext moved from SchemaProviderOptions to SchemaBuilderOptions - now accessed via options.Builder.PreBuildSchemaFromContext (it's called during the schema building phase, not runtime)
• Removed introspectionEnabled parameter from AddGraphQLSchema extension method - configure via options.Schema.IntrospectionEnabled instead
• Authorization refactoring: RequiredAuthorization now uses a keyed data structure for extensibility
  • RequiredAuthorization no longer has separate Roles backing field - roles are stored via "egql:core:roles" key in KeyedData dictionary
  • The Roles property is now nullable and computed from keyed data
  • Policy support moved entirely to EntityGraphQL.AspNet package using "egql:aspnet:policies" key
  • RequiredAuthorization constructor that took roles parameter has been removed - use RequiresAnyRole() or RequiresAllRoles() methods instead
  • Custom authorization implementations should use namespaced keys (e.g., "myapp:custom-auth") to avoid conflicts
• Added withoutServiceFields parameter to IFieldExtension.GetExpressionAndArguments() to allow extensions to know when they're in the first pass of two-pass execution and should skip service-dependent expressions.

Changes

• Added pre-execution query guards (MaxQueryDepth, MaxQueryNodes, MaxFieldAliases, MaxQueryComplexity) to ExecutionOptions. All default to unlimited (opt-in). A limit violation returns a GraphQL DocumentError and prevents any resolver from running. Configure in ExecutionOptions in your call to schema.ExecuteRequest(...).
• Added complexity scoring via field.SetComplexity(int) (fixed cost) or field.SetComplexity(ctx => ctx.Args.take * (1 + ctx.ChildComplexity)) (args-aware). Pluggable via IQueryComplexityAnalyzer / ExecutionOptions.QueryComplexityAnalyzer.
• Added per-field rate limiting via field.AddRateLimit("policy-name"). EntityGraphQL.AspNet ships a PartitionedRateLimiter-backed default registered with services.AddGraphQLFieldRateLimit(opts => { opts.AddFixedWindowPolicy(...); opts.AddConcurrencyPolicy(...); ... }). Rate limits count per-selection (aliases each burn a permit) and support userSpecific: true partitioning by user key.
• Added support for document descriptions as outlined in the latest 2025 spec. Basically string comments in the query document
• #474 - Add support for TimeSpan as a scalar in the default schema
• #500 - Expose parsed executable directive metadata via BaseGraphQLField.Directives by making GraphQLDirective.Name and GraphQLDirective.Processor public for custom query processing scenarios
• Replaced the previous 3rd party GraphQL document parser.
• Add net10.0 as a target
• When using Offset Paging the total items expression is now only executed if the query requests hasNextPage or totalItems fields
• When using Connection Paging the total count expression is now only executed if the query requests totalCount or pageInfo fields or the 'last' argument is used
• Added IField.AsService() to signal that a field should (or can) be treated as a service field. This means null-checks are differently and they are executed after EF related calls (if ExecutionOptions.ExecuteServiceFieldsSeparately = true). Useful for fields that operate with data fully in-memory and do not need a registered service to fetch data or work
• AddGraphQLSchema in ASP.NET now automatically detects and applies environment-based defaults:
  • Uses PolicyOrRoleBasedAuthorization by default (instead of requiring explicit configuration)
  • Automatically sets IsDevelopment = false in non-Development environments
• Subscription fields now support Task<IObservable<T>> and ValueTask<IObservable<T>> as return types in addition to IObservable<T>. This allows subscription setup methods to be async, which is useful when subscribing to an external message broker (Redis, RabbitMQ, etc.) requires an async connection step.

Fixes

• Rewrote WebSocket subscription send path (GraphQLWebSocketServer) to use a Channel-backed drain task. All outbound frames are now serialised through a single writer, eliminating the concurrent WebSocket.SendAsync violation that could corrupt the frame stream when multiple subscriptions fired simultaneously. The IObserver<T> callbacks (OnNext/OnError/OnCompleted) now enqueue to the channel rather than blocking on GetAwaiter().GetResult(), freeing the observable/Redis thread immediately. subscriptions dictionary replaced with ConcurrentDictionary for thread-safety.
• Fixed SelectWithNullCheck error when using .ResolveAsync<TService>() on a field that returns a list of complex objects with subfield selection (e.g. toolCatalog { name }), where the parent field returns a single object. In the two-pass execution path the element-type parameter was incorrectly derived from Task<IEnumerable<T>> rather than T, and the resolved collection was not preserved as a typed List<T> when rebuilding the async result graph.
• #498 - Fixed introspection types and fields incorrectly using the configured FieldNamer. Spec-defined introspection names now remain standard camelCase even when the application schema uses a custom naming convention.
• #486 - Fixed directives on root-level fields failing to resolve query variable arguments (e.g. @include(if: $var)). OpVariableParameter and docVariables were not being passed through to directive evaluation in GraphQLQueryStatement, causing any directive that references a variable to throw a type-mismatch error.
• #481 - handle ResolveAsync on a top level field
• #488 - Support async fields with [GraphQLField]
• #487 - Fix ResolveAsync with arguments
• #484 - Better support for nullable numeric types in filter expressions. Nullable int/short/long fields can now be compared to numeric literals without type mismatch errors. The fix also prioritizes converting literals over field expressions to avoid database column casts that could prevent index usage.
• #459 - Fixed error "variable 'service' ... is not defined" when using Resolve<TService>() directly on a field that also uses UseConnectionPaging() or UseOffsetPaging(). When the paging field's own resolver depends on a service, the field now falls back to single-pass execution so the service parameter is always in scope. Fields with services on child types (not the paging field itself) continue to use the normal two-pass execution path where the DB query runs first and the service is resolved in-memory against the paged results.
• As per spec - _Type.fields should be null for INPUT_OBJECT. Previously the inputFields were repeated.

6.0.0-beta2

Changes

• Added selectMany method support to filter expressions, enabling flattening using nested collections within queries.

Fixes

• Fixed (maybe a regression introduced in 6.0.0-beta1) UseFilter() incorrectly adding a default value to the filter argument when applied to fields that already have other arguments defined.

6.0.0-beta1

Breaking Changes

• Support for partial results as per spec. This actually fixes EntityGraphQL to follow the GraphQL spec regarding partial results. However it does change behavior.

  • EntityGraphQL basically executes each "top level" field in the operation separately, now if any fail, you'll get the partial results of those that succeeded and error information about the failed ones.
  • AddGraphQLValidator now registers IGraphQLValidator as Transient. This was the original intent as the docs have examples of bailing early by checking if the validator has any errors. The intent was errors for that field. This change helps enable partial results. If you want the old behavior, remove the use of AddGraphQLValidator and just add IGraphQLValidator yourself as Scoped
  • As per spec If an error was raised during the execution that prevented a valid response, the "data" entry in the response should be null. This was not always the case

• Removed methods/properties marked as obsolete

  • IField.UseArgumentsFromField use GetExpressionAndArguments
  • IField.UseArgumentsFrom use GetExpressionAndArguments
  • IField.ResolveWithService use Resolve
  • IFieldExtension.GetExpression use the new GetExpressionAndArguments

• MapGraphQL followSpec = true is now the default behavior, it follows https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md

• You can no longer add filter support by using ArgumentHelper.EntityQuery or EntityQueryType in the field args, e.g. schemaProvider.Query().ReplaceField("users", new { filter = ArgumentHelper.EntityQuery<User>() }, "Users optionally filtered"). Please use the UseFilter extension which supports filters referencing service fields.

• IFieldExtension.GetExpressionAndArguments now takes the current GraphQL node BaseGraphQLField fieldNode as an argument. parentNode has been removed. Access it via fieldNode.ParentNode.

• EntityGraphQL.AspNet package drops net6.0 and net7.0 as targets. EntityGraphQL package drops net6.0 as a target however as it still targets netstandard2.1 you can still use it with those previous dotnet versions.

Changes

• Partial results support
• #467 - New implementation for handling async fields. See updated docs and use the .ResolveAsync<>() methods when adding fields.
• New support for CancellationToken. A CancellationToken can be passed into the ExecuteRequestAsync method. The token will be checked throughout execution and passed to other async operations. You can use it in .ResolveAsync<MyService, CancellationToken>((context, service, ct) => service.DoSomethingAsync(context.Field, ct)) to pass it to your async fields. If you use MapGraphQL() for ASP.NET it will use the context.RequestAborted as the cancellation token.
• #469 - Make filter grammar immutable as it should be for performance
• #303 - You can now reference service fields in the UseFilter/[UseFilter] expression. Like normal the filter will first be applied with non service fields, then applied again with service fields is ExecutionOptions.ExecuteServiceFieldsSeparately == true (default).
• #396 - Filter expressions now support GraphQL variables using $variableName syntax. This allows parameterized and dynamic filters (e.g., filter: "name == $searchTerm && age > $minAge").
• Related to #331 and the followSpec = true above, errors and exceptions were refactored internally. Following the GraphQL spec if the core library gets an error it will still return a GraphQLResult with the errors (and potentially partial results).

Fixes

• #429 Validation attributes now work with [GraphQLInputType]

5.7.3

Fixes

• #526 - Fixed ResolveBulk fields failing when reached through a nested single-object navigation (e.g. tasks { project { createdBy } }) or a mutation result selection - single-object contexts are now wrapped for the bulk key batching, object navigations off a list context project per element, and null navigations anywhere in the chain no longer throw. Thanks @alex-birch

5.7.2

Fixes

• #512 - Updated HotChocolate.Language dependency from 13.9.14 to 13.9.16 to resolve critical vulnerability (GHSA-qr3m-xw4c-jqw3: stack overflow via deeply nested GraphQL documents)

5.7.1

Fixes

• #466 Include enum-typed input fields in introspection per GraphQL spec

5.7.0

Changes

• QueryInfo Support: Added optional query execution information that can be included in the result extensions. Enable with ExecutionOptions.IncludeQueryInfo = true to get metadata about:
  • Operation type (Query, Mutation, Subscription)
  • Operation name
  • Types queried and their selected fields
  • Total number of types and fields queried
  • This is useful for query analysis, debugging, and monitoring GraphQL usage patterns
• Fix #441 (PR #455) - Have your argument class (including an InputType) class inherit ArgumentsTracker or implement IArgumentsTracker to be able to tell if a variable is just the dotnet default value or is set from the query (variable or inline) with args.IsSet. You can also include IArgumentsTracker as an argument in your mutations etc. This is useful if you method usings simple arguments e.g. MyMutation(Guid id, string name) vs. a [GraphQLArguments] object.
• #461 - EntityGraphQLEndpointRouteExtensions.MapGraphQL now supports chunked requests
• RequiredAuthorization is not settable allowing you to change or overwrite it after creation. Also now has Clear() methods to remove authentication

Fixes

• Throw error on a query that has fragments with a cycle as per the GraphQL spec and to prevent infinite loops.
• #442 - Fix issue when a service field with a bulk resolver is on a parent field named differently to the dotnet underlying object property

5.6.1

Fixes

• #443 - Allow */* & application/* Accept headers in followSpec option for MapGraphQL
• #443 - Allow expected headers to not be listed first when using followSpec option for MapGraphQL
• Better support for multiple items in a single Accept header when using followSpec option for MapGraphQL
• #449 - Fix issues with self referencing query and connection paging

5.6.0

Changes

• Added additional framework target net9.0
• ResolveWithService and ResolveWithServices methods are now marked obsolete. Please use Resolve in the same way
• #430 - MapGraphQL has new parameter followSpec which changes the behavior to follow https://github.com/graphql/graphql-over-http/blob/main/spec/GraphQLOverHTTP.md and is false by default in v5.x. If set to true it will follow the spec, the major change being that if the HTTP request was valid you'll get a 200 status code even if there may be GraphQL errors in the response. Note this will be the default behavior in version v6.
• Add IsNullable to the IField interface to control setting the nullability of the field return type in the schema

Fixes

• #435 - fix isAny() in filter
• Fix issue selecting fields from an object a service field returns where the GraphQL field name differs from the dotnet property name.

Example a field that returns a User type using a service and you are changing the field names in the schema like below

schema.Type<User>().AddField("username", u => u.Name, "Username")

• #439 - Fix using fields / properties with key words (null, true, false) at the start of the name in the filter expressions
• Related to #430 - Make sure if the schema says a field is not nullable, that it is not returned as null when using null to exit a mutation or field on error.
• Fix issue where an expression extracted from a service field may clash with a existing field name

5.5.3

Fixes

• #432 - filter expression was incorrectly using bit-wise Or instead of OrElse

5.5.2

Fixes

• #418 - Fix issue where field expressions using ctx.Entities.FirstOrDefault(<filter>) (First*, Last*, Single* methods with a filter) would duplicate the filter expression on each execution (e.g. making ctx.Entities.Where(<filter>).Where(<filter>).FirstOrDefault()). This also caused EntityFramework not to use it's cache for the expression
• Fix issue with RequiresAnyRole() being called on a field with multiple roles added them as requiring all those roles vs. any role. This did not effect the [GraphQLAuthorize] attribute

5.5.1

Fixes

• #425 - As per GraphQL Spec, Interfaces are not supported for Input Types
• #426 - Fix custom directives with no arguments.
• #427/#428 - Fix issue with connection style paging field extension when using last and before arguments

5.5.0

Changes

• Add IgnoreAttributes to SchemaBuilderOptions - A list of Attribute types which will cause the builder to ignore the field/property when building the schema. These are additional to GraphQLIgnoreAttribute
• .Resolve<>() method on field changes return type to object? to avoid warnings when returning a valid nullable service call etc.
• Add support for using a struct type as an object type in the schema, allowing you to query the fields on it. Previously it only worked if you added the struct as a Scalar Type
• #419 - Add support for using isAny([]) on nullable types

Fixes

• Make sure top level types have access checked (Query, Mutation and Subscription)
• Fix #392 - Better handle null checks when executing against in-memory data
• #363 - Only use ToListWithNullCheck when we know we are executing with services, or have been told not to separate the execution.

5.4.6

Fixes

• Fix issue with inline arguments for mutation methods not being validated or trying to look for a service. e.g.

[GraphQLMutation]
public static Expression<Func<MyContext, Movie>> AddMovie(
    [Required(ErrorMessage = "Title is required")] string title,
    [Range(1, 100, ErrorMessage = "Price must be between $1 and $100")] decimal price,
    [StringLength(5, ErrorMessage = "Rating must be less than 5 characters")] string rating
)

5.4.5

Fixes

• Fix auth not correctly being checked for mutations or subscriptions. Issue was introduced in 5.4.2

5.4.4

Fixes

• Argument validator was incorrectly traversing types and properties it shouldn't which could cause stack overflows for some types
• Fix validating inline arguments for mutation methods

5.4.3

Fixes

• #399 - Serialize null values if the field is requested as per the GraphQL spec
• Make sure the naming policy set in DefaultGraphQLResponseSerializer is used for all fields

5.4.2

Fixes

• #393 - Handle DateTimeOffset in filter expressions
• #398 - Make sure user credentials are not cached if using the compiled query cache

5.4.1

Fixes

• #370 - Sort field extension ([UseSort] or .UseSort()), if building the sort argument input type from the dotnet fields/properties will now respect the [GraphQLIgnore] attribute on any fields.
• #386 / #387 - Fix regressions in filter expressions

5.4.0

Changes

• #367 - Remove Antlr dependency for generating the filter expression parser. Replaced with Parlot, a dotnet only solution to remove a barrier for contributors. This also results in the filter (FilterExpression field extension) expressions being compiled up to twice as fast.
• #334 - add isAny([]) method to the filter expression language
• Broadcaster exposes its properties and methods are virtual allowing you to extend its functionality instead of writing your own fully
• #374 - Sort field extension now has an useSchemaFields option. This will use the fields on the type you are sorting from the schema to build the input argument. Instead of the fields on the dotnet type. Because the input type is build once at the beginning it will only include schema fields currently known at the time you call .UseSort().
• #375 - Allow specifying introspectionEnabled when calling the AddGraphQLSchema extension methods
• #222 - EntityGraphQL can now build a argument objects via their constructor. The parameter names need to match the field names. E.g.

// empty constructor - the properties set are called
public class PersonArg
{
    public string name { get; set; }
}

// with a constructor
public class PersonArgConstructor
{
    public PersonArgConstructor(string name)
    {
        Name = name;
    }

    public string Name { get; }
}

Fixes

• Fix issue where a subscription execution had access to a disposed IServiceProvider
• Broadcaster is thread safe when removing observers
• Fixes in the implementation of the GraphQL over Websockets
  • ID is now a string as it does not specify that it must be a Guid
  • Better errors on invalid messages

5.3.0

Changes

• ISchemaProvider.Validate() added to allow you to validate the schema is complete to avoid potential errors at runtime/query time. As fields and types can be added to the schema out of dependency order, this checks that all required types are in the schema.
• #362 - The Sort field extension now supports defining more complex sort expressions that will be used. E.g.

schema.Type<TestDataContext>().GetField("people", null)
  .UseSort((Person person) => new
  {
    // [{managerName: ASC}] in GQL can be used and the full expression person.Manager.Name will be used in the OrderBy()
    managerName = person.Manager.Name,
  });

• #169 - ExecutionOptions now has a BeforeRootFieldExpressionBuild callback you can use to make modifications to a fields expression before it is then used to build the whole query. This is only called for root fields in your GraphQL operation. A common use case for this might be to call the EF TagWith extension method passing it the operation name to help with debugging queries.

• #308 - Support a dotnet Type being used for an input type and a query type. This may change in future versions but some simple cases are now supported

• IField.UseArgumentsFrom & IField.UseArgumentsFromField is now Obsolete. Using it (typically in a field extension) creates issues. See #358 fix below

• IFieldExtension.GetExpressionAndArguments has been added to allow field extensions to handle arguments and add them to the compile context. This interface will merge with the existing (now obsolete) IFieldExtension.GetExpression in version 6.0. This was introduced to fix #358 and avoid breaking changes

• GetSchemaType(string typeName, QueryRequestContext? requestContext) is now Obsolete, use GetSchemaType(string typeName, bool inputTypeScope, QueryRequestContext? requestContext) and provide inputTypeScope = true if the type is an Input type.

• #359 - For targets .net6 and above DateOnly & TimeOnly are added as scalar types by default.

Fixes

• #356 - Look up the correct field return type for InputTypes
• #358 - OffsetPaging and ConnectionPaging field extensions can now be used on multiple fields that return the same type. e.g.
• #148 - Return a more descriptive error message for a missing type when we know the field we are trying to find the type of
• #361 - Handle union/interface types when accessed from a object projection

// both fields return a list of people but have different expressions
schema.Query().AddField("peopleOver", new
  {
      over = ArgumentHelper.Required<int>()
  },
  (ctx, args) => ctx.People.Where(p => p.Height > args.over).OrderBy(p => p.Id), "Return list of people with paging metadata")
  .UseOffsetPaging();
schema.Query().AddField("peopleUnder", new
  {
      under = ArgumentHelper.Required<int>()
  },
  (ctx, args) => ctx.People.Where(p => p.Height < args.under).OrderBy(p => p.Id), "Return list of people with paging metadata")
  .UseOffsetPaging();

5.2.1

Fixes

• #355 - make error variable values more distinctive
• EntityGraphQL is now more specific in which methods it tries to optimize the pattern of a list to single. E.g. If a field has an expression like ctx => ctx.People.FirstOrDefault(filter) EntityGraphQL treats that as a ListToSingle field and will build a full expression similar to ctx => ctx.People.Where(filter).Select(x => new {...}).FirstOrDefault() to avoid over fetching when using EntityFramework. Previously EntityGraphQL would try to break up and rebuild expressions.methods it didn't know how to. It now correctly only tries this optimization on First, FirstOrDefault, Single, SingleOrDefault, Last & LastOrDefault from Queryable & Enumerable

5.2.0

Check release notes for the 5.2.0-beta1 and beta2 below.

Changes

• #347 - The handler for the subscriptions end point added by UseGraphQLWebSockets no longer returns 400 if the request is not a web socket request. Allowing the request to get passed to the next handlers. This allows you to have the same endpoint for queries/mutations and subscriptions.

Fixes

• #350 - Index accessors properties (which are methods to dotnet) on types are ignored when using SchemaBuilder. Previously they would fail.
• #333 - Fixes to method and service calls on interfaces/unions
• #344 - Support paging field extensions with field.ResolveBulk<TService, TKey, TResult>()
• Fix bulk resolve services within a List to Single node

5.2.0-beta2

Check release notes for the 5.2.0-beta1 below.

Fixes

• Fix error when using a service at a query root field that uses First() as friends (List to single pattern). E.g. (ctx, service) => ctx.SomeList.First(i => i.Thing == service.Other)
• #318 - Fix issue comparing int style fields against float style fields in the filter expression
• Better error message when comparing different enum types in the filter language
• Include descriptions for scalars and directives in introspection and schema output
• Fix issue using the default SchemaBuilderOptions with a mutation method that has a list argument. The argument input type was not being correctly added to the schema. Not an issue if you were already adding the type manually
• #336 - Fix conversion of non-nullable/nullable types
• #342 - Fix argument incorrectly being renamed when using [GraphQLField]

Changes

• #318 - Support Unicode characters in the string of the filter language
• Support more cases with field.ResolveBulk<TService, TKey, TResult>()
• Add a net8.0 target output for the base EntityGraphQL library.

5.2.0-beta1

Changes

• Make more properties public in nodes like GraphQLCollectionToSingleField to better support customisation in custom directives
• Added field.Resolve<TService, ...>() to replace ResolveWithService<>(). Recommended to use Resolve(). Release 5.3 will mark ResolveWithService as deprecated and release 6.0 will remove them.
• Add field.ResolveBulk<TService, TKey, TResult>() to allow you to use services to bulk load data to avoid multiple calls to a service resolve expression that may call an external service in a list result. Example
• Add schema.AddEnum<TEnum>(typeName, description) to the schema building API
• Add net8.0 as a target for EntityGraphQL.AspNet project

var schema = SchemaBuilder.FromObject<MyContext>();
schema.UpdateType<Project>(type =>
{
    type.ReplaceField("createdBy", "Get user that created it")
      // normal service to fetch the User object for creator of the Project type
      .ResolveWithService<UserService>((proj, users) => users.GetUserById(proj.CreatedById))
      // Bulk service used to fetch many User objects
      .ResolveBulk<UserService, int, User>(proj => proj.CreatedById, (ids, srv) => srv.GetAllUsers(ids));
});

If you have a query like

{
  # ResolveBulk
  projects {
    # project fields
    name
    id
    # service field - resolved with ResolveBulk expression for all Projects loaded
    createdBy {
      name
    }
  }

  # ResolveWithService
  project(id: 78) {
    # project fields
    name
    id
    # service field - resolved with ResolveWithService expression for the single project loaded
    createdBy {
      name
    }
  }
}

Instead of calling users.GetUserById() for each project to resolve createdBy { name }, EntityGraphQL will build a list of keys using the proj => proj.CreatedById expression from the list of projects and then call the (ids, srv) => srv.GetAllUsers(ids) expression once for the whole list of projects in the results. See updated documentation for further details.

5.1.1

Fixes

• Fix #337 - Description attribute accidentally updating name instead of description

5.1.0

Changes

• Upgrade to the latest standard Antlr4 - the parser/tool used for the filter expression strings. Fixing precedence of operators

Fixes

• #319 - Only convert strings to Guid or DateTime when required
• If you add a field connecting back to the Query Context that ends in a method to go from a list to a single result the graph object projection will now correctly be inserted before the last call. Example

var schema = SchemaBuilder.FromObject<MyContext>();
schema.AddType<ExternalData>("ExternalData").AddAllFields();

schema.UpdateType<ExternalData>(ed =>
{
    // connect back to the MyContext types
    ed.AddField("movie", "Get movie")
      // here FirstOrDefault() goes from list -> single
      .ResolveWithService<MyContext>((ed, db) => db.Movies.Where(m => m.Id == ed.Id).FirstOrDefault());
});

schema.Query().AddField("externalData", "Get Data")
    .ResolveWithService<ExternalDataService>((p, srv) => srv.GetData());

In the above case if you select

{
  externalData {
    movie {
      director {
        name
      }
    }
  }
}

The movie field will have the selection inserted allowing EF to resolve fields without lazy loading turned on. Without this the m.Director.Name would also be null as no relation was included. e.g.

db.Movies.Where(m => m.Id == ed.Id)
.Select(m => new [
  director = new {
    name = m.Director.Name
  }
])
.FirstOrDefault();

5.0.1

Fixes

• Fix #314 - Some clean up of the Antlr4 grammar for the filter expressions

5.0.0

Make sure to check out the changes 5.0.0-beta1

Breaking Changes

• Generated schema type name for field sort inputs now include the name of the schema type the field is on to avoid conflicts

Changes

• IField.AddExtension now returns the IField
• UseSort() field extension now can take a list of default sort fields e.g.
• Broadcaster (inbuilt IObservable<TType> you can use for subscriptions) now has a OnUnsubscribe callback

schema.ReplaceField("people",
    ctx => ctx.People,
    "Return a list of people. Optional sorted")
    .UseSort(
        new Sort<Person>((person) => person.Height, SortDirection.ASC),
        new Sort<Person>((person) => person.LastName, SortDirection.ASC)
    );

• SchemaBuilderOptions now has a OnFieldCreated callback to make changes to fields as SchemaBuilder is building the schema.
• .contains(string), .startsWith(string), .endsWith(string) & .toLower() / .toUpper() string methods now available in the filter argument expression.

Fixes

• Fix naming of fields extracted from service calls when those field use convert

5.0.0-beta1

Breaking Changes

• EntityGraphQL.AspNet now targets net6.0 and net7.0, dropping targets netcoreapp3.1 and net5.0. You can still use the base EntityGraphQL library with older targets.
• Interface IExposableException has been removed. Use SchemaBuilderSchemaOptions.AllowedExceptions or the new AllowedExceptionAttribute to define which exceptions are rendered into the results
• #254 - Previously passing null for the ClaimsPrincipal in ExecuteRequest() would skip any authorization checks. All authorization checks are now done regardless of the ClaimsPrincipal value. Meaning null will fail if there is fields requiring authorization.
• IDirectiveProcessor interface has changed. See upgrade docs for changes
• SchemaBuilderMethodOptions removed, see updated properties on SchemaBuilderOptions and upgrade docs. This was because you can also now add methods as query fields with GraphQLFieldAttribute
• SchemaBuilderOptions.AutoCreateInputTypes now defaults to true. Meaning in SchemaBuilder when adding mutations etc any complex types will be added to the schema if they are not there already.
• The rules for reflection on method parameters have been changed to make them clearer. See the upgrade to 5.0 docs and the mutation docs that cover examples.
• GraphQLValidator is no longer magically added to your method fields (mutations/subscriptions). If you wish to use it please register it in your services. There is a new helper method in EntityGraphQL.AspNet AddGraphQLValidator(). This means you can implement and register your own implementation.
• SchemaProvider.ExecuteRequest & SchemaProvider.ExecuteRequestAsync have been renamed to ExecuteRequestWithContext & ExecuteRequestWithContextAsync. The schema context instance provided will be used for all context references within that query.
• #309 - Introduced new SchemaProvider.ExecuteRequest & SchemaProvider.ExecuteRequestAsync which take no schema context instance as an argument. The context will be fetched from the provided ServiceProvider meaning the lifetime rules are adhered to - e.g. ServiceLifetime.Transient is now correctly used. This is the preferred way to execute a query

Changes

• EntityGraphQL (the core library) targets both netstandard2.1 & net6. netstandard2.1 will be dropped around the time of net8.0 being released.
• Introduced GraphQLFieldAttribute to allow you to rename fields in the schema as well as mark methods as fields in the schema. Method parameters will become field arguments in the same way as mutation methods. See updated docs for more information.
• Argument types used for directives now read DescriptionAttribute and GraphQLFieldAttribute to use different field name in the schema and set a description
• Added GraphQLInputTypeAttribute. Whereas GraphQLArgumentsAttribute flattens the types properties into the schema, GraphQLInputTypeAttribute assumes the type is an input type and uses that as the schema argument
• You may implement you own GraphQLValidator by implementing (and registering) IGraphQLValidator
• Added a options.BeforeExecuting callback to allow modification of the expression before execution

Fixes

• #266 - Fix error calling AddPossibleType() when some of the types have already been added to the schema
• ExecutionOptions passed into IApplicationBuilder.UseGraphQLWebSockets() are now used when executing the queries for the subscription
• #284 - Support generic class types as mutation arguments. MyClass<OtherClass> will become input MyClassOtherClass {}
• #302 - Fix issue where using service fields with IQueryable/DbContext fields

4.3.1

Fixes

• Fix issue using the OneOf directive with ArgumentHelper.Required<T>() in a query field argument.

4.3.0

Changes

• #285 - Add support for implicit operators when converting types
• Fix how EntityGraphQL evaluates the root level fields that return lists. If the return type of the field is nullable a null will be returned if the result is null. If the return type is non-nullable an empty List<T> will be returned.

public class UserDbContextNonNullable
{
    // empty list will be returned if UserIds resolves to null. If you use nullable types you can control with the ? operator (to return null)
    [GraphQLNotNull]
    public List<string> UserIds { get; set; }
}

Fixes

• #288 - fix stack overflow in RuntimeTypeJsonConverter
• #291 - Fix ResolveWithService being called twice due to Expression.Condition if the field is a list and at the root level of the Query type

4.2.1

Fixes

• Fix issue selecting repeated fields from an interface and a fragment selection
• Fix issue selecting interface fields from the concrete type in a fragment

4.2.0

Changes

• #281 - Implement allowed exceptions to allow exceptions to come into the error result when running with IsDevelopment == false as users not be able to modify the exceptions being thrown in order to have them implement IExposableException. Exceptions may be allowed with an exact type match, or allowed including all types that inherit it

Fixes

• Prevent double SQL (when using against EF) query on base type (4.1 regression)
• #279 - Remove duplicate fields when creating expressions
• #280 - Fix for mutations that return interfaces/unions

4.1.2

Fixes

• Fix issue when using paging extension and aliases in the query e.g. { myList { myEdges: edges { .. } } } previously would fail

4.1.1

Fixes

• #221 - Apply null check on the ToList expression built to resolve list expressions
• Better support for service fields at the root query level
• Fix support for service fields that take a complex type (object or enumerable) as arguments
• Fix UseFilter() filter and UseSort() sort field arguments were incorrectly being marked as required in schema introspection
• Fix issues with default sort values for UseSort() not appearing in the schema as default values
• Fix output of default values in schema for lists and objects

4.1.0

Changes

• #262/#205 - Option to prevent leaking internal exceptions into the 'errors' field on a result.

When running in development (read via IWebHostEnvironment.IsEnvironment("Development") or when manually creating SchemaProvider), messages of exceptions will not be dumped out into the 'errors' field of a query result, unless they implement the newly created (and empty) interface IExposableException.

• #260 - Support default values in C# methods for mutations
• #264 - Versions prior to .NET 7, System.Text.Json doesn't support the serialization of polymorphic type hierarchies. EntityGraphQL now registers a RuntimeTypeJsonConverter class as part of the DefaultGraphQLResponseSerializer

Fixes

• #264 - Interface/union queries used to require you to query for at least 2 of the subtypes at once.
• Fix issue with service fields that take nullable type fields as arguments

4.0.1

Fixes

• #248 - Make sure directives run on fields that map a list of items to a single item (e.g. myItem(id: Int!) @include(...) { ... })
• #213 - Multiple levels of TargetInvocationException will now be unwrapped
• #82 - SchemaBuilder can now handle fields that return Task<>. Note that the way that queries expressions are built you may still encounter issues with async fields not at the root query level. Please open an issue if you do
• #259 - Fix introspection of nullable/non-nullable lists with nullable/non-nullable items
• #239 - Fix issues rejoining main context from a service field

4.0.0

Fixes

• #243 - support application/json; charset=utf-8 content type

4.0.0-beta2

Fixes

• Fix issue related to #235 where the multiple fields are the same field with different alias and arguments

Breaking Changes

• IFieldExtension.ProcessExpressionSelection now takes a ParameterExpression? argumentParam argument which is the argument parameter used at execution time (if there is one). Relating to #235

4.0.0-beta1

Breaking changes

• DateTimeOffset is now added as a default scalar type in schema creation. It is a very common used type in EF contexts and trips up new users. If you previously were adding it as a scalar type you no longer need to. Or if you'd like to add it differently (like map it to Date) you can

services.AddGraphQLSchema<DemoContext>(options =>
{
    options.PreBuildSchemaFromContext = (schema) =>
    {
        schema.RemoveType<DateTimeOffset>();
        // add it how you want
    };
});

• AddMutationsFrom and friends now take an optional SchemaBuilderMethodOptions options object to configure how mutations are built, following the SchemaBuilderOptions used elsewhere. See updated docs. Important defaults:

bool AutoCreateInputTypes = true; // Any input types seen will be added to the schema
bool AddNonAttributedMethods = false; // GraphQLMutationAttributes are still required by default
bool AutoCreateNewComplexTypes = true; // Return types of mutations will be added to the schema

• SchemaBuilderOptions.IgnoreTypes Now uses Type instead of string. It is a HashSet<Type> now to avoid confusion of which name to use (full name space or not)
• ProcessExpressionSelection used in Field Extensions now takes Dictionary<IFieldKey, CompiledField> for the selectionExpressions parameter. IFieldKey is the field name and the schema type the field belongs too. Helps when dealing with inline fragments/union types where we may have multiple fields with the same name from different types.
• MutationArgumentsAttribute renamed to GraphQLArgumentsAttribute and is used with subscriptions or mutation method arguments

Changes

• Add support for GraphQL subscriptions - see updated documentation
• Added support for defining Union types in the schema (#107)
• Core library EntityGraphQL only targets netstandard2.1 as we do not need to multi-target and this still supports a large dotnet base (3.1+)

Fixes

• Fix #206 - If a service field included a binary expression EntityGraphQL would sometimes build an incorrect selection expression
• Fix #214 - The implicit conversion return type of a ArgumentHelper.Required<>() field argument is non-null
• Fix #212 - Regression using a static or instance method in a service field
• Fix #223 - Mutations with inline args don't support variables with different name to argument name
• Fix #225 - Mutations with separate (not using MutationArgumentsAttribute) parameters fail if called without variables
• Fix #229 - Using Field.Resolve() would incorrectly assume the field had a service
• #219 - Handle conversion of variables as lists to a RequiredField<> arg of the list type
• #215 - Fix issue using GraphQLValidator if using inline mutation arguments
• #235 - Fix issue where arguments with the same name at the same level in a query would receive the same value

3.0.5

Fixes

• Fix #197 - If a mutation returns Task<T> use T as the return type
• Fix #204 - Nullable reference types correctly produce a nullable argument in the schema
• If not using MutationArgumentsAttribute in mutation methods autoAddInputTypes was being ignored

3.0.4

Fixes

• Fix #194 - HasType() was not checking type mappings

3.0.3

Fixes

• Prevent creation of invalid GraphQL schemas
  • Exception is thrown if you try to add a field with arguments to types that do not support arguments - Enum & Input types
  • Exception is thrown if you try to add fields to a Scalar type
  • Exception is thrown on invalid type name
• Schema builder now creates a valid GraphQL type name for generic types
• Enum types are now added to the schema as a typed SchemaType<T> instance. Meaning you can fetch them using schema.Type<MyEnum>()
• Fix #181 - Schema builder now correctly respects SchemaBuilderOptions.IgnoreTypes. Note it compares names against the Type.FullName
• Fix #182 - Add missing dotnet scalar type for char. By default this is added as a schema scalar type named Char so the client can decide how to handle it. Over the wire it will serialize as a string (default for System.Text.Json). You can change default scalars and mappings by using the PreBuildSchemaFromContext action when adding your schema

services.AddGraphQLSchema<TContext>(options => {
  options.PreBuildSchemaFromContext = schema =>
  {
      // remove and/or add scalar types or mappings here. e.g.
      schema.AddScalarType<KeyValuePair<string, string>>("StringKeyValuePair", "Represents a pair of strings");
  };
})

• When generating a field name for the field that takes an ID argument if the name generated matches the current field EntityGraphQL will add ById to the field name. E.g. a property List<LinePath> Line { get; set; } previously would try to add the line: [LinePath] field with no arguments and another field named line(id: ID!): LinePath. This causes an error. EntityGraphQL will name add lineById(id: ID!): LinePath. This is because the singularized version of "line" is "line".
• In built field extensions now check if their extra types have already been added by using Type instead of name allowing you to add them with your own descriptions etc.
• Fix mutations without any mutation arguments would incorrectly include the query context as an argument

3.0.2

Fixes

• InputValue type was being registered under wrong name #184

3.0.1

Fixes

• Input Types were incorrectly getting field arguments added when using AutoCreateFieldWithIdArguments

3.0.0

Breaking changes

• IDirectiveProcessor now requires a List<ExecutableDirectiveLocation> On { get; } to define where the directive is allowed to be used
• Removed obsolete ISchemaType.BaseType. Use ISchemaType.BaseTypes
• Cleaned up SchemaType constructors - using GqlTypeEnum instead of many boolean flags
• Removed obsolete SchemaProvider.AddInheritedType<TBaseType>
• Removed the instance parameter from AddMutationsFrom and friends. Mutation "controllers" are now always created per request like an asp.net controller. Use DI for any constructor parameters
• Renamed ISchemaType.AddBaseType to ISchemaType.Implements to align with GraphQL language
  • ISchemaType.Implements will throw an exception if you try to implement a non-interface
• Renamed ISchemaType.AddAllBaseTypes to ISchemaType.ImplementAllBaseTypes to align with GraphQL language
• Create & FromObject on SchemaBuilder now take option classes to configure the create of the schema through reflection
  • ISchemaType.AddAllFields also takes the option class to configure it's behavior
  • ISchemaType.AddAllFields default behavior now auto adds any complex types found really reflection the properties & fields and will add those to the schema
• Added new option when building a schema with SchemaBuilder.FromObject - AutoCreateInterfaceTypes. Defaults to false. If true any abstract classes or interfaces on types reflected with be added as Interfaces in the schema. This is useful if you expose lists of entities on a base/interface type.

Changes

• ToGraphQLSchemaString now outputs directives in the schema
• #154 - Dynamically generated types used in the expressions now include the field name the type is being built for to aid in debugging issues
• #146 - Allow GraphQL mutation arguments as separate arguments in the method signature. Avoiding the need to create the mutation argument classes. e.g.

[GraphQLMutation]
public Person AddPersonSeparateArguments(string name, List<string> names, InputObject nameInput, Gender? gender)
{
  // ...
}

[GraphQLMutation]
public Person AddPersonSingleArgument(InputObject nameInput)
{
  // ...
}

Turn into

type Mutation {
  addPersonSeparateArguments(name: String, names: [String!], nameInput: InputObject, gender: Gender): Person
  addPersonSingleArgument(nameInput: InputObject): Person
}

• #160 - Nested data annotations for validation is now supported
• Main EntityGraphQL package now targets net6.0;net5.0;netstandard2.1
• #170 - EntityGraphQL now replaces query context expressions in service fields by matching the expression instance it extracted. This allows for more complex expressions when passing data to a service field
• Added support for @oneOf Input Types. Mark an input type with GraphQLOneOfAttribute and EntityGraphQL will mark the type with @oneOf in the schema and validate the input meets the requirements on execution

Fixes

• #171 inheritance support for nested properties / conditional fields
• #176 - allow fully qualified enums in the filter query language

2.3.2

Fixes

• Fix #159 - SchemaBuilder will no longer try to create schema fields for const fields on mutation args or input types

2.3.1

Fixes

• #163 - Fix to handle null property in a nested object when processing a System.Text.Json deserialised query document
• #164 - Fix to support inline fragments in a fragment
• #166 - Add missing != operator in the filter expression language and make sure precedence is correct for logic operators

2.3.0

Changes

• AddMutationsFrom now can use the ServiceProvider instance to create the mutation class allowing dependency injection at the constructor level like Controllers.
• You can still provide an instance of the mutation class that will be used instead which is the same behavior as previous, however this method is considered obsolete and will be removed in a future version. We suggest you utilse the ServiceProvider to register your mutation classes with your desired lifetime.
• Allow types to inherit from multiple base classes/interfaces
• Cleanup SchemaType to use an enum instead of lots of boolean type variables. Previous constructor is obsolete
• Cleanup Interfaces api - added a AddAllBaseTypes, AddBaseType and AddBaseType(string) which provides a lot more flexibility. See updated docs
• Added support for Inline Fragments for types that have interfaces
• ToGraphQLSchemaString now orders types and fields by name for consistency regardless of order of fields added and to reduce differences when diffing the schema

Fixes

• Fix #120 - Error when using schema.RemoveTypeAndAllFields and a field of the removing type had a type that has not been added to the schema
• Fix #143 - Error building a null check expression in certain cases.

2.2.0

Changes

• FromObject / default schema generator now adds single fields within non root-level fields. E.g. if a root-level field is a list of people and each person has a list of projects (and projects has an id) is will create a field on project(id) field on person
• Add support for nullable reference types - meaning the correct GraphQL schema nullable definitions are generated. @bzbetty

Fixes

• Fix generation of singular field with id arguments on list fields that use a paging extension when generating a schema. @bzbetty
• Fix - when adding Mutation argument types only search for public instance properties. @breyed
• Fix interface query introspection. @bzbetty
• Fix #137 - multiple line endings were used in the schema output
• Fix - make sure we use an array for arguments when expected instead of a list<>

2.1.5

• Fix null exception in service field from an object field

2.1.4

• Fix #123 do not output types with no fields in the schema definition
• Fix issue calling ToList in an expression that then used a IQueryable FirstOrDefault or friends. Resulting in an invalid expression at runtime

2.1.3

• Fix - Throw an error if your query document defines a non-null variable and a null value is supplied
• Service fields that return a list of items are now wrapped in a null check expression like service fields that return a single object are
• Fix - Object fields not included in the schema could be returned when the selection set was missing from the query. Now missing selection sets on list or object fields in queries throw an error. Selection sets are required in graphql queries for non scalar/enum field types. Thanks @breyed

2.1.2

• Fix - issue with a field using a static member e.g. DateTime.MaxValue

2.1.1

• Fix - issue where a nullable value was incorrectly being called

2.1.0

• Added support for interfaces - thanks @bzbetty
• Added EntityGraphQLException - use this to throw exceptions and add more error data to the error result via extensions
• GraphQLValidator now supports adding custom data via the extensions field
• ResolveWithService methods will throw an exception if the expression returns Task as we need the result. Use .GetAwaiter().GetResult(). Expression do not support async/await as it is a compiler feature and we need the actual result to build the expression and return the data
• Fix using QueryFilter with an empty string treats it as no value - i.e. no filter
• Fix - the type of an array variable defined as required [Type!]! was incorrectly reflected
• Fix - service type's field used in a field's expression was not being extracted into the select. E.g. service field User.project has an expression requiring the user.id which is not included in the GraphQL query.

2.0.3

• Fix thread safety issue with cached queries
• Fix support for using arrays in field argument definitions

2.0.2

• fix regression where non-required (nullable) document variables would be set their non-nullable default value. E.g. Guid

2.0.1

• Fix regression where non service fields in service fields were not being pulled forward to the stage one expression execution.
• Fix regression where services were not be passed to a mutation with no arguments

2.0.0

Breaking changes

• Interface for Field Extensions now are passed a flag telling the extension if this is pre or post the call with service fields
• GetExpression in Field Extensions is passed the parent IGraphQLNode - useful when your extension changed the original shape of the object graph, like the paging extensions
• services.AddGraphQLSchema adopts a more ASP.NET style options callback overload to configure the creation of the schema
• MapGraphQL implementation now returns 400 Bad Request status code if the query results contains errors, as a bad query was sent
• Directive interface for building custom directives has changed
• UseSort field extension now takes an array of SortInput<T> so order of sorts is used
• Parsing floats/doubles/decimals now uses CultureInfo.InvariantCulture Clean up on the schema building APIs to make them more consistent, documented and concise
• Fix #89 - Remove JSON.NET dependency - This means internally if EntityGraphQL hits a JObject or JToken it does not know what to do with them. Make sure QueryRequest.Variables are fully deserialized. I.e. do not have any JObject/JTokens in there. Deserialize them to nested Dictionary<string, object>.

If you use the EntityGraphQL.AspNet package and the MapGraphQL() method you do not need to worry about anything. EntityGraphQL.AspNet uses System.Text.Json and handles the nested JsonElements with a custom type converter.

If you are directly using SchemaProvider.ExecuteRequest() (i.e. from a Controller or elsewhere), and you are using Newtonsoft.Json to deserialize the incoming QueryRequest you can add a custom converter to your schema to handle nested JObject/JTokens when encountered in query variables.

schema.AddCustomTypeConverter(new JObjectTypeConverter());
schema.AddCustomTypeConverter(new JTokenTypeConverter());

See the serialization tests for an example.

• Remove the WithService() method used inside a field expression and replace it with ResolveWithService<TService>() on the field for easier discovery in your IDE. Example

schema.Type<Person>().AddField("age", "A persons age")
  .ResolveWithService<AgeService>(
      (person, ageService) => ageService.GetAge(person.Birthday)
  );

• Clean up of SchemaType APIs to add/replace/remove fields.
  • Remove SchemaProvider.Add/ReplaceField methods.
    • Use SchemaProvider.Query().Add/ReplaceField() or SchemaProvider.UpdateQuery(queryType => {}) to make changes to the root Query type in the schema
  • Additions to the Field API to add more uncommon functionality to chaining methods
  • Remove SchemaProvider.UpdateQueryType(), use SchemaProvider.UpdateQuery(type => {})
  • Remove SchemaProvider.TypeHasField()
  • Remove SchemaProvider.GetQueryFields() - use SchemaProvider.Query.GetFields()
  • Renamed GetGraphQLSchema() to ToGraphQLSchemaString()
  • Renamed AddMutationFrom() to AddMutationsFrom()
  • Removed Obsolete methods:
    • RequiresAllClaims replaced by RequiresAllRoles
    • RequiresAnyClaim replaced by RequiresAnyRole
    • ExecuteQuery replaced by ExecuteRequest
    • ExecuteQueryAsync replaced by ExecuteRequestAsync

Changes

• Support for persisted queries (enabled by default) - https://www.apollographql.com/docs/react/api/link/persisted-queries/
• Support for a query cache of recent queries. Enabled by default. Caches the result of compiling the query document string to an AST. Execution is then applying the document level variables, building the expressions then execution
• Better support for nested objects in QueryVariables
• Performance enhancements when building internal types for arguments
• Performance of compiling and building expressions has been improved - it is about 2 times faster. Note this is just building the expressions, not executing them which triggers your services/EF/etc
• Reduction in memory allocation when compiling queries by around 30%
• You can no add/define mutation methods as delegates/anonymous functions etc.
• You can now use [Range] & [StringLength] attributes on your arguments for more validation options
• Introduced custom argument validators - a simple way to act on field arguments before execution. Great for custom/complex input validation on arguments. Use field.AddValidator() or the ArgumentValidatorAttribute attribute.
• Using AddAllFields(true) on an InputType will add the sub-complex class types as InputTypes as well
• New option to auto add other classes found on mutation arguments as InputTypes when adding a mutation

Fixes

• Fix - Paging field extensions are now thread safe to support multiple different queries being run on the same field at the same time
• Fix #101 - allow custom de/serialization of incoming requests and outgoing responses, via. services IGraphQLRequestDeserializer & IGraphQLResponseSerializer.
  • Note that the objects created in the resulting QueryResult have fields named like the fields in the schema which is controlled by the fieldNamer function provided to the SchemaProvider which defaults to GraphQL "standard" (fields camelCase, types PascalCase)
• Fix field name looks up that were not using the fieldNamer function in SchemaProvider
• Fix bug where compiler would loop through all available arguments even if it already found the matching type
• Fix argument types of unsigned short/int/long
• Fix #72 - Handling dictionaries introspection - note it will try to create a scalar type KeyValuePair<T1, T2> in the schema by default
• Fix handling argument types of unsigned short/int/long
• Fix issue parsing float/double argument values
• Fix null exception with mutations returning a selection with a list field
• Fix directives on mutation fields
• Fix #110 - Field using the wrong sort input object when the fields are the same

1.2.1

• Fix #99 issue using the MapGraphQL() extension method

1.2.0

• New option to disable introspection. Use introspectionEnabled parameter when creating SchemaProvider. Defaults to true.

1.1.2

• Fix #96 - processing int/long/short as list arguments in mutations - thanks @pierrebelin

1.1.1

• Fix #92 - error processing mutation arguments that are lists/arrays

1.1.0

• Authorization now supports using ASP.NET policies from the EntityGraphQL.AspNet package
  • IAuthorizationService is resolved to check authorization and needs to be registered
  • [Authorize] attribute can be used instead of the [GraphQLAuthorize] attribute when using EntityGraphQL.AspNet
• Fix - RequiredAttribute results in the field being not null in the generated GraphQL Schema
• Fix - Schema introspection was incorrectly returning __typename for Enums
• UseConnectionPagingAttribute takes optional arguments for default page size and max page size
• UseOffsetPagingAttribute takes optional arguments for default page size and max page size
• EntityGraphQL.AspNet now uses System.Text.Json for de/serialization internally. It still supports JSON.NET objects in the variable object (as well as System.Text.Json types)
• Fix #19 - you can mark fields (including mutations) as deprecated using the dotnet [Obsolete] attribute or the IField.Deprecate(reason) method in the schema building
• Fix #88 - If an argument is marked as required and not provided in the query request an error is raised. Mark arguments optional via the API, or make it a nullable type or give it a default value
• Query used in ConnectionPaging now resolves itself using .ToList()

Obsolete - will be removed 2.x

• RequireAnyClaim() & RequireAllClaims(). Use RequireAnyRole() & RequireAllRoles() as the ClaimTypes.Role was used previously and this change makes it explicit
• schema.ExecuteQueryAsync/ExecuteQuery(QueryRequest, TContextType, IServiceProvider, ClaimsIdentity, ExecutionOptions). Use the ExecuteRequest/ExecuteRequestAsync methods that take the full ClaimsPrincipal as we now support authorization with policies

1.0.3

• Fix #86. Mutations not correctly checking required authorization on the mutation field directly

1.0.2

• Fix - RequiredAttribute results in the field being not null in the generated GraphQL Schema
• Fix issue with expressions failing in a high throughput, threaded use case (heavily hit API)

1.0.1

• Fix issue passing optional enum arguments

1.0.0

• New extension methods to ease adding your schema to the service collection. See docs - services.AddGraphQLSchema<DemoContext>(options => {})
• New package EntityGraphQL.AspNet with extensions to easily expose a graphql endpoint with MapGraphQL<T>().

app.UseEndpoints(endpoints =>
{
    endpoints.MapGraphQL<DemoContext>();
});

• Fix issue reconnecting from a service field to the context
• Fix issue when execution is split across non service fields and then with service fields and the first result is null
• Fix issue using Connection/Offset paging on collection fields that were not on the query root
• Fix issue using Connection/Offset paging on collection fields that have service fields
• Option to add default sort when using UseSort() field extension
• Fix service fields in an inline fragment selection

0.70.0

• Introduction of fields extensions to encapsulate common field logic and apply it to many fields. See update docs. New built in field extensions
  • UseConnectionPaging() which when applied to a collection field modifies the field to implement the GraphQL Connection spec for paging data with metadata
  • UseOffsetPaging() which when applied to a collection field modifies the field to implement an offset style paging structure
  • UseFilter() which when applied to a collection adds a filter argument that takes an expression
  • UseSort() which when applied to a collection adds a sort arguments that takes fields to sort the collection by
• Replaced Antlr based GraphQL query lexer/parser with HotChocolate.Language Parser. Parsing of query documents is much faster!
• You can now directly use lists ([12,32], etc) and objects ({name: "Frank"}) as arguments in the query document. Although it is still recommended to use the Variables in the query
• Added benchmarks to help explore performance issues in expression building (What we do with expressions is fast, but found the Antlr Parser was slow)
• Directives now supported on fragment spreads

Breaking changes

• EntityGraphQL now targets netstandard2.1
• Some optional arguments in ExecuteQuery moved to an Options object

0.69.0

• New docs https://entitygraphql.github.io/introduction
• Added SchemaProvider.UpdateType<T>(Action<SchemaType<T>> updateFunc) to better help "contain" schema types. Instead of

schema.Type<MyType>().AddField(...);
schema.Type<MyType>().AddField(...);
schema.Type<MyType>().AddField(...);

we have

schema.UpdateType<MyType>(t => {
  t.AddField(...);
  t.AddField(...);
  t.AddField(...);
});

Similar for SchemaProvider.AddType<T>(string name, string description, Action<SchemaType<T>> updateFunc)

• You can pass a ILogger<SchemaProvider<T>> when creating a SchemaProvider. Exceptions etc. will be logged
• Added Take<TSource>(this IQueryable<TSource> source, int? count) that works on IQueryable<T> to support EF translation

Breaking changes

• EntityGraphQL now targets netstandard2.0
• Big refactor/clean - hopefully easier to follow the post Antlr (compiled graphql) output - see GraphQL*Field classes
• Support for dotnet Entity Framework Core 3.1+ when using other services in the schema (WithService())
• Removed the Where<TSource>(this IEnumerable<TSource> source, EntityQueryType<TSource> filter) helper. Use the WhereWhen methods that support EntityQueryType

To support EF 3.x as a base schema context we now build and execute expressions in 2 stages. See the updated readme section How EntityGraphQL handles WithService().

0.68.1

• Update Humanizer.Core dependency which resolves issue with newer dotnet core

0.68.0

• Fix issue where FieldNamer was not being consistently used. Thanks @AnderssonPeter
• Make sure we include inner exceptions on errors. Thanks @AnderssonPeter
• Added string and long parsing for DateTime and DateTimeOffset. Thanks @GravlLift

0.67.0

• As per GraphQL spec commas are optional (previously EntityGraphQL expected them in field/mutation arguments)

Breaking changes

• errors property on query result should not be present on the response if there are no errors per the graphQL specification.

0.66.1

• Fix bug with using WithService() when you require the schema context service again to create a link between services

0.66.0

• When using services other than the schema context in fields (that return a single object not a Enumerable) the methods/services are no longer executed multiple times. (issue #36). Notes below
• When a string matches a date time it will be converted to a DateTime object. Useful when using the ArgumentHelper.EntityQuery for advanced filtering. Regex matches "yyyy-MM-dd HH:mm:ss.fffffffzzz", "yyyy-MM-dd HH:mm:ss", "yyyy-MM-dd" with the separator between date and time being either or T
• EntityQueryCompiler (used in ArgumentHelper.EntityQuery) supports Enums
• fieldNamer used in mutations too

Breaking changes

• Cleaning up the API. The optional isNullable argument is removed from the AddField() methods. Use IsNullable(bool) method on the Field class or the [GraphQLNotNull] attribute.
• Cleaning up the API. fieldNamer argument removed from methods in SchemaProvider and SchemaType. Pass in a fieldNamer func to the constructor of SchemaProvider which will be used when it is auto creating fields. If you pass it in via SchemaBuilder.FromObject it will set it on the SchemaProvider created.
• AddCustomScalarType() removed. Previously marked as obsolete. Use AddScalarType()

Notes of services fix

If you build a field like so

schema.AddField("myField", ctx => WithService((IMyService srv) => srv.DoSomething(ctx)));

// Register the service with DI somewhere
public class MyService: IMyService {
  public SomeObject DoSomething(Context ctx)
  {
    // do something
    return data;
  }
}

With a query like

{
  myField { field1 field 2 }
}

We use to build an expression like so

srv.DoSomething(ctx) == null ? null : new {
  field1 = srv.DoSomething(ctx).field1,
  field2 = srv.DoSomething(ctx).field2
}

We now wrap this in a method call that only calls DoSomething(ctx) a single time Which looks like this

(ctx, srv) => NullCheckWrapper(srv.DoSomething(ctx), parameterValues, selection); // simplifying here

// Again a simified example of what NullCheckWrapper does
public object NullCheckWrapper(Expression<Func<Context, IMyService>> baseValue, object[] values, LambdaExpression selection)
{
  // null check
  if (baseValue == null)
    return null;
  // build the select on the object
  var result = selection.Compile().DynamicInvoke(baseValue);
}

This works with services used deeper in the graph too. Example

schema.Type<Person>().AddField("complexField", (person) => DoSomething(person.Id));

GraphQL

{
  people {
    complexField {
      field1
      field1
    }
  }
}

The wrapped expression looks like this

(ctx, srv) => ctx.People.Select(person => new {
  complexField = NullCheckWrapper(srv.DoSomething(person.Id), parameterValues, selection); // simplifying here
})

This has been tested with EF Core and works well.

0.65.0

• You can now secure whole types in the schema. Add the [GraphQLAuthorize("claim-name")] to the class or use schema.AddType(...).RequiresAllClaims("some-claim"), schema.AddType(...).RequiresAnyClaim("some-claim")
• Add GetField(Expression<Func<TBaseType, object>>) overload
• operation name is optional for a query operation as per GraphQL spec if it is the only operation in the request
• Breaking - removed the authorizeClaims argument from AddField(). Please use field.RequiresAllClaims("some-claim"), field.RequiresAnyClaim("some-claim")

0.64.0

• Change - descriptions generated for a .graphql schema file now use the multiple line triple-quote """
• Fix issue where an WithService() expression is wrapped in a UnaryExpression and we fail to get the lambda

0.63.0

• Expose a SchemaProvider.ExecuteQueryAsync()
• Fix #53 support mutations with no arguments
• With the above fix the context and/or the mutation arguments parameters are optional in your mutation method
• the parameters in the mutation methods are no longer required to follow a position
• SchemaProvider.AddCustomScalarType() is deprecated, use AddScalarType
• Directvies are now included in schema introspection
• Fix #52 - sometimes incorrect types generated for schema introspection or the GraphQL schema file format
• Refactor type information held in the schema. This mean return types etc are evaluated at schema creation time not execution. If you add a field that requires a type as an Argument or return type, that type must already be in the schema
• You can now provide a field namer function to name the generated fields when using SchemaBuilder.FromObject(), ISchemaType.AddAllFields() or SchemaProvider.PopulateFromContext()

Breaking changes

• The class that represents the mutation arguments must be marked with the MutationArgumentsAttribute either at the class level or the parameter
• SchemaProvider now adds a default Date scalar type in the schema that maps to/from the C# DateTime class. If you were previously adding that you'll get an error on type existing. Use SchemaProvider.RemoveType<DateTime>() to remove it and add it with a different name
• Type mapping information (AddTypeMapping()) are evaluated at schema creation time. You may need to add mappings before creating the rest of your schema

0.63.0-beta1 to 0.63.0-beta2

• Removed the empty IMutationArguments in favor for a MutationArgumentsAttribute on the parameter or the class

0.62.0

• Support async mutation methods

0.61.0

• Add model validation for mutation arguments. See updated readme
• Fix issue with services not correctly being included when the field is used in a fragment

0.60.0

• Add support for directives. Supported by default are @include(if: Boolean!) and @skip(if: Boolean!). You can add your own that make changes to the expression pre-execution
• Added syntax support for subscription queries (they compile/no error but do not execute or work)
• Removed support for older syntax of complex queries that is not GQL standard
• Refactored GraphQLVistor and friends to make it easier to follow what is happening (I hope). See CONTRIBUTING.md for some notes
• From my testing the compiling and expression building is 15-20% faster than before (still network and or the DB calls are the largest)
• Allow enum values in the query schema (e.g. as an argument)
• Ignore static properties & fields on the object passed to SchemaBuilder.FromObject - they were not supported and threw errors anyway

0.50.1

• Name all ParameterExpressions as EF 3.1 expects a name (can throw an error)

0.50.0

• Fix claims check when required claims are empty
• Fix error message state which claims are required for the given access error

0.50.0-beta1

• Sorry about the quick turn around
• Breaking changes
  • Using DI inspired design now instead of the TArg
  • Use WithService helper to let EntityGraphQL know which services you require e.g. in an AddField use (db, p) => WithService<IUserProvider>(users => users.Load(p.id))
  • For mutations just add the services as arguments (at the end) as you typically do in dotnet
  • schema.ExecuteQuery() takes an IServiceProvider which it uses to look up required services like IUserProvider above

0.40.0

• Breaking changes
  • Trying to clean up the interface for creating a schema and allowing an easier way to get services in mutations and field selections
  • Rename MappedSchemaProvider to SchemaProvider
  • Remove extension object.QueryObject() and require a more specific call to SchmeaProvider.ExecuteQuery()
  • SchmeaProvider.ExecuteQuery() takes a TArg type which is an argument that will be passed to all field selections and mutation methods. This replaces mutationArgs in object.QueryObject() and lets both mutations and field selections access other services non-statically (e.g. via TArg being an IServiceProvider). See updated readme and demo project
  • SchemaProvider is now create using SchemaBuilder.Create<TContext, TArg>() or SchemaBuilder.Create<TContext>() giving you a short cut for not providing a TArg
  • SchemaBuilder.FromObject<TContext, TArg>() now takes second type argument for the TArg value. Also SchemaBuilder.FromObject<TContext>() shortcut
• Fix bug where EntityQuery arguments were being cached in the schema

0.32.1

• Add ContextId to the ignored list in SchemaBuilder for EF 3.1

0.32.0

• Clean up LinqExtensions, removing the overloads that take LambdaExpressions. Use .AsQueryable().Where(someExpressionVar) instead. It works better with EF and other LinqProviders.

0.31.0

• Breaking change - Multiple [GraphQLAuthorize] mean all polices are required and supplying multiple in a single [GraphQLAuthorize] mean any
• Do not generate an empty mutation type if there are no mutations
• Fix query introspection to output mapped types correctly
• Support multiple queries in a request with the operation name of which one to run - e.g. how GraphiQL handles multiple queries
• Update error messages
• Clean up some APIs - SchemaType.AddAllFields(), Field.RequiresAllClaims(), Field.RequiresAnyClaim()

0.30.0

• Initial support for Authorization and Security in the schema - see updated readme and provide feedback

0.29.0

• Support fragment statements in other positions in the query

0.28.2

• Fix error with EntityQueryType<> as a field argument not being defined as a String in introspection

0.28.1

• Fix issue introduced in 0.28 when using the RequiredField<> type

0.28.0

• Only convert a string matching a Guid when the arg type is a Guid or Guid?

0.27.2

• Fix issue where a non-required EntityQueryType Filter throw an error if it wasn't supplied

0.27.1

• Better support mutations that return an object, not a list

0.27.0

• Introspection query __type(name: "") now correctly returns an object not an array
• [Description("")] attributes on enum fields are now read into the schema
• Fix issue where introspection query would have duplicate types for enum types

0.26.0

• ISchemaType.AddAllFields requires a schema as it can add newly discovered types to that schema
• ISchemaType.AddAllFields by default adds new enum types to the schema if found as a field type
• ISchemaType.AddAllFields can (off by default) add new complex types to the schema if found as a field type
• Schema.Type<TType>() now searches by TType not typeof(TType).Name. Allowing you to add a type with a different name but still get the typed SchemaType<T> back

0.25.0

• Add the ability to add enum types to the schema
• The auto schema builder now adds enum types it finds to the schema by default
• Enum values are referenced by the string value, if using JSON.NET you will want to use [JsonConverter(typeof(StringEnumConverter))]

0.24.0

• Add GraphQLNotNullAttribute to mark fields as not nullable in the graphql schema
• By default when generating a .schema file IEnumerable<T> will generate the element type as not nullable. E.g. [T!]. Use GraphQLElementTypeNullableAttribute to mark it that the list can contain null items
• Support mapping decimal to number
• Better support for defining nullable or non-nullable types

0.23.3

• Allow adding a mapping type to a type that already exists in the schema. E.g. you might add an input type Point and want to map the dotnet type Point to it.

0.23.2

• fix issue with required type in an array e.g. [ID!]

0.23.1

• fix issue with generated required types

0.23.0

• Output fields as required in .graphql schemas

0.22.0

• You can now specify if a field is ignored for queries, mutations or both (if you're sharing DTOs/objects)
• Don't output the meta information of the schema in the schema definition
• Prevent duplicate scalar types in schema generation
• Fix issue where mutation keyword could not have any white space before it

0.21.0

• Change, make ENUMs a Int type as dotnet serialises them like that
• Fix input types missing for the SDL schema generated
• Fix issue where mutation args has repeating ofType data in introspection
• Fix issue where InputTypes would be duplicated in introspection query results
• Fix issue where ToList() was being called deep in expressions causing issues with EF

0.20.0

• Add the ability to add custom scalar types to the schema
• Fix a bug where introspection queries were in correct if you have a List/Array in your mutation type

0.19.1

• Fix a bug where mutation arg objects retained values from previous mutation - i.e if the next call to that mutation didn't provide some optional arguments

0.19.0

• QueryObject() calls ToList() on any lists so if you are using something like EF all queries will be evaluated on QueryObject(), not just the ones that return a single object (as they call FirstOrDefault()). This is more consistent, the result contains all your data (regardless of underlying ORM or not) and not a miz of evaluated and non-evaluated.
• Add RemoveTypeAndAllFields() on MappedSchemaProvider to more easily clean up a schema that was auto created by SchemaBuilder.FromObject<T>()

0.18.4

• Fix case matching of arguments in mutations. EntityGraphQL defaults to turning dotnet UpperCaseFieldsAndProperties to camelCaseFieldsAndProperties as this was the intention with the change in 0.18.0
• Enum values are as defined. E.g. if you have an enum Meter you can use "Meter" not "meter"

0.18.3

• map Int16 and UInt16 to Int
• Fix issue where argument names were not case sensitive (the Breaking change introduced in 0.18)

0.18.2

• Fix kind in schema introspection query to not have !

0.18.1

• Update dependencies (JSON.NET)
• Fix some small casing issues

0.18.0

• Support for schema introspection. Top two fields (__schema and __type(name: String!)) are implemented. There are some things missing where we currently don't support the feature (directives). GraphiQL introspection query executes and you can navigate the example. Big thanks to @JTravis76 for starting the work.
• Implement #18 default argument values in GQL operations mutation MyMutation($arg: String = "hey defaults") { ... }
• Breaking change - If you purely use SchemaBuilder.FromObject() it now creates all field names lowerCaseCamel and type names UpperCamelCase like the GraphQL defaults. Also since GraphQL is case sensitive I have enforced that. You may need to update some queries to match casing

0.17.0

• Add the option to have other parameters passed into a mutation method. Very useful for IServiceProvider or other services your mutations require

0.16.2

• Fix issue where duplicate fields (say from a query and a fragment) would cause an error

0.16.1

• Bring inner exception details up
• Fix issue where fields that require arguments fail (See Paging example in Demo)

0.16.0

• Add support for full queries on a mutation result. See readme for more details (you return an Expression)
• Initial support for GraphQL fragments. fix #2
• Fix issues with using field arguments deeper in the graph schema
• Add support for operationName in the GraphQLRequest
• Add support for graphql comments
• Add GraphiQL web interface to the demo app
• Add GraphQLIgnore attribute to ignore a field on a Type for the automatic schema builder
• fix bug where it would sometimes try to give an UInt64 to an argument that required an Int32
• (beta) Add dotnet gql command to generate a schema from your current DBContext. See readme for more info

0.15.8

• Add WhereWhen() to the extension helpers

0.15.7

• Fix bug in handling converting a string into an enum
• Fix issue looking up types internally when working with anonymous types

0.15.6

• Fix issue with incorrectly checking for generic types

0.15.5

• Fix issue with array types in the dynamically generated type for lambdas

0.15.4

• Fix issue where the generated GraphQL schema had the incorrect type for arrays (e.g. double[])
• Fix issue with SchemaBuilder.FromObject building invalid types from arrays.

0.15.3

• Fix an issue where it would generate an invalid field name if we couldn't singularize the name

0.15.2

• Move the query results into a QueryResult class so it is easier to work with

0.15.1

• Fix #11 - failure to use RequiredField with types like uint - it would try to initialise it with an int

0.15

• Remove old code that supported multiple fields with the same name and different arguments. GraphQL doesn't support that and it caused a bug where it would sometimes not find the field you want. You can implement optional arguments and build a complex field like schemaProvider.AddField("myField", new {name = (string)null, id = (Guid?)null}, (db, param) => param.id.HasValue ? db.MyEntities.Where(l => l.Id == param.id).FirstOrDefault() : db.MyEntities.Where(l => l.Name == param.name).FirstOrDefault(), "Returns an Entity object by ID or a match on the name argument");

0.14.4

• Allow user to supply a type mapping for the generated GraphQL schema

0.14.3

• Fix an issue where we would some time identify a type as IEnumerable when it shouldn't have been
• Allow ReplaceField on a sub type

0.14.2

• Convert enums correctly

0.14.1

• Fix SchemaGenerator to support arrays better
• Support turning QueryRequest variables from JSON objects into their required objects

0.14.0

• Bring back ReplaceField as technically GraphQL doesn't support overloading, so if you're using tools like Apollo etc to generate code you need to only have unique fields
• Added GetGraphQLSchema on the schema to return a .graphql schema file for input into tools like Apollo codegen
• Add the option to add descriptions to Mutations

0.13.1

• Fix issue where operation name with no arguments failed

0.13.0

• Breaking change: Strings are now defined by double quotes " to fit in with GraphQL better
• Added support to use a LINQ-style language as a argument in GraphQL. E.g the following GQL field, { users(filter: "active = true and age > 20") { id name } } can be defined with schema.AddField("users", new {filter = EntityQuery<User>()}, (ctx, p) => ctx.Users.Where(p.filter), "Return filtered users"). Letting you write that filter using any fields defined on the User object
• Add null/empty constant for checking for null in EQL

0.12.1

• Fix bug converting Int values to double? values

0.12.0

• Support field "overloads" - fields with same name and different arguments.

0.11.0

• Renamed package EntityGraphQL to emphasizes that it implements GraphQL

0.10.1

• Fix issue with arrays and objects in variables parameter on the request
• Better error messages when GraphQL arguments can't be mapped to an object
• Validate required variables in operations are supplied in the variables dictionary
• Fix potential issue with selecting sub object graphs

0.10.0

• Change the errors to appear in errors key along side data key as per GraphQL
• Fix an issue when selecting fields from a mutation result

0.9.4

• Support selecting an object that may be null { person {name} } person will be null if it does not exist

0.9.3

• Parameter types can be optional (no !)

0.9.2

• Fix type issues with mutation args
• Change auto entity call with id: (e.g. { entity(id: 13)}) to call the First() method last
• Fix issue with selecting a one-to-one relation in a query

0.9.1

• Fix a issue where schema and method provider were not being passed down in QueryObject

0.9.0

• Add initial support for Mutations
• , between fields is optional like in GraphQL
• Support __typename metadata

0.8.0

• Moved EntityQueryLanguage.DataApi namespace to EntityQueryLanguage.GraphQL to better communicate that its intent is to support
• Add support GraphQL arguments in fields. See updated readme
• By default SchemaBuilder.FromObject<TType>() generates a non-plural field for any type with a public Id property, with the argument name of id. E.g. A field people that returns a IEnumerable<Person> will result in a person(id) field
• Move results to field data in the resulting object to match GraphQL
• Support the query keyword for graphql

0.7.0

• Added support for complex nested queries when using the EFRelationshipHandler
• Fix type caching issue causing exception on changing a sub query