@ethlete/query 5.23.0 → 5.25.0

package/lib/experimental/{bearer-auth-provider-config.d.ts → auth/bearer-auth-provider-config.d.ts}

@@ -1,8 +1,6 @@
 import { InjectionToken } from '@angular/core';
+import { QueryArgs, QueryClientRef, QueryCreator, RequestArgs, ResponseType } from '../http';
 import { BearerAuthProvider } from './bearer-auth-provider';
-import { QueryArgs, RequestArgs, ResponseType } from './query';
-import { QueryClientRef } from './query-client-config';
-import { QueryCreator } from './query-creator';
 export type BearerAuthProviderTokens = {
     accessToken: string;
     refreshToken: string;
@@ -57,6 +55,16 @@ export type BearerAuthProviderCookieConfig<TTokenRefreshArgs extends QueryArgs>
      * @default (token) => ({ token })
      */
     refreshArgsTransformer?: (token: string) => RequestArgs<TTokenRefreshArgs>;
+    /**
+     * An array of routes where the auto login via cookie should not be triggered.
+     *
+     * This checks the current route against the array of routes using the `startsWith` method.
+     * Make sure to start each route with a `/`.
+     *
+     * @default []
+     * @example ['/login', '/register']
+     */
+    autoLoginExcludeRoutes?: string[];
 };
 export type CreateBearerAuthProviderConfigOptions<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = {
     /**

package/lib/experimental/{bearer-auth-provider.d.ts → auth/bearer-auth-provider.d.ts}

@@ -1,7 +1,7 @@
 import { HttpErrorResponse } from '@angular/common/http';
 import { Signal } from '@angular/core';
+import { QueryArgs, QuerySnapshot, RequestArgs } from '../http';
 import { BearerAuthProviderConfig, BearerAuthProviderTokens } from './bearer-auth-provider-config';
-import { QueryArgs, QuerySnapshot, RequestArgs } from './query';
 type QuerySnapshotWithType<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = ({
     type: 'login';
 } & QuerySnapshot<TLoginArgs>) | ({

package/lib/experimental/auth/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bearer-auth-provider';
+export * from './bearer-auth-provider-config';

package/lib/experimental/gql/gql-query-creator-templates.d.ts

@@ -0,0 +1,11 @@
+import { QueryClientConfig } from '../http';
+import { GqlQueryArgs } from './gql-query';
+import { CreateGqlQueryCreatorOptions } from './gql-query-creator';
+/** A query creator that creates a GQL query where the payload is sent via GET (query params) */
+export declare const createGqlQueryViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+/** A query creator that creates a GQL query where the payload is sent via POST (body) */
+export declare const createGqlQueryViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+/** A query creator that creates a GQL mutation where the payload is sent via GET (query params) */
+export declare const createGqlMutationViaGet: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;
+/** A query creator that creates a GQL mutation where the payload is sent via POST (body) */
+export declare const createGqlMutationViaPost: (client: QueryClientConfig) => <TArgs extends GqlQueryArgs>(creatorOptions: CreateGqlQueryCreatorOptions<TArgs>) => import("../http").QueryCreator<TArgs>;

package/lib/experimental/gql/gql-query-creator.d.ts

@@ -0,0 +1,14 @@
+import { CreateQueryCreatorOptions, QueryClientConfig, QueryCreator, RouteType } from '../http';
+import { GqlQueryArgs } from './gql-query';
+export type CreateGqlQueryCreatorOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryCreatorOptions<TArgs>, 'route'> & {
+    query: string;
+    route?: RouteType<TArgs>;
+};
+export type GqlQueryMethod = 'QUERY' | 'MUTATE';
+export type GqlQueryTransport = 'GET' | 'POST';
+export type InternalCreateGqlQueryCreatorOptions = {
+    method: GqlQueryMethod;
+    transport: GqlQueryTransport;
+    client: QueryClientConfig;
+};
+export declare const createGqlQueryCreator: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryCreatorOptions<TArgs>, internals: InternalCreateGqlQueryCreatorOptions) => QueryCreator<TArgs>;

