@ethlete/query 6.0.0-next.18 → 6.0.0-next.19

package/CHANGELOG.md

@@ -1,5 +1,23 @@
 # @ethlete/query
 
+## 6.0.0-next.19
+
+### Minor Changes
+
+- [#3036](https://github.com/ethlete-io/ethdk/pull/3036) [`aa4bdde`](https://github.com/ethlete-io/ethdk/commit/aa4bdde586615ed13735ed9c970831b91323ebad) Thanks [@github-actions](https://github.com/apps/github-actions)! - Query devtools: add `provideQueryDevtools()` and a registry that instruments
+  queries, query stacks, paged query stacks, `querySequence`, bearer auth providers
+  and web socket clients so they can be inspected by `<et-query-devtools>` (from
+  `@ethlete/components`). Instrumentation is a no-op unless the provider is added,
+  so there is no overhead when it is omitted.
+
+  Supporting devtools APIs added: `querySequence` exposes a `stepArgs` signal (the
+  resolved input args of each step); the query repository gains
+  `subtle.cacheEntries()` / `subtle.cacheVersion` / `subtle.evict()`; queries gain
+  `subtle.setLoading()` / `subtle.setError()` (force UI states for testing);
+  `HttpRequest` exposes `method`, `url` and `expiresAt`; `QueryClient` exposes its
+  `baseUrl`; `QuerySequence` exposes its step `queries`; and web socket clients
+  expose a devtools handle (connection state, rooms, recent messages).
+
 ## 6.0.0-next.18
 
 ### Minor Changes

package/fesm2022/ethlete-query.mjs

@@ -1,5 +1,5 @@
 import * as i0 from '@angular/core';
-import { isDevMode, DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ErrorHandler, createEnvironmentInjector, effect, untracked, signal, linkedSignal, computed, runInInjectionContext, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, ElementRef, input, Pipe, ViewEncapsulation, Component, resource, DOCUMENT, NgZone } from '@angular/core';
+import { signal, isDevMode, makeEnvironmentProviders, DestroyRef, InjectionToken, inject, Injector, EnvironmentInjector, ElementRef, ErrorHandler, createEnvironmentInjector, effect, untracked, linkedSignal, computed, runInInjectionContext, assertInInjectionContext, ChangeDetectorRef, ViewContainerRef, TemplateRef, Input, Directive, input, Pipe, ViewEncapsulation, Component, resource, DOCUMENT, NgZone } from '@angular/core';
 import { createStaticProvider, RuntimeError, clamp, createDestroy, computedTillTruthy, getCookie, setCookie, deleteCookie, createProvider, nextFrame, randomId, createRootProvider, isObject, injectRoute, getDomain, injectQueryParamChanges, injectQueryParams, clone, equal, ET_PROPERTY_REMOVED, previousSignalValue } from '@ethlete/core';
 import { filter, Subject, Subscription, Observable, tap, retry, throwError, timer, catchError, takeUntil, startWith, pairwise, switchMap, of, BehaviorSubject, fromEvent, take, ReplaySubject, map, shareReplay, interval, skip, takeWhile, combineLatest, EMPTY, withLatestFrom, debounceTime, firstValueFrom, merge, throttleTime } from 'rxjs';
 import { toObservable, takeUntilDestroyed, toSignal } from '@angular/core/rxjs-interop';
@@ -12,6 +12,126 @@ import { validateAsync } from '@angular/forms/signals';
 import { Router, ActivatedRoute } from '@angular/router';
 import { io } from 'socket.io-client';
 
+const noop = () => undefined;
+let devtoolsEnabled = false;
+/**
+ * Whether {@link provideQueryDevtools} has been called. When `false`, every `register*` call is a
+ * no-op so the devtools instrumentation retains no references and adds no overhead in production.
+ * @internal
+ */
+const isQueryDevtoolsEnabled = () => devtoolsEnabled;
+const entries = signal([], /* @ts-ignore */
+...(ngDevMode ? [{ debugName: "entries" }] : /* istanbul ignore next */ []));
+/**
+ * The reactive list of every registered devtools entry, consumed by the `<et-query-devtools>` UI.
+ */
+const queryDevtoolsEntries = entries.asReadonly();
+// Per-descriptor counter used to derive stable, reload-deterministic ids. Reset on page load (module
+// re-eval), so the same queries created in the same order get the same ids across reloads — which is
+// what lets the devtools restore the selected query after a reload.
+const idCounters = new Map();
+const descriptorOf = (entry) => {
+    const { kind, meta } = entry;
+    if (kind === 'query')
+        return `query|${meta.clientName ?? ''}|${meta.method ?? ''}|${meta.route ?? ''}`;
+    if (kind === 'auth-provider')
+        return `auth-provider|${meta.name ?? ''}`;
+    if (kind === 'ws-client')
+        return `ws-client|${meta.name ?? ''}`;
+    return kind;
+};
+/**
+ * Registers an entry with the devtools registry. Returns an unregister callback. A no-op (returning
+ * a no-op callback) unless {@link provideQueryDevtools} has been called.
+ *
+ * Ids are derived deterministically from a stable descriptor + a per-descriptor sequence number, so
+ * they survive a page reload (letting the UI restore the selected entry) instead of being random.
+ * @internal
+ */
+const registerQueryDevtoolsEntry = (entry) => {
+    if (!devtoolsEnabled)
+        return noop;
+    let id = entry.id;
+    if (!id) {
+        const descriptor = descriptorOf(entry);
+        const seq = idCounters.get(descriptor) ?? 0;
+        idCounters.set(descriptor, seq + 1);
+        id = `${descriptor}#${seq}`;
+    }
+    const fullEntry = { ...entry, id, createdAt: Date.now() };
+    entries.update((list) => [...list, fullEntry]);
+    return () => entries.update((list) => list.filter((e) => e.id !== fullEntry.id));
+};
+let suppressStackRegistration = false;
+/**
+ * Suppresses devtools registration for the next {@link createQueryStack} call. Used by
+ * `createPagedQueryStack` so its backing stack is not registered as a separate `query-stack` entry.
+ * @internal
+ */
+const suppressNextQueryStackDevtools = () => {
+    suppressStackRegistration = true;
+};
+/**
+ * Reads and clears the suppress-next-stack flag. Always call this from `createQueryStack` (even when
+ * devtools are disabled) so a suppression request never leaks into a later stack.
+ * @internal
+ */
+const consumeSuppressQueryStackDevtools = () => {
+    const value = suppressStackRegistration;
+    suppressStackRegistration = false;
+    return value;
+};
+/**
+ * Stringifies a query creator route. Function routes are invoked with an empty args object and any
+ * resulting `undefined` path segments are rendered as `:param`, matching the legacy devtools.
+ * @internal
+ */
+const stringifyQueryRoute = (route) => {
+    if (route === undefined || route === null)
+        return '';
+    try {
+        if (typeof route === 'function') {
+            return route({}).replace(/undefined/g, ':param');
+        }
+        return String(route);
+    }
+    catch {
+        return typeof route === 'function' ? '(dynamic route)' : String(route);
+    }
+};
+/**
+ * Extracts the human readable client name from a query client tuple. The client's DI token is named
+ * `QueryClient_<name>`, so we strip the prefix to recover the original name.
+ * @internal
+ */
+const getQueryClientName = (client) => {
+    const token = client[2];
+    const desc = token?.toString?.() ?? '';
+    return desc.replace('InjectionToken ', '').replace('QueryClient_', '') || 'unknown';
+};
+/**
+ * Enables the `@ethlete/query` devtools. Add this to your application providers (e.g. in
+ * `bootstrapApplication`) to make query clients, queries, stacks, sequences and auth providers
+ * appear in the `<et-query-devtools>` panel.
+ *
+ * When omitted, all devtools instrumentation is a no-op — no references are retained and there is no
+ * runtime overhead — so it is safe to leave out of production builds.
+ *
+ * @example
+ * ```ts
+ * bootstrapApplication(AppComponent, {
+ *   providers: [provideQueryDevtools()],
+ * });
+ * ```
+ */
+const provideQueryDevtools = () => {
+    devtoolsEnabled = true;
+    if (!isDevMode()) {
+        console.warn('You are using the Query Devtools in production mode. This increases the size of your bundle and should only be used for development purposes.');
+    }
+    return makeEnvironmentProviders([]);
+};
+
 const getOpName = /(query|mutation) ?([\w\d-_]+)? ?\(.*?\)? \{/;
 const transformGql = (str) => {
     const normalizedStr = Array.isArray(str) ? str.join('') : str;
@@ -133,6 +253,7 @@ const setupQueryDependencies = (options) => {
         injector: undefined, // Will be set after injector creation
         ngErrorHandler: hostInjector.get(ErrorHandler),
         httpClient: hostInjector.get(HttpClient),
+        hostElement: hostInjector.get(ElementRef, null, { optional: true })?.nativeElement ?? null,
     };
     const queryContext = {
         deps: dependencies,
@@ -657,6 +778,8 @@ const createQueryObject = (options) => {
     const { state, execute, deps } = options;
     const destroy = () => deps.injector.destroy();
     const setResponse = (response) => state.rawResponse.set(response);
+    const setLoading = (loading) => state.loading.set(loading);
+    const setError = (error) => state.error.set(error);
     const createSnapshot = createQuerySnapshotFn({ state, execute, deps });
     // Pre-wrap all public signals once so both `query` and `roQuery` share the same instances.
     const wrappedArgs = wrapAsObservableSignal(state.args.asReadonly(), deps.injector);
@@ -701,6 +824,8 @@ const createQueryObject = (options) => {
         subtle: {
             destroy,
             setResponse,
+            setLoading,
+            setError,
             request: wrappedRequest,
             destroyRef: deps.scopeDestroyRef,
             injector: deps.injector,
@@ -734,7 +859,28 @@ const createBaseQuery = (options) => {
         };
         applyQueryFeatures(options.features, featureFnContext);
         maybeExecute({ execute, flags });
-        return createQueryObject({ state, execute, deps });
+        const query = createQueryObject({ state, execute, deps });
+        if (isQueryDevtoolsEnabled()) {
+            const unregister = registerQueryDevtoolsEntry({
+                kind: 'query',
+                handle: query,
+                meta: {
+                    clientName: getQueryClientName(client),
+                    clientBaseUrl: deps.client.baseUrl,
+                    route: stringifyQueryRoute(options.creatorInternals.route ??
+                        options.creator?.route),
+                    method: flags.method,
+                    featureTypes: options.features.map((f) => f.type),
+                    queryConfig: options.queryConfig,
+                    creator: options.creator,
+                    repository: deps.client.repository,
+                    element: deps.hostElement,
+                    gqlQuery: options.creatorInternals.query,
+                },
+            });
+            deps.destroyRef.onDestroy(unregister);
+        }
+        return query;
     });
 };
 
@@ -1718,6 +1864,8 @@ const createHttpRequest = (options) => {
         loading.set(state);
     };
     const httpRequest = {
+        method: options.method,
+        url: options.fullPath,
         execute,
         destroy,
         loading: loading.asReadonly(),
@@ -1726,6 +1874,7 @@ const createHttpRequest = (options) => {
         currentEvent: currentEvent.asReadonly(),
         events$: event$.asObservable(),
         isStale,
+        expiresAt: expiresIn.asReadonly(),
     };
     return httpRequest;
 };
@@ -1886,6 +2035,17 @@ const createQueryStack = (options) => {
             runWithArgs,
         },
     };
+    const skipDevtools = consumeSuppressQueryStackDevtools();
+    if (isQueryDevtoolsEnabled() && !skipDevtools) {
+        const unregister = registerQueryDevtoolsEntry({
+            kind: 'query-stack',
+            handle: stack,
+            meta: {
+                featureTypes: features.map((f) => f.type),
+            },
+        });
+        inject(DestroyRef).onDestroy(unregister);
+    }
     return stack;
 };
 
@@ -1958,6 +2118,7 @@ const createPagedQueryStack = (options) => {
     ...(ngDevMode ? [{ debugName: "resetTrigger" }] : /* istanbul ignore next */ []));
     const pageDirection = signal('next', /* @ts-ignore */
     ...(ngDevMode ? [{ debugName: "pageDirection" }] : /* istanbul ignore next */ []));
+    suppressNextQueryStackDevtools();
     const stack = createQueryStack({
         args: () => null,
         queryCreator,
@@ -2165,6 +2326,16 @@ const createPagedQueryStack = (options) => {
         reset,
         execute,
     };
+    if (isQueryDevtoolsEnabled()) {
+        const unregister = registerQueryDevtoolsEntry({
+            kind: 'paged-query-stack',
+            handle: pagedQuery,
+            meta: {
+                featureTypes: features?.map((f) => f.type),
+            },
+        });
+        inject(DestroyRef).onDestroy(unregister);
+    }
     return pagedQuery;
 };
 
@@ -5285,6 +5456,11 @@ const generateUuid = () => randomId();
 const createQueryRepository = (config) => {
     const cache = new Map();
     const eventsSubject = new Subject();
+    // Bumped on every cache mutation so the devtools cache view can react. Cheap enough to keep
+    // unconditional — it is a single integer signal with no readers unless the devtools are open.
+    const cacheVersion = signal(0, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "cacheVersion" }] : /* istanbul ignore next */ []));
+    const bumpCacheVersion = () => cacheVersion.update((v) => v + 1);
     const request = (options) => {
         const { args, creatorOptions, runQueryOptions } = options;
         const shouldCache = creatorOptions?.subtle?.useQueryRepositoryCache === false
@@ -5349,6 +5525,7 @@ const createQueryRepository = (config) => {
             cacheEntry.eventSubscription?.unsubscribe();
             cache.delete(key);
         }
+        bumpCacheVersion();
         return true;
     };
     const unbindAllSecure = () => {
@@ -5361,6 +5538,7 @@ const createQueryRepository = (config) => {
                 cache.delete(key);
             }
         }
+        bumpCacheVersion();
     };
     const bind = (key, consumerDestroyRef, request, isSecure, allowReuse) => {
         const destroyListener = consumerDestroyRef.onDestroy(() => unbind(key, consumerDestroyRef));
@@ -5391,12 +5569,33 @@ const createQueryRepository = (config) => {
                 eventSubscription,
             });
         }
