@ethlete/query 5.17.0 → 5.19.0

package/index.d.ts

@@ -5,6 +5,7 @@ export * from './lib/devtools/pipes';
 export * from './lib/devtools/utils';
 export * from './lib/directives';
 export * from './lib/entity';
+export * as ExperimentalQuery from './lib/experimental';
 export * from './lib/gql';
 export * from './lib/infinite-query';
 export * from './lib/logger';

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

@@ -0,0 +1,111 @@
+import { InjectionToken } from '@angular/core';
+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;
+};
+export type BearerAuthProviderRouteConfig<TArgs extends QueryArgs> = {
+    queryCreator: QueryCreator<TArgs>;
+    /**
+     * A function that transforms the response into the format that the auth provider expects
+     *
+     * The expected format is an object with the `accessToken` and `refreshToken` properties.
+     *
+     * @default (response) => response
+     */
+    responseTransformer?: (response: ResponseType<TArgs>) => BearerAuthProviderTokens;
+};
+export type BearerAuthProviderCookieConfig<TTokenRefreshArgs extends QueryArgs> = {
+    /**
+     * The cookie name where the refresh token is stored
+     * @default 'etAuth'
+     */
+    name?: string;
+    /**
+     * The domain of the cookie. If not set, the current origin will be used.
+     *
+     * @example
+     * "https://example.com" -> "example.com"
+     * "https://sub.example.com" -> "example.com"
+     */
+    domain?: string;
+    /**
+     * The days until the cookie expires
+     * @default 30
+     */
+    expiresInDays?: number;
+    /**
+     * The path of the cookie
+     * @default '/'
+     */
+    path?: string;
+    /**
+     * Enable or disable the cookie
+     * @default true
+     */
+    enabled?: boolean;
+    /**
+     * The same site property of the cookie
+     * @default 'lax'
+     */
+    sameSite?: 'strict' | 'none' | 'lax';
+    /**
+     * A function that turns the token gotten from the cookie into the body for the refresh token request
+     * @default (token) => ({ token })
+     */
+    refreshArgsTransformer?: (token: string) => RequestArgs<TTokenRefreshArgs>;
+};
+export type CreateBearerAuthProviderConfigOptions<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = {
+    /**
+     * The name of the auth provider
+     */
+    name: string;
+    /**
+     * The query client reference
+     */
+    queryClientRef: QueryClientRef;
+    /**
+     * The login route configuration
+     */
+    login?: BearerAuthProviderRouteConfig<TLoginArgs>;
+    /**
+     * The token login route configuration
+     */
+    tokenLogin?: BearerAuthProviderRouteConfig<TTokenLoginArgs>;
+    /**
+     * The token refresh route configuration
+     */
+    tokenRefresh?: BearerAuthProviderRouteConfig<TTokenRefreshArgs>;
+    /**
+     * The select role route configuration
+     */
+    selectRole?: BearerAuthProviderRouteConfig<TSelectRoleArgs>;
+    /**
+     * The cookie configuration for the auth provider
+     */
+    cookie?: BearerAuthProviderCookieConfig<TTokenRefreshArgs>;
+    /**
+     * The time in milliseconds before the token expires when the refresh should be triggered.
+     * @default 300000 // (5 minutes)
+     */
+    refreshBuffer?: number;
+    /**
+     * The expires in property name inside the jwt body
+     * @default 'exp'
+     */
+    expiresInPropertyName?: string;
+    /**
+     * Determines if the token should be refreshed if **any** query returns a 401 response.
+     * @default true
+     */
+    refreshOnUnauthorizedResponse?: boolean;
+};
+export type BearerAuthProviderConfig<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs> & {
+    token: BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>;
+};
+export type AnyBearerAuthProviderConfig = BearerAuthProviderConfig<any, any, any, any>;
+export type BearerAuthProviderRef<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = InjectionToken<BearerAuthProvider<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>>;
+export declare const createBearerAuthProviderConfig: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs>(options: CreateBearerAuthProviderConfigOptions<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>) => BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>;

package/lib/experimental/bearer-auth-provider.d.ts