package/lib/experimental/gql/gql-query-execute.d.ts

@@ -0,0 +1,11 @@
+import { InternalQueryExecute, QueryArgs, QueryConfig, QueryDependencies, QueryState } from '../http';
+import { GqlQueryArgs } from './gql-query';
+import { CreateGqlQueryCreatorOptions, InternalCreateGqlQueryCreatorOptions } from './gql-query-creator';
+export type CreateGqlQueryExecuteOptions<TArgs extends QueryArgs> = {
+    deps: QueryDependencies;
+    state: QueryState<TArgs>;
+    creator: CreateGqlQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateGqlQueryCreatorOptions;
+    queryConfig: QueryConfig;
+};
+export declare const createGqlExecuteFn: <TArgs extends GqlQueryArgs>(executeOptions: CreateGqlQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;

package/lib/experimental/gql/gql-query.d.ts

@@ -0,0 +1,12 @@
+import { CreateQueryOptions, QueryArgs } from '../http';
+import { CreateGqlQueryCreatorOptions, InternalCreateGqlQueryCreatorOptions } from './gql-query-creator';
+export type GqlQueryArgs = QueryArgs & {
+    variables?: Record<string, unknown>;
+};
+export type CreateGqlQueryOptions<TArgs extends GqlQueryArgs> = Omit<CreateQueryOptions<TArgs>, 'creator' | 'creatorInternals'> & {
+    creator: CreateGqlQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateGqlQueryCreatorOptions;
+};
+export type GqlVariablesType<T extends GqlQueryArgs | null> = T extends GqlQueryArgs ? T['variables'] : never;
+export declare const isCreateGqlQueryOptions: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs> | CreateGqlQueryOptions<TArgs>) => options is CreateGqlQueryOptions<TArgs>;
+export declare const createGqlQuery: <TArgs extends GqlQueryArgs>(options: CreateGqlQueryOptions<TArgs>) => import("../http").Query<TArgs>;

package/lib/experimental/gql/index.d.ts

@@ -0,0 +1,4 @@
+export * from './gql-query';
+export * from './gql-query-creator';
+export * from './gql-query-creator-templates';
+export * from './gql-query-execute';

package/lib/experimental/http/index.d.ts

@@ -0,0 +1,20 @@
+export * from './http-request';
+export * from './paged-query-stack';
+export * from './query';
+export * from './query-client';
+export * from './query-client-config';
+export * from './query-creator';
+export * from './query-creator-templates';
+export * from './query-dependencies';
+export * from './query-errors';
+export * from './query-execute';
+export * from './query-execute-utils';
+export * from './query-features';
+export * from './query-repository';
+export * from './query-snapshot';
+export * from './query-stack';
+export * from './query-state';
+export * from './query-utils';
+export * from './secure-query';
+export * from './secure-query-creator';
+export * from './secure-query-execute';

package/lib/experimental/http/paged-query-stack.d.ts