+        bumpCacheVersion();
+    };
+    const cacheEntries = () => Array.from(cache.entries()).map(([key, entry]) => ({
+        key,
+        isSecure: entry.isSecure,
+        consumerCount: entry.consumers.size,
+        request: entry.request,
+    }));
+    const evict = (key) => {
+        const entry = cache.get(key);
+        if (!entry)
+            return;
+        entry.request.destroy();
+        entry.eventSubscription?.unsubscribe();
+        cache.delete(key);
+        bumpCacheVersion();
     };
     const repository = {
         request,
         unbind,
         unbindAllSecure,
         events$: eventsSubject.asObservable(),
+        subtle: {
+            cacheEntries,
+            cacheVersion: cacheVersion.asReadonly(),
+            evict,
+        },
     };
     return repository;
 };
@@ -5411,6 +5610,7 @@ const createQueryClient = (options) => createRootProvider(() => {
     });
     const client = {
         repository,
+        baseUrl: options.baseUrl,
     };
     return client;
 }, {
@@ -5505,9 +5705,10 @@ const createSequenceState = () => ({
     error: signal(null),
     failedAt: signal(null),
     snapshots: signal([]),
+    stepArgs: signal([]),
     responses: signal([]),
 });
-const buildSequence = (steps, state) => {
+const buildSequence = (steps, state, devtoolsHandle) => {
     const run = async () => {
         if (state.running())
             throw querySequenceAlreadyRunning();
@@ -5517,13 +5718,17 @@ const buildSequence = (steps, state) => {
         state.error.set(null);
         state.failedAt.set(null);
         state.snapshots.set([]);
+        state.stepArgs.set([]);
         state.responses.set([]);
         const snapshots = [];
+        const stepArgs = [];
         const responses = [];
         let previousResponse = undefined;
         for (const [i, step] of steps.entries()) {
             state.currentStep.set(i + 1);
             const { args } = step.produceArgs(previousResponse, responses);
+            stepArgs.push(args);
+            state.stepArgs.set([...stepArgs]);
             const snapshot = await executeUntilSettled(step.query, { args });
             snapshots.push(snapshot);
             state.snapshots.set([...snapshots]);
@@ -5544,21 +5749,26 @@ const buildSequence = (steps, state) => {
         state.running.set(false);
         return { ok: true, responses: responses, snapshots };
     };
-    return {
+    const sequence = {
         then: (query, mapArgs) => buildSequence([
             ...steps,
             { query, produceArgs: (previousResponse, responses) => mapArgs(previousResponse, responses) },
-        ], state),
+        ], state, devtoolsHandle),
         status: state.status.asReadonly(),
         running: state.running.asReadonly(),
         currentStep: state.currentStep.asReadonly(),
         total: steps.length,
+        queries: steps.map((s) => s.query),
         error: state.error.asReadonly(),
         failedAt: state.failedAt.asReadonly(),
         snapshots: state.snapshots.asReadonly(),
+        stepArgs: state.stepArgs.asReadonly(),
         responses: state.responses.asReadonly(),
         run,
     };
+    if (devtoolsHandle)
+        devtoolsHandle.current = sequence;
+    return sequence;
 };
 /**
  * Starts an imperative waterfall of dependent queries. Chain the remaining steps with `.then()`
@@ -5582,7 +5792,27 @@ const buildSequence = (steps, state) => {
  * }
  * ```
  */
-const querySequence = (query, seedArgs) => buildSequence([{ query, produceArgs: () => seedArgs() }], createSequenceState());
+const querySequence = (query, seedArgs) => {
+    const devtoolsHandle = isQueryDevtoolsEnabled()
+        ? { current: null }
+        : undefined;
+    const seed = buildSequence([{ query, produceArgs: () => seedArgs() }], createSequenceState(), devtoolsHandle);
+    if (devtoolsHandle) {
+        const unregister = registerQueryDevtoolsEntry({
+            kind: 'query-sequence',
+            handle: devtoolsHandle,
+            meta: {},
+        });
+        // Sequences have no destroy hook; tie cleanup to the creating scope when there is one.
+        try {
+            inject(DestroyRef).onDestroy(unregister);
+        }
+        catch {
+            // Created outside an injection context — the entry lives for the app's lifetime.
+        }
+    }
+    return seed;
+};
 
 /**
  * Binds a query-backed async validator to a signal-forms field, adapting an `@ethlete/query` v3
@@ -6213,7 +6443,7 @@ const createBearerAuthProviderImpl = (config) => {
     };
     const features = setupFeatures(config.features, featureSetupContext);
     setupMultiTabSyncIfEnabled(config, accessToken, refreshToken, queryClient);
-    return {
+    const provider = {
         queries,
         features: features,
         accessToken: accessToken.asReadonly(),
@@ -6226,6 +6456,20 @@ const createBearerAuthProviderImpl = (config) => {
         logout,
         afterTokenRefresh$,
     };
+    if (isQueryDevtoolsEnabled()) {
+        const unregister = registerQueryDevtoolsEntry({
+            kind: 'auth-provider',
+            handle: provider,
+            meta: {
+                name: config.name,
+                clientName: getQueryClientName(config.queryClientRef),
+                clientBaseUrl: queryClient.baseUrl,
+                repository: queryClient.repository,
+            },
+        });
+        destroyRef.onDestroy(unregister);
+    }
+    return provider;
 };
 const createBearerAuthProvider = (config) => createRootProvider(() => createBearerAuthProviderImpl(config), { name: `BearerAuthProvider_${config.name}` });
 
@@ -7789,6 +8033,7 @@ const messageMalformed = () => {
     return new RuntimeError(WebSocketRuntimeErrorCode.MESSAGE_MALFORMED, 'A message has been received but it is malformed (cannot be parsed as JSON).');
 };
 
+const MAX_DEVTOOLS_MESSAGES = 100;
 const createWebSocketClient = (options) => {
     return createRootProvider(() => {
         const socket = io(options.url, {
@@ -7799,6 +8044,17 @@ const createWebSocketClient = (options) => {
         const rooms = new Map();
         const isConnected = signal(false, /* @ts-ignore */
         ...(ngDevMode ? [{ debugName: "isConnected" }] : /* istanbul ignore next */ []));
+        // Devtools instrumentation (no-op unless provideQueryDevtools() was called).
+        const devtoolsEnabled = isQueryDevtoolsEnabled();
+        const devtoolsRooms = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "devtoolsRooms" }] : /* istanbul ignore next */ []));
+        const devtoolsMessages = signal([], /* @ts-ignore */
+        ...(ngDevMode ? [{ debugName: "devtoolsMessages" }] : /* istanbul ignore next */ []));
+        let devtoolsMessageId = 0;
+        const syncDevtoolsRooms = () => {
+            if (devtoolsEnabled)
+                devtoolsRooms.set([...rooms.keys()]);
+        };
         const joinRoom = (room) => {
             const roomFn = typeof room === 'function' ? room : () => room;
             const pre = previousSignalValue(computed(() => roomFn()));
@@ -7815,6 +8071,7 @@ const createWebSocketClient = (options) => {
                     latestMessage: message,
                 };
                 rooms.set(name, newRoom);
+                syncDevtoolsRooms();
                 return newRoom;
             };
             effect(() => {
@@ -7851,6 +8108,7 @@ const createWebSocketClient = (options) => {
             }
             socket.emit('leave-room', room);
             rooms.delete(room);
+            syncDevtoolsRooms();
         };
         const setupWebSocketConnectionListener = () => {
             socket.on('connect', () => {
@@ -7865,6 +8123,16 @@ const createWebSocketClient = (options) => {
             socket.onAny((data) => {
                 try {
                     const json = JSON.parse(data);
+                    if (devtoolsEnabled) {
+                        const message = {
+                            id: devtoolsMessageId++,
+                            timestamp: Date.now(),
+                            room: json.room,
+                            event: json.event,
+                            data: json.data,
+                        };
+                        devtoolsMessages.update((log) => [message, ...log].slice(0, MAX_DEVTOOLS_MESSAGES));
+                    }
                     const room = rooms.get(json.room);
                     if (room)
                         room.latestMessage.set(json);
@@ -7887,6 +8155,19 @@ const createWebSocketClient = (options) => {
                 leaveRoom,
             },
         };
+        if (devtoolsEnabled) {
+            const handle = {
+                connected: isConnected.asReadonly(),
+                rooms: devtoolsRooms.asReadonly(),
+                messages: devtoolsMessages.asReadonly(),
+            };
+            const unregister = registerQueryDevtoolsEntry({
+                kind: 'ws-client',
+                handle,
+                meta: { name: options.name, url: options.url },
+            });
+            inject(DestroyRef).onDestroy(unregister);
+        }
         return client;
     }, {
         name: `WebSocketClient_${options.name}`,
@@ -7897,5 +8178,5 @@ const createWebSocketClient = (options) => {
  * Generated bundle index. Do not edit.
  */
 
-export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DateArrayQueryField, DateQueryField, EntityStore, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryExecute, queryFeatureUsedMultipleTimes, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
+export { BasicAuthProvider, BearerAuthFeatureType, BooleanArrayQueryField, CLEAR_QUERY_ARGS, CustomHeaderAuthProvider, DateArrayQueryField, DateQueryField, EntityStore, INFINITY_QUERY_TOKEN, InfinityQuery, InfinityQueryDirective, InfinityQueryTriggerDirective, LegacyQuery, LegacyQueryCreator, NumberArrayQueryField, ParseHttpErrorCodeToMessageDePipe, ParseHttpErrorCodeToMessageEnPipe, ParseHttpErrorCodeToTitleDePipe, ParseHttpErrorCodeToTitleEnPipe, QUERY_CLIENT_DEVTOOLS_TOKEN, QueryDevtoolsComponent, QueryDirective, QueryError, QueryFeatureType, QueryField, QueryForm, QueryRuntimeErrorCode, QueryShortNamePipe, QueryStore, SERVER_ERROR_KIND, SERVER_VIOLATION_ERROR_KIND, SPEED_BUFFER_TIME_IN_MS, SearchQueryField, SortQueryField, StringArrayQueryField, V2BearerAuthProvider, V2Query, V2QueryClient, V2QueryCreator, addQueryContainerHandling, applyQueryFeatures, authExtractTokensResponseMissingAccessToken, authExtractTokensResponseMissingRefreshToken, authExtractTokensResponseNotObject, authProviderFeatureUsedMultipleTimes, buildErrorMessage, buildQueryCacheKey, buildQueryString, buildRoute, buildTimestampFromSeconds, castQueryCreatorTypes, circularQueryDependency, circularQueryDependencyChecker, computeQueryAuthHeader, computeQueryBody, computeQueryHeaders, computeQueryMethod, computeQueryQueryParams, consumeSuppressQueryStackDevtools, contentfulGqlLikePaginationAdapter, createBaseQuery, createBaseQueryCreator, createBearerAuthProvider, createDeleteQuery, createExecuteFn, createGetQuery, createGqlExecuteFn, createGqlMutationViaGet, createGqlMutationViaPost, createGqlQuery, createGqlQueryCreator, createGqlQueryViaGet, createGqlQueryViaPost, createHttpRequest, createInfinityQueryConfig, createLegacyQueryCreator, createPagedQueryStack, createPatchQuery, createPersistentAuthFeature, createPostQuery, createPutQuery, createQuery, createQueryClient, createQueryCollection, createQueryCollectionSignal, createQueryCollectionSubject, createQueryContext, createQueryCreator, createQueryErrorResponse, createQueryFeature, createQueryObject, createQueryRepository, createQuerySnapshotFn, createQueryStack, createSecureDeleteQuery, createSecureExecuteFactory, createSecureExecuteFn, createSecureGetQuery, createSecureGqlExecuteFn, createSecureGqlMutationViaGet, createSecureGqlMutationViaPost, createSecureGqlQuery, createSecureGqlQueryCreator, createSecureGqlQueryViaGet, createSecureGqlQueryViaPost, createSecurePatchQuery, createSecurePostQuery, createSecurePutQuery, createSecureQuery, createSecureQueryCreator, createTrackingFeature, createWebSocketClient, decryptBearer, deepFreeze, def, detectContentTypeHeader, dynLikePaginationAdapter, effectComputed, ethletePaginationAdapter, executeUntilSettled, extractExpiresInSeconds, extractFormViolations, extractQuery, fakePaginationAdapter, filterFailure, filterNull, filterQueryStates, filterSuccess, forEachHeader, getDefaultHeaders, getQueryClientName, getQueryFeatureUsage, getResponseUrl, ggLikePaginationAdapter, gql, gqlDataPropertyMissingInResponse, hasHeader, ignoreAutoRefresh, injectInfinityQueryResponseDelay, injectQueryContext, insertFrom, invalidBaseRouteError, invalidBodyError, invalidRouteError, invalidStateInsideSecureExecuteFactory, isAutoRefresh, isBasicAuthProvider, isBearerAuthProvider, isClassValidatorError, isCreateGqlQueryOptions, isCustomHeaderAuthProvider, isEmptyString, isGqlQueryConfig, isLegacyQuery, isNaN$1 as isNaN, isQuery, isQueryCollection, isQueryDevtoolsEnabled, isQueryErrorResponse, isQueryStateCancelled, isQueryStateFailure, isQueryStateLoading, isQueryStatePrepared, isQueryStateSuccess, isRequestError, isSymfonyError, isSymfonyFormViolationListError, isSymfonyListError, isSymfonyPagerfantaOutOfRangeError, mapToPaginated, mapViolationsToFormErrors, maybeExecute, mergeHeaders, nestedEffect, pagedQueryStackNextPageCalledWithoutPreviousPage, pagedQueryStackPageBiggerThanTotalPages, pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage, paginatedEntityValueUpdater, parseAllXhrResponseHeaders, parseHttpErrorCodeToMessageDe, parseHttpErrorCodeToMessageEn, parseHttpErrorCodeToTitleDe, parseHttpErrorCodeToTitleEn, pathParamsMissingInRouteFunctionError, provideInfinityQueryResponseDelay, provideQueryClientForDevtools, provideQueryDevtools, queryArrayComputed, queryComputed, queryComputedTillTruthy, queryDevtoolsEntries, queryExecute, queryFeatureUsedMultipleTimes, querySequence, querySequenceAlreadyRunning, queryStackTotalQueriesAndExpectedQueriesMismatch, queryStackWithArgsUsed, queryStackWithResponseUpdateUsed, queryStateAlreadyHasKeyError, queryStateCannotTransformError, queryStateDoesNotContainKeyError, queryStateErrorSignal, queryStateLoadingSignal, queryStateResponseSignal, queryStateSignal, registerQueryDevtoolsEntry, removeFrom, request, resetExecuteState, resetPageOnError, serializeBody, setupQueryDependencies, setupQueryExecuteState, setupQueryState, shouldAutoExecuteGqlQuery, shouldAutoExecuteQuery, shouldCacheQuery, shouldRetryRequest, silenceMissingWithArgsFeatureErrorUsedButWithArgsPresent, skipPaginationPageParamCalculator, splitQueryConfig, stringifyQueryRoute, suppressNextQueryStackDevtools, switchQueryCollectionState, switchQueryState, takeUntilResponse, toQuerySignal, toQuerySubject, tokensNotAvailableInsideAuthAndExec, transformArrayResponse, transformExecStateToQueryState, transformGql, transformMethod, transformPaginatedResponse, transformToBoolean, transformToBooleanArray, transformToDate, transformToDateArray, transformToNumber, transformToNumberArray, transformToSort, transformToSortQueryParam, transformToString, transformToStringArray, uncacheableRequestHasAllowCacheParam, uncacheableRequestHasCacheKeyParam, v2BuildQueryCacheKey, v2ExtractExpiresInSeconds, v2ShouldCacheQuery, v2ShouldRetryRequest, validateWithQuery, validateWithV2Query, withArgs, withArgsQueryFeatureMissingButRouteIsFunction, withAuthenticationQuery, withAutoRefresh, withAutoRefreshUsedInManualQuery, withAutoRefreshUsedOnUnsupportedHttpMethod, withErrorHandling, withInactivityLogout, withLogging, withPersistentAuth, withPolling, withPollingUsedOnUnsupportedHttpMethod, withRefreshQuery, withResponseUpdate, withSuccessHandling, withTokenExpirationWarning, withTokenRevocation, withTracking, wrapAsObservableSignal };
 //# sourceMappingURL=ethlete-query.mjs.map