@@ -0,0 +1,63 @@
+import { HttpErrorResponse } from '@angular/common/http';
+import { Signal } from '@angular/core';
+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>) | ({
+    type: 'tokenLogin';
+} & QuerySnapshot<TTokenLoginArgs>) | ({
+    type: 'tokenRefresh';
+} & QuerySnapshot<TTokenRefreshArgs>) | ({
+    type: 'selectRole';
+} & QuerySnapshot<TSelectRoleArgs>);
+export type BearerAuthProvider<TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs> = {
+    /**
+     * Logs in the user with the given args.
+     */
+    login: (args: RequestArgs<TLoginArgs>) => QuerySnapshot<TLoginArgs>;
+    /**
+     * Logs in the user with the given token.
+     */
+    loginWithToken: (args: RequestArgs<TTokenLoginArgs>) => QuerySnapshot<TTokenLoginArgs>;
+    /**
+     * Refreshes the token with the given refresh token.
+     */
+    refreshToken: (args: RequestArgs<TTokenRefreshArgs>) => QuerySnapshot<TTokenRefreshArgs>;
+    /**
+     * Selects the role for the user.
+     */
+    selectRole: (args: RequestArgs<TSelectRoleArgs>) => QuerySnapshot<TSelectRoleArgs>;
+    /**
+     * Logs out the user and removes the cookie.
+     */
+    logout: () => void;
+    /**
+     * Enables cookie usage for the auth provider.
+     */
+    enableCookie: () => void;
+    /**
+     * Disables cookie usage for the auth provider and removes the cookie.
+     */
+    disableCookie: () => void;
+    /**
+     * Tries to login with the given cookie config.
+     * Returns `true` if a cookie was found, `false` otherwise.
+     */
+    tryLoginWithCookie: () => boolean;
+    /**
+     * The latest executed query that was not triggered internally.
+     */
+    latestExecutedQuery: Signal<QuerySnapshotWithType<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs> | null>;
+    onRefreshFailure?: (callback: (error: HttpErrorResponse) => void) => void;
+    /**
+     * A signal that contains the current access and refresh tokens.
+     */
+    tokens: Signal<BearerAuthProviderTokens | null>;
+};
+export declare const createBearerAuthProvider: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs>(options: BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>) => BearerAuthProvider<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>;
+export declare const provideBearerAuthProvider: <TLoginArgs extends QueryArgs, TTokenLoginArgs extends QueryArgs, TTokenRefreshArgs extends QueryArgs, TSelectRoleArgs extends QueryArgs>(config: BearerAuthProviderConfig<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>) => {
+    provide: import("./bearer-auth-provider-config").BearerAuthProviderRef<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>;
+    useFactory: () => BearerAuthProvider<TLoginArgs, TTokenLoginArgs, TTokenRefreshArgs, TSelectRoleArgs>;
+};
+export {};

package/lib/experimental/http-request.d.ts

@@ -0,0 +1,55 @@
+import { HttpClient, HttpContext, HttpErrorResponse, HttpEvent, HttpHeaders } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { BodyType, PathParamsType, QueryArgs, QueryParamsType, ResponseType } from './query';
+import { CacheAdapterFn } from './query-client-config';
+import { QueryMethod } from './query-creator';
+import { ShouldRetryRequestFn } from './query-utils';
+export declare const SPEED_BUFFER_TIME_IN_MS = 2000;
+export type CreateHttpRequestOptions<TArgs extends QueryArgs> = {
+    method: QueryMethod;
+    fullPath: string;
+    pathParams?: PathParamsType<TArgs>;
+    queryParams?: QueryParamsType<TArgs>;
+    body?: BodyType<TArgs>;
+    reportProgress?: boolean;
+    withCredentials?: boolean;
+    transferCache?: boolean | {
+        includeHeaders?: string[];
+    };
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+    context?: HttpContext;
+    headers?: HttpHeaders;
+    httpClient: HttpClient;
+    cacheAdapter?: CacheAdapterFn;
+    retryFn?: ShouldRetryRequestFn;
+};
+export type HttpRequestLoadingState = {
+    executeTime: number;
+    progress: HttpRequestLoadingProgressState | null;
+};
+export type HttpRequestLoadingProgressState = {
+    /** The total number of bytes to be transferred */
+    total: number;
+    /** The number of bytes transferred */
+    loaded: number;
+    /** The percentage of the transfer that is completed */
+    percentage: number;
+    /** The speed of the transfer in bytes per millisecond */
+    speed: number | null;
+    /** The estimated remaining time in milliseconds */
+    remainingTime: number | null;
+};
+export type HttpRequest<TArgs extends QueryArgs> = {
+    execute: () => boolean;
+    destroy: () => boolean;
+    loading: Signal<HttpRequestLoadingState | null>;
+    error: Signal<HttpErrorResponse | null>;
+    response: Signal<ResponseType<TArgs> | null>;
+    currentEvent: Signal<HttpEvent<ResponseType<TArgs>> | HttpErrorEvent | null>;
+    isStale: Signal<boolean>;
+};
+export type HttpErrorEvent = {
+    type: 'error';
+    error: HttpErrorResponse;
+};
+export declare const createHttpRequest: <TArgs extends QueryArgs>(options: CreateHttpRequestOptions<TArgs>) => HttpRequest<TArgs>;