@@ -0,0 +1,149 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { ContentfulGqlLikePaginated, DynLikePaginated, GgLikePaginated, NormalizedPagination, Paginated } from '@ethlete/types';
+import { AnyQuery, Query, QueryArgs, RequestArgs, ResponseType } from './query';
+import { AnyQueryCreator, QueryArgsOf, QueryCreator } from './query-creator';
+import { QueryFeature } from './query-features';
+export declare const ethletePaginationAdapter: <T>(response: Paginated<T>) => NormalizedPagination<T>;
+export declare const ggLikePaginationAdapter: <T>(response: GgLikePaginated<T>) => NormalizedPagination<T>;
+export declare const dynLikePaginationAdapter: <T>(response: DynLikePaginated<T>) => NormalizedPagination<T>;
+export declare const contentfulGqlLikePaginationAdapter: <T>(response: ContentfulGqlLikePaginated<T>) => NormalizedPagination<T>;
+export declare const fakePaginationAdapter: (totalHits?: number) => <T>(response: T) => NormalizedPagination<T>;
+export type CreatePagedQueryStackOptions<TArgs extends QueryArgs> = {
+    /**
+     * The normalizer function that will be used to normalize the response to a format that the paged query can understand.
+     *
+     * There are some built-in normalizers that can be used:
+     * - `ethletePaginationAdapter`
+     * - `ggLikePaginationAdapter`
+     * - `dynLikePaginationAdapter`
+     * - `contentfulGqlLikePaginationAdapter`
+     * - `fakePaginationAdapter` (for testing purposes)
+     */
+    responseNormalizer: (response: ResponseType<TArgs>) => NormalizedPagination<ResponseType<TArgs>>;
+    /**
+     * The query creator function that will be used to create the paged query.
+     */
+    queryCreator: QueryCreator<TArgs>;
+    /**
+     * The arguments to create the query.
+     * The current page will be passed as an argument.
+     * This function can be treated like a computed function. It reacts to signal changes.
+     * If a signal changes, the paged query will be reset to the initial page.
+     *
+     * @example (page) => ({ queryParams: { page, limit:20 } }),
+     */
+    args: (page: number) => RequestArgs<TArgs>;
+    /**
+     * The features that should be used for all queries in the stack.
+     *
+     * @throws If the `withArgs` feature is used. This feature is internally used.
+     *
+     * @example
+     * // Due to limitations in TypeScript, you have to manually add the needed generic types if needed.
+     * features: [E.withSuccessHandling<GetPostQueryArgs>({ handler: (post) => console.log(post.title) })]
+     *
+     * @example
+     * // If typings are not needed, you can use the feature without generics.
+     * features: [E.withPolling({ interval: 5000 })]
+     */
+    features?: QueryFeature<any>[];
+    /**
+     * The page to start this paged query from.
+     * @default 1
+     */
+    initialPage?: number;
+};
+export type PagedQueryStackResetOptions = {
+    /**
+     * The page to reset this paged query to.
+     * This will clear everything and start from this page.
+     * @default 1 // or the value passed in the `initialPage` option when creating the paged query.
+     */
+    initialPage?: number;
+};
+export type PagedQueryStackExecuteOptions<TArgs extends QueryArgs> = {
+    /**
+     * If provided, only the queries that match the condition will be executed.
+     * This will also execute the previous and next query to the one that matched the condition.
+     * If not provided, all queries will be executed.
+     *
+     * @example
+     * myPagedQuery.execute({ where: (item) => item.id === 4 });
+     */
+    where?: (item: ResponseType<TArgs>, index: number, array: ResponseType<TArgs>[]) => boolean;
+    /**
+     * If true, the cache will be used (if not expired) and the request will not be made.
+     * @default false
+     */
+    allowCache?: boolean;
+};
+export type PagedQueryStackDirection = 'next' | 'previous';
+export type AnyPagedQueryStack = PagedQueryStack<AnyQuery>;
+export type PagedQueryStack<TQuery extends AnyQuery> = {
+    /**
+     * The current pagination state of the paged query.
+     */
+    pagination: Signal<NormalizedPagination<ResponseType<QueryArgsOf<TQuery>>> | null>;
+    /**
+     * Fetches the previous page of the paged query.
+     *
+     * @throws If the paged query is already at the first page.
+     */
+    fetchPreviousPage: () => void;
+    /**
+     * Fetches the next page of the paged query.
+     *
+     * @throws If the paged query is already at the last page.
+     */
+    fetchNextPage: () => void;
+    /**
+     * Whether the previous page can be fetched or not.
+     *
+     * This will be false if the paged query is already at the first page or if the paged query is loading.
+     */
+    canFetchPreviousPage: Signal<boolean>;
+    /**
+     * Whether the next page can be fetched or not.
+     *
+     * This will be false if the paged query is already at the last page or if the paged query is loading.
+     */
+    canFetchNextPage: Signal<boolean>;
+    /**
+     * The items of the paged query.
+     */
+    items: Signal<ResponseType<QueryArgsOf<TQuery>>[]>;
+    /**
+     * Whether the paged query is loading or not.
+     */
+    loading: Signal<boolean>;
+    /**
+     * The error that occurred during the last execution of the paged query.
+     */
+    error: Signal<HttpErrorResponse | null>;
+    /**
+     * The last query executed in the paged query.
+     */
+    lastQuery: Signal<Query<QueryArgsOf<TQuery>> | null>;
+    /**
+     * Whether the paged query is on its first load or not.
+     */
+    isFirstLoad: Signal<boolean>;
+    /**
+     * The queries in the paged query stack.
+     */
+    queries: Signal<TQuery[]>;
+    /**
+     * Resets the paged query to the initial page.
+     */
+    reset: (resetOptions?: PagedQueryStackResetOptions) => void;
+    /**
+     * Executes the paged query.
+     */
+    execute: (options?: PagedQueryStackExecuteOptions<QueryArgsOf<TQuery>>) => void;
+    /**
+     * The current direction of the paged query.
+     */
+    direction: Signal<PagedQueryStackDirection>;
+};
+export declare const createPagedQueryStack: <TCreator extends AnyQueryCreator, TArgs extends QueryArgsOf<TCreator>>(options: CreatePagedQueryStackOptions<TArgs>) => PagedQueryStack<Query<TArgs>>;

package/lib/experimental/http/query-client-config.d.ts

@@ -0,0 +1,45 @@
+import { HttpHeaders } from '@angular/common/http';
+import { InjectionToken } from '@angular/core';
+import { BuildQueryStringConfig } from '../../request';
+import { QueryClient } from './query-client';
+import { ShouldRetryRequestFn } from './query-utils';
+export type CacheAdapterFn = (headers: HttpHeaders) => number | null;
+export type CreateQueryClientConfigOptions = {
+    /**
+     * The base URL of the client
+     * @example 'https://api.example.com/v1'
+     */
+    baseUrl: string;
+    /** Configuration for building query strings */
+    queryString?: BuildQueryStringConfig;
+    /** The name of the client */
+    name: string;
+    /**
+     * The cache adapter function to use for the client.
+     * It determines how long the response of a request can be cached.
+     *
+     * @default extractExpiresInSeconds()
+     */
+    cacheAdapter?: CacheAdapterFn;
+    /**
+     * The retry function to use for the client.
+     * It determines if a request should be retried after it failed.
+     *
+     * @default shouldRetryRequest()
+     */
+    retryFn?: ShouldRetryRequestFn;
+};
+export type QueryClientConfig = CreateQueryClientConfigOptions & {
+    /** A generated token for dependency injection */
+    token: QueryClientRef;
+};
+/**
+ * A token for a query client.
+ * This token can be used to inject a query client into a service.
+ */
+export type QueryClientRef = InjectionToken<QueryClient>;
+/**
+ * This function creates a query client config.
+ * The config is used to create a query client using the `provideQueryClient(myConfig)` function.
+ */
+export declare const createQueryClientConfig: (options: CreateQueryClientConfigOptions) => QueryClientConfig;

package/lib/experimental/{query-creator-templates.d.ts → http/query-creator-templates.d.ts}

@@ -1,14 +1,24 @@
-import { AnyBearerAuthProviderConfig } from './bearer-auth-provider-config';
+import { AnyBearerAuthProviderConfig } from '../auth/bearer-auth-provider-config';
 import { QueryArgs } from './query';
 import { QueryClientConfig } from './query-client-config';
 import { CreateQueryCreatorOptions } from './query-creator';
+/** A query creator that creates a GET query */
 export declare const createGetQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a secure GET query (requires authentication) */
 export declare const createSecureGetQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a POST query */
 export declare const createPostQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a secure POST query (requires authentication) */
 export declare const createSecurePostQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a PUT query */
 export declare const createPutQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a secure PUT query (requires authentication) */
 export declare const createSecurePutQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a DELETE query */
 export declare const createDeleteQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a secure DELETE query (requires authentication) */
 export declare const createSecureDeleteQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a PATCH query */
 export declare const createPatchQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+/** A query creator that creates a secure PATCH query (requires authentication) */
 export declare const createSecurePatchQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;