package/lib/experimental/index.d.ts

@@ -0,0 +1,20 @@
+export * from './bearer-auth-provider';
+export * from './bearer-auth-provider-config';
+export * from './http-request';
+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-state';
+export * from './query-utils';
+export * from './secure-query';
+export * from './secure-query-creator';
+export * from './secure-query-execute';

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

@@ -0,0 +1,18 @@
+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 = {
+    baseUrl: string;
+    queryString?: BuildQueryStringConfig;
+    name: string;
+    cacheAdapter?: CacheAdapterFn;
+    retryFn?: ShouldRetryRequestFn;
+};
+export type QueryClientConfig = CreateQueryClientConfigOptions & {
+    token: QueryClientRef;
+};
+export type QueryClientRef = InjectionToken<QueryClient>;
+export declare const createQueryClientConfig: (options: CreateQueryClientConfigOptions) => QueryClientConfig;

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

@@ -0,0 +1,10 @@
+import { QueryClientConfig } from './query-client-config';
+import { QueryRepository } from './query-repository';
+export type QueryClient = {
+    repository: QueryRepository;
+};
+export declare const createQueryClient: (config: QueryClientConfig) => QueryClient;
+export declare const provideQueryClient: (config: QueryClientConfig) => {
+    provide: import("./query-client-config").QueryClientRef;
+    useFactory: () => QueryClient;
+};

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

@@ -0,0 +1,14 @@
+import { AnyBearerAuthProviderConfig } from './bearer-auth-provider-config';
+import { QueryArgs } from './query';
+import { QueryClientConfig } from './query-client-config';
+import { CreateQueryCreatorOptions } from './query-creator';
+export declare const createGetQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecureGetQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createPostQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecurePostQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createPutQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecurePutQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createDeleteQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecureDeleteQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createPatchQuery: (client: QueryClientConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;
+export declare const createSecurePatchQuery: (client: QueryClientConfig, authProvider: AnyBearerAuthProviderConfig) => <TArgs extends QueryArgs>(creatorOptions: CreateQueryCreatorOptions<TArgs>) => import("./query-creator").QueryCreator<TArgs>;

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

@@ -0,0 +1,39 @@
+import { 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]: string;
+} ? (args: TArgs['pathParams']) => RouteString : RouteString;
+export type RouteString = `/${string}`;
+export type CreateQueryCreatorOptions<TArgs extends QueryArgs> = {
+    route: RouteType<TArgs>;
+    reportProgress?: boolean;
+    responseType?: 'json';
+    withCredentials?: boolean;
+    transferCache?: {
+        includeHeaders?: string[];
+    } | boolean;
+};
+export type QueryCreator<TArgs extends QueryArgs> = {
+    (...features: QueryFeature<TArgs>[]): Query<TArgs>;
+    (queryConfig: QueryConfig, ...features: QueryFeature<TArgs>[]): Query<TArgs>;
+};
+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