package/lib/experimental/http/query-creator.d.ts

@@ -0,0 +1,73 @@
+import { HttpRequestResponseType, HttpRequestTransferCacheConfig } from './http-request';
+import { AnyQuery, PathParamsType, Query, QueryArgs } from './query';
+import { QueryClientConfig } from './query-client-config';
+import { QueryFeature } from './query-features';
+export type RouteType<TArgs extends QueryArgs> = PathParamsType<TArgs> extends {
+    [key: string]: unknown;
+} ? (args: TArgs['pathParams']) => RouteString : RouteString;
+export type RouteString = `/${string}`;
+export type CreateQueryCreatorOptions<TArgs extends QueryArgs> = {
+    /**
+     * The route of the query.
+     * If the query has path params, the route should be a function that takes the path params as an argument.
+     * Otherwise, it should be a string.
+     */
+    route: RouteType<TArgs>;
+    /**
+     * If true, the query loading state will include progress information.
+     * This is useful for file uploads and downloads.
+     *
+     * **Warning**: Upload progress events are not supported by browsers when using the fetch API, such as with `provideHttpClient(withFetch())`.
+     * In this case, you should use the older XHR implementation by omitting `withFetch()`. But take into account that XHR is not supported in server-side rendering environments.
+     *
+     * @see https://angular.dev/guide/http/making-requests#receiving-raw-progress-events
+     *
+     * @default false
+     */
+    reportProgress?: boolean;
+    /**
+     * The response type of the query.
+     * @default 'json'
+     */
+    responseType?: HttpRequestResponseType;
+    /**
+     * Whether to include credentials (cookies) in the request or not.
+     * @default false
+     */
+    withCredentials?: boolean;
+    /**
+     * This property accepts either a boolean to enable/disable transferring cache for eligible
+     * requests performed using `HttpClient`, or an object, which allows to configure cache
+     * parameters, such as which headers should be included (no headers are included by default).
+     *
+     * Setting this property will override the options passed to `provideClientHydration()` for this
+     * particular request
+     */
+    transferCache?: HttpRequestTransferCacheConfig;
+};
+export type QueryCreator<TArgs extends QueryArgs> = {
+    (...features: QueryFeature<TArgs>[]): Query<TArgs>;
+    (queryConfig: QueryConfig, ...features: QueryFeature<TArgs>[]): Query<TArgs>;
+};
+export type AnyQueryCreator = QueryCreator<any>;
+export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery> = T extends QueryCreator<infer TArgs> ? TArgs : T extends Query<infer TArgs> ? TArgs : never;
+export type RunQueryCreator<TCreator extends AnyQueryCreator> = ReturnType<TCreator>;
+export type QueryMethod = 'GET' | 'OPTIONS' | 'HEAD' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'TRACE' | 'CONNECT';
+export type InternalCreateQueryCreatorOptions = {
+    method: QueryMethod;
+    client: QueryClientConfig;
+};
+export type QueryConfig = {
+    /** A custom id to use for this query. Only affects queries that can be cached. */
+    key?: string;
+    /**
+     * If true, the query will not be executed automatically.
+     * Does not affect mutations such as POST, PUT etc. since those are never executed automatically.
+     */
+    onlyManualExecution?: boolean;
+};
+export declare const splitQueryConfig: <TArgs extends QueryArgs>(args: (QueryFeature<TArgs> | QueryConfig)[]) => {
+    features: QueryFeature<TArgs>[];
+    queryConfig: QueryConfig;
+};
+export declare const createQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions<TArgs>, internals: InternalCreateQueryCreatorOptions) => QueryCreator<TArgs>;

package/lib/experimental/{query-dependencies.d.ts → http/query-dependencies.d.ts}

@@ -5,8 +5,13 @@ export type SetupQueryDependenciesOptions = {
     clientConfig: QueryClientConfig;
 };
 export type QueryDependencies = {
+    /** The destroy ref of the query. */
     destroyRef: DestroyRef;
+    /** The destroy ref of the scope the query is in (e.g. a component) */
+    scopeDestroyRef: DestroyRef;
+    /** The query client */
     client: QueryClient;
+    /** The injector of the query */
     injector: EnvironmentInjector;
 };
 export declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;

package/lib/experimental/http/query-errors.d.ts

@@ -0,0 +1,52 @@
+import { RuntimeError } from '@ethlete/core';
+import { QueryFeatureType } from './query-features';
+export declare const enum QueryRuntimeErrorCode {
+    QUERY_FEATURE_USED_MULTIPLE_TIMES = 0,
+    WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION = 100,
+    WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD = 101,
+    WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD = 102,
+    WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY = 103,
+    COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED = 200,
+    ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 201,
+    DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG = 202,
+    LOGIN_CALLED_WITHOUT_CONFIG = 203,
+    LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG = 204,
+    REFRESH_TOKEN_CALLED_WITHOUT_CONFIG = 205,
+    SELECT_ROLE_CALLED_WITHOUT_CONFIG = 206,
+    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT = 207,
+    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN = 208,
+    DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN = 209,
+    UNABLE_TO_DECRYPT_BEARER_TOKEN = 210,
+    BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER = 211,
+    UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM = 300,
+    UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM = 301,
+    PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES = 400,
+    PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE = 401,
+    PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE = 402,
+    QUERY_STACK_WITH_ARGS_USED = 500,
+    QUERY_STACK_WITH_RESPONSE_UPDATE_USED = 501
+}
+export declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<QueryRuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES>;
+export declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<QueryRuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION>;
+export declare const withPollingUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<QueryRuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD>;
+export declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: string) => RuntimeError<QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD>;
+export declare const withAutoRefreshUsedInManualQuery: () => RuntimeError<QueryRuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY>;
+export declare const cookieLoginTriedButCookieDisabled: () => RuntimeError<QueryRuntimeErrorCode.COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED>;
+export declare const enableCookieCalledWithoutCookieConfig: () => RuntimeError<QueryRuntimeErrorCode.ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
+export declare const disableCookieCalledWithoutCookieConfig: () => RuntimeError<QueryRuntimeErrorCode.DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
+export declare const loginCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.LOGIN_CALLED_WITHOUT_CONFIG>;
+export declare const loginWithTokenCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG>;
+export declare const refreshTokenCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.REFRESH_TOKEN_CALLED_WITHOUT_CONFIG>;
+export declare const selectRoleCalledWithoutConfig: () => RuntimeError<QueryRuntimeErrorCode.SELECT_ROLE_CALLED_WITHOUT_CONFIG>;
+export declare const defaultResponseTransformerResponseNotObject: (currentType: string) => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT>;
+export declare const defaultResponseTransformerResponseNotContainingAccessToken: () => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN>;
+export declare const defaultResponseTransformerResponseNotContainingRefreshToken: () => RuntimeError<QueryRuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN>;
+export declare const unableToDecryptBearerToken: (token: string) => RuntimeError<QueryRuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN>;
+export declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<QueryRuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER>;
+export declare const uncacheableRequestHasCacheKeyParam: (key: string) => RuntimeError<QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_CACHE_KEY_PARAM>;
+export declare const uncacheableRequestHasAllowCacheParam: () => RuntimeError<QueryRuntimeErrorCode.UNCACHEABLE_REQUEST_HAS_ALLOW_CACHE_PARAM>;
+export declare const pagedQueryStackPageBiggerThanTotalPages: (page: number, totalPages: number) => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PAGE_BIGGER_THAN_TOTAL_PAGES>;
+export declare const pagedQueryStackNextPageCalledWithoutPreviousPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_NEXT_PAGE_CALLED_WITHOUT_PREVIOUS_PAGE>;
+export declare const pagedQueryStackPreviousPageCalledButAlreadyAtFirstPage: () => RuntimeError<QueryRuntimeErrorCode.PAGED_QUERY_STACK_PREVIOUS_PAGE_CALLED_BUT_ALREADY_AT_FIRST_PAGE>;
+export declare const queryStackWithArgsUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_ARGS_USED>;
+export declare const queryStackWithResponseUpdateUsed: () => RuntimeError<QueryRuntimeErrorCode.QUERY_STACK_WITH_RESPONSE_UPDATE_USED>;