@@ -0,0 +1,12 @@
+import { DestroyRef, Injector } from '@angular/core';
+import { QueryClient } from './query-client';
+import { QueryClientConfig } from './query-client-config';
+export type SetupQueryDependenciesOptions = {
+    clientConfig: QueryClientConfig;
+};
+export type QueryDependencies = {
+    destroyRef: DestroyRef;
+    client: QueryClient;
+    injector: Injector;
+};
+export declare const setupQueryDependencies: (options: SetupQueryDependenciesOptions) => QueryDependencies;

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

@@ -0,0 +1,39 @@
+import { RuntimeError } from '@ethlete/core';
+import { QueryMethod } from './query-creator';
+import { QueryFeatureType } from './query-features';
+export declare const enum RuntimeErrorCode {
+    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
+}
+export declare const queryFeatureUsedMultipleTimes: (type: QueryFeatureType) => RuntimeError<RuntimeErrorCode.QUERY_FEATURE_USED_MULTIPLE_TIMES>;
+export declare const withArgsQueryFeatureMissingButRouteIsFunction: () => RuntimeError<RuntimeErrorCode.WITH_ARGS_QUERY_FEATURE_MISSING_BUT_ROUTE_IS_FUNCTION>;
+export declare const withPollingUsedOnUnsupportedHttpMethod: (method: QueryMethod) => RuntimeError<RuntimeErrorCode.WITH_POLLING_USED_ON_UNSUPPORTED_HTTP_METHOD>;
+export declare const withAutoRefreshUsedOnUnsupportedHttpMethod: (method: QueryMethod) => RuntimeError<RuntimeErrorCode.WITH_AUTO_REFRESH_USED_ON_UNSUPPORTED_HTTP_METHOD>;
+export declare const withAutoRefreshUsedInManualQuery: () => RuntimeError<RuntimeErrorCode.WITH_AUTO_REFRESH_USED_IN_MANUAL_QUERY>;
+export declare const cookieLoginTriedButCookieDisabled: () => RuntimeError<RuntimeErrorCode.COOKIE_LOGIN_TRIED_BUT_COOKIE_DISABLED>;
+export declare const enableCookieCalledWithoutCookieConfig: () => RuntimeError<RuntimeErrorCode.ENABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
+export declare const disableCookieCalledWithoutCookieConfig: () => RuntimeError<RuntimeErrorCode.DISABLE_COOKIE_CALLED_WITHOUT_COOKIE_CONFIG>;
+export declare const loginCalledWithoutConfig: () => RuntimeError<RuntimeErrorCode.LOGIN_CALLED_WITHOUT_CONFIG>;
+export declare const loginWithTokenCalledWithoutConfig: () => RuntimeError<RuntimeErrorCode.LOGIN_WITH_TOKEN_CALLED_WITHOUT_CONFIG>;
+export declare const refreshTokenCalledWithoutConfig: () => RuntimeError<RuntimeErrorCode.REFRESH_TOKEN_CALLED_WITHOUT_CONFIG>;
+export declare const selectRoleCalledWithoutConfig: () => RuntimeError<RuntimeErrorCode.SELECT_ROLE_CALLED_WITHOUT_CONFIG>;
+export declare const defaultResponseTransformerResponseNotObject: (currentType: string) => RuntimeError<RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_OBJECT>;
+export declare const defaultResponseTransformerResponseNotContainingAccessToken: () => RuntimeError<RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_ACCESS_TOKEN>;
+export declare const defaultResponseTransformerResponseNotContainingRefreshToken: () => RuntimeError<RuntimeErrorCode.DEFAULT_RESPONSE_TRANSFORMER_RESPONSE_NOT_CONTAINING_REFRESH_TOKEN>;
+export declare const unableToDecryptBearerToken: (token: string) => RuntimeError<RuntimeErrorCode.UNABLE_TO_DECRYPT_BEARER_TOKEN>;
+export declare const bearerExpiresInPropertyNotNumber: (expiresIn: unknown) => RuntimeError<RuntimeErrorCode.BEARER_EXPIRES_IN_PROPERTY_NOT_NUMBER>;

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