package/lib/experimental/{query-execute-utils.d.ts → http/query-execute-utils.d.ts}

@@ -2,7 +2,7 @@ import { EffectRef, WritableSignal } from '@angular/core';
 import { QueryArgs, RequestArgs } from './query';
 import { CreateQueryExecuteOptions } from './query-execute';
 export type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
-    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state' | 'deps'>;
     executeState: QueryExecuteState;
 };
 export declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
@@ -14,15 +14,28 @@ export declare const setupQueryExecuteState: () => QueryExecuteState;
 export type RunQueryExecuteOptions = {
     allowCache?: boolean;
 };
+export type InternalRunQueryExecuteOptions = {
+    /**
+     * If true, the request will be forced to be cached (saved inside the query repository).
+     * Can be used to e.g. cache GQL queries transported via POST
+     *
+     * - `true` means the request will always be cached
+     * - `false` means the request will never be cached
+     * - `undefined` means the request will be cached if the method is GET, OPTIONS or HEAD
+     */
+    useQueryRepositoryCache?: boolean;
+};
 export type QueryExecuteOptions<TArgs extends QueryArgs> = {
     executeOptions: CreateQueryExecuteOptions<TArgs>;
     executeState: QueryExecuteState;
     args: RequestArgs<TArgs> | null;
     options?: RunQueryExecuteOptions;
+    internalOptions?: InternalRunQueryExecuteOptions;
+    transformResponse?: (response: any) => any;
 };
 export declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
 export type CleanupPreviousExecuteOptions<TArgs extends QueryArgs> = {
-    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeOptions: Pick<CreateQueryExecuteOptions<TArgs>, 'state'>;
     executeState: QueryExecuteState;
 };
 export declare const cleanupPreviousExecute: <TArgs extends QueryArgs>(options: CleanupPreviousExecuteOptions<TArgs>) => void;

package/lib/experimental/{query-execute.d.ts → http/query-execute.d.ts}

@@ -3,6 +3,7 @@ import { QueryArgs, RequestArgs } from './query';
 import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
 import { QueryDependencies } from './query-dependencies';
 import { RunQueryExecuteOptions } from './query-execute-utils';
+import { QueryKeyOrNone } from './query-repository';
 import { QueryState } from './query-state';
 export type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
     deps: QueryDependencies;
@@ -15,9 +16,10 @@ export type QueryExecuteArgs<TArgs extends QueryArgs> = {
     args?: RequestArgs<TArgs> | null;
     options?: RunQueryExecuteOptions;
 };
-export type QueryExecute<TArgs extends QueryArgs> = {
+export type InternalQueryExecute<TArgs extends QueryArgs> = {
     (executeArgs?: QueryExecuteArgs<TArgs>): void;
     reset: () => void;
-    currentRepositoryKey: Signal<string | false>;
+    currentRepositoryKey: Signal<QueryKeyOrNone>;
 };
-export declare const createExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateQueryExecuteOptions<TArgs>) => QueryExecute<TArgs>;
+export type QueryExecute<TArgs extends QueryArgs> = (executeArgs?: QueryExecuteArgs<TArgs>) => void;
+export declare const createExecuteFn: <TArgs extends QueryArgs>(executeOptions: CreateQueryExecuteOptions<TArgs>) => InternalQueryExecute<TArgs>;