@@ -0,0 +1,20 @@
+import { EffectRef } from '@angular/core';
+import { QueryArgs, RequestArgs } from './query';
+import { CreateQueryExecuteOptions } from './query-execute';
+export type ResetExecuteStateOptions<TArgs extends QueryArgs> = {
+    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeState: QueryExecuteState;
+};
+export declare const resetExecuteState: <TArgs extends QueryArgs>(options: ResetExecuteStateOptions<TArgs>) => void;
+export type QueryExecuteState = {
+    effectRefs: EffectRef[];
+    previousKey: string | false;
+};
+export declare const setupQueryExecuteState: () => QueryExecuteState;
+export type QueryExecuteOptions<TArgs extends QueryArgs> = {
+    executeOptions: CreateQueryExecuteOptions<TArgs>;
+    executeState: QueryExecuteState;
+    args?: RequestArgs<TArgs> | null;
+};
+export declare const queryExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;
+export declare const cleanupPreviousExecute: <TArgs extends QueryArgs>(options: QueryExecuteOptions<TArgs>) => void;

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

@@ -0,0 +1,16 @@
+import { QueryArgs, RequestArgs } from './query';
+import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
+import { QueryDependencies } from './query-dependencies';
+import { QueryState } from './query-state';
+export type CreateQueryExecuteOptions<TArgs extends QueryArgs> = {
+    deps: QueryDependencies;
+    state: QueryState<TArgs>;
+    creator: CreateQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateQueryCreatorOptions;
+    queryConfig: QueryConfig;
+};
+export type QueryExecute<TArgs extends QueryArgs> = {
+    (args?: RequestArgs<TArgs> | null): void;
+    reset: () => void;
+};
+export declare const createExecuteFn: <TArgs extends QueryArgs>(options: CreateQueryExecuteOptions<TArgs>) => QueryExecute<TArgs>;

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

@@ -0,0 +1,45 @@
+import { HttpErrorResponse, HttpEvent } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { QueryArgs, RequestArgs, ResponseType } from './query';
+import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
+import { QueryState } from './query-state';
+import { QueryArgsReset, QueryFeatureFlags } from './query-utils';
+export declare const enum QueryFeatureType {
+    WithArgs = "withArgs",
+    WithLogging = "withLogging",
+    WithErrorHandling = "withErrorHandling",
+    WithSuccessHandling = "withSuccessHandling",
+    WithPolling = "withPolling",
+    WithAutoRefresh = "withAutoRefresh"
+}
+export type QueryFeatureContext<TArgs extends QueryArgs> = {
+    state: QueryState<TArgs>;
+    queryConfig: QueryConfig;
+    creatorConfig: CreateQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateQueryCreatorOptions;
+    execute: (args: RequestArgs<TArgs>) => void;
+    flags: QueryFeatureFlags;
+};
+export type QueryFeatureFn<TArgs extends QueryArgs> = (context: QueryFeatureContext<TArgs>) => void;
+export type QueryFeature<TArgs extends QueryArgs> = {
+    type: QueryFeatureType;
+    fn: (context: QueryFeatureContext<TArgs>) => void;
+};
+export declare const withArgs: <TArgs extends QueryArgs>(args: () => NoInfer<RequestArgs<TArgs>> | QueryArgsReset | null) => QueryFeature<TArgs>;
+export declare const withPolling: <TArgs extends QueryArgs>(options: {
+    interval: number;
+    executeInitially?: boolean;
+}) => QueryFeature<TArgs>;
+export declare const withLogging: <TArgs extends QueryArgs>(options: {
+    logFn: (v: HttpEvent<ResponseType<TArgs>> | null) => void;
+}) => QueryFeature<TArgs>;
+export declare const withErrorHandling: <TArgs extends QueryArgs>(options: {
+    handler: (e: HttpErrorResponse) => void;
+}) => QueryFeature<TArgs>;
+export declare const withSuccessHandling: <TArgs extends QueryArgs>(options: {
+    handler: (data: NonNullable<ResponseType<TArgs>>) => void;
+}) => QueryFeature<TArgs>;
+export declare const withAutoRefresh: <TArgs extends QueryArgs>(options: {
+    signalChanges: Signal<unknown>[];
+    ignoreOnlyManualExecution?: boolean;
+}) => QueryFeature<TArgs>;

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

@@ -0,0 +1,31 @@
+import { HttpHeaders } from '@angular/common/http';
+import { DestroyRef } from '@angular/core';
+import { HttpRequest } from './http-request';
+import { BodyType, PathParamsType, QueryArgs, QueryParamsType } from './query';
+import { QueryClientConfig } from './query-client-config';
+import { QueryMethod, RouteType } from './query-creator';
+export type QueryRepositoryRequestOptions<TArgs extends QueryArgs> = {
+    method: QueryMethod;
+    route: RouteType<TArgs>;
+    pathParams?: PathParamsType<TArgs>;
+    queryParams?: QueryParamsType<TArgs>;
+    body?: BodyType<TArgs>;
+    headers?: HttpHeaders;
+    reportProgress?: boolean;
+    withCredentials?: boolean;
+    transferCache?: boolean | {
+        includeHeaders?: string[];
+    };
+    responseType?: 'json';
+    key?: string;
+    skipExecution?: boolean;
+    destroyRef: DestroyRef;
+};
+export type QueryRepository = {
+    request: <TArgs extends QueryArgs>(options: QueryRepositoryRequestOptions<TArgs>) => {
+        key: string | false;
+        request: HttpRequest<TArgs>;
+    };
+    unbind: (key: string | false, destroyRef: DestroyRef) => void;
+};
+export declare const createQueryRepository: (config: QueryClientConfig) => QueryRepository;

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

@@ -0,0 +1,8 @@
+import { QueryArgs, QuerySnapshot } from './query';
+import { QueryDependencies } from './query-dependencies';
+import { QueryState } from './query-state';
+export type CreateQuerySnapshotOptions<TArgs extends QueryArgs> = {
+    state: QueryState<TArgs>;
+    deps: QueryDependencies;
+};
+export declare const createQuerySnapshotFn: <TArgs extends QueryArgs>(options: CreateQuerySnapshotOptions<TArgs>) => () => QuerySnapshot<TArgs>;

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

@@ -0,0 +1,14 @@
+import { HttpErrorResponse, HttpEvent } from '@angular/common/http';
+import { WritableSignal } from '@angular/core';
+import { HttpRequestLoadingState } from './http-request';
+import { QueryArgs, RequestArgs, ResponseType } from './query';
+export type SetupQueryStateOptions = {};
+export type QueryState<TArgs extends QueryArgs> = {
+    response: WritableSignal<ResponseType<TArgs> | null>;
+    args: WritableSignal<RequestArgs<TArgs> | null>;
+    latestHttpEvent: WritableSignal<HttpEvent<ResponseType<TArgs>> | null>;
+    loading: WritableSignal<HttpRequestLoadingState | null>;
+    error: WritableSignal<HttpErrorResponse | null>;
+    lastTimeExecutedAt: WritableSignal<number | null>;
+};
+export declare const setupQueryState: <TArgs extends QueryArgs>(options: SetupQueryStateOptions) => QueryState<TArgs>;

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

@@ -0,0 +1,41 @@
+import { HttpErrorResponse, HttpHeaders } from '@angular/common/http';
+import { CreateEffectOptions } from '@angular/core';
+import { CreateQueryOptions, QueryArgs } from './query';
+import { QueryMethod } from './query-creator';
+import { QueryExecute } from './query-execute';
+import { QueryFeatureContext } from './query-features';
+/**
+ * Returning this inside e.g. a withComputedArgs feature will reset the query args to null.
+ * This will also pause polling and auto refresh until new args are set.
+ */
+export declare const QUERY_ARGS_RESET: unique symbol;
+export type QueryArgsReset = typeof QUERY_ARGS_RESET;
+export declare const QUERY_EFFECT_ERROR_MESSAGE = "Effect triggered too often. This is probably due to a circular dependency inside the query.";
+/** A angular effect that will throw an error in dev mode if it is called too often. This indicates a circular dependency inside the effect. */
+export declare const queryEffect: (fn: () => void, errorMessage: string, options?: CreateEffectOptions) => void;
+export declare const shouldAutoExecuteQuery: (method: QueryMethod) => method is "GET" | "HEAD" | "OPTIONS";
+export declare const extractExpiresInSeconds: (headers: HttpHeaders) => number | null;
+export type ShouldRetryRequestOptions = {
+    retryCount: number;
+    error: HttpErrorResponse;
+};
+export type ShouldRetryRequestResult = {
+    retry: false;
+} | {
+    retry: true;
+    delay: number;
+};
+export type ShouldRetryRequestFn = (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;
+export declare const shouldRetryRequest: (options: ShouldRetryRequestOptions) => ShouldRetryRequestResult;
+export type QueryFeatureFlags = {
+    hasWithArgsFeature: boolean;
+    shouldAutoExecuteMethod: boolean;
+    shouldAutoExecute: boolean;
+    hasRouteFunction: boolean;
+};
+export declare const getQueryFeatureUsage: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => QueryFeatureFlags;
+export declare const applyQueryFeatures: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>, context: QueryFeatureContext<TArgs>) => void;
+export declare const maybeExecute: <TArgs extends QueryArgs>(options: {
+    flags: QueryFeatureFlags;
+    execute: QueryExecute<TArgs>;
+}) => void;

package/lib/experimental/query.d.ts

@@ -0,0 +1,41 @@
+import { HttpErrorResponse, HttpEvent, HttpHeaders } from '@angular/common/http';
+import { Signal } from '@angular/core';
+import { HttpRequestLoadingState } from './http-request';
+import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryConfig } from './query-creator';
+import { QueryExecute } from './query-execute';
+import { QueryFeature } from './query-features';
+export type QueryArgs = {
+    response?: any;
+    pathParams?: Record<string, string | number>;
+    queryParams?: any;
+    body?: any;
+    headers?: HttpHeaders;
+};
+export type ResponseType<T extends QueryArgs> = T['response'];
+export type PathParamsType<T extends QueryArgs> = T['pathParams'];
+export type QueryParamsType<T extends QueryArgs> = T['queryParams'];
+export type BodyType<T extends QueryArgs> = T['body'];
+export type RequestArgs<T extends QueryArgs> = Omit<T, 'response'>;
+export type CreateQueryOptions<TArgs extends QueryArgs> = {
+    creator: CreateQueryCreatorOptions<TArgs>;
+    creatorInternals: InternalCreateQueryCreatorOptions;
+    features: QueryFeature<TArgs>[];
+    queryConfig: QueryConfig;
+};
+export type QueryBase<TArgs extends QueryArgs> = {
+    args: Signal<RequestArgs<TArgs> | null>;
+    response: Signal<ResponseType<TArgs> | null>;
+    latestHttpEvent: Signal<HttpEvent<ResponseType<TArgs>> | null>;
+    loading: Signal<HttpRequestLoadingState | null>;
+    error: Signal<HttpErrorResponse | null>;
+    lastTimeExecutedAt: Signal<number | null>;
+};
+export type QuerySnapshot<TArgs extends QueryArgs> = QueryBase<TArgs> & {
+    isAlive: Signal<boolean>;
+};
+export type AnyQuerySnapshot = QuerySnapshot<any>;
+export type Query<TArgs extends QueryArgs> = QueryBase<TArgs> & {
+    execute: QueryExecute<TArgs>;
+    createSnapshot: () => QuerySnapshot<TArgs>;
+};
+export declare const createQuery: <TArgs extends QueryArgs>(options: CreateQueryOptions<TArgs>) => Query<TArgs>;

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

@@ -0,0 +1,7 @@
+import { AnyBearerAuthProviderConfig } from './bearer-auth-provider-config';
+import { QueryArgs } from './query';
+import { CreateQueryCreatorOptions, InternalCreateQueryCreatorOptions, QueryCreator } from './query-creator';
+export type InternalSecureCreateQueryCreatorOptions = InternalCreateQueryCreatorOptions & {
+    authProvider: AnyBearerAuthProviderConfig;
+};
+export declare const createSecureQueryCreator: <TArgs extends QueryArgs>(options: CreateQueryCreatorOptions<TArgs>, internals: InternalSecureCreateQueryCreatorOptions) => QueryCreator<TArgs>;