@ethlete/query 2.1.1 → 2.3.0

package/lib/auth/auth-provider.types.d.ts

@@ -6,6 +6,11 @@ export interface AuthProvider {
      * This will automatically get injected into every query that has the `secure` property set to `true`.
      */
     header: Record<string, string>;
+    /**
+     * Cleanup function that gets called once the auth provider gets destroyed.
+     * @internal
+     */
+    cleanUp(): void;
 }
 export interface AuthProviderBasicConfig {
     /**

package/lib/directives/infinity-query.directive.d.ts

@@ -1,10 +1,10 @@
 import { InjectionToken, OnDestroy, OnInit } from '@angular/core';
-import { InfinityQuery, InfinityQueryConfig } from '../infinite-query';
+import { InfinityQueryConfig, InfinityQueryOf } from '../infinite-query';
 import { BaseArguments } from '../query';
 import { AnyQueryCreator } from '../query-client';
 import { RequestError } from '../request';
 import * as i0 from "@angular/core";
-interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments, any, unknown[]>> {
+interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> {
     $implicit: Q['response']['arrayType'] | null;
     infinityQuery: Q['response']['arrayType'] | null;
     loading: boolean;
@@ -17,7 +17,7 @@ interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, Ba
     itemsPerPage: number | null;
 }
 export declare const INFINITY_QUERY_TOKEN: InjectionToken<InfinityQueryDirective<any>>;
-export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments, any, unknown[]>> implements OnInit, OnDestroy {
+export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>> implements OnInit, OnDestroy {
     private readonly _queryConfigChanged$;
     private readonly _viewContext;
     private _infinityQueryInstance;
@@ -32,14 +32,20 @@ export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQue
     set infinityQuery(v: Q);
     private _infinityQuery;
     get context(): InfinityQueryContext<Q>;
-    get instance(): InfinityQuery<AnyQueryCreator, import("../query").Query<any, any, any, any, any>, BaseArguments, any, unknown[]> | null;
+    get instance(): InfinityQueryOf<Q> | null;
     get data$(): import("rxjs").Observable<Q["response"]["arrayType"]>;
     get data(): Q["response"]["arrayType"];
-    static ngTemplateContextGuard<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
+    static ngTemplateContextGuard<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments | undefined, any, unknown[]>>(dir: InfinityQueryDirective<Q>, ctx: unknown): ctx is InfinityQueryContext<Q>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     private _setupInfinityQuery;
+    /**
+     * @deprecated Use `loadNextPage` instead
+     * @breaking 3.0.0
+     */
     _loadNextPage(): void;
+    loadNextPage(): void;
+    reset(newConfig?: Omit<Q, 'queryCreator' | 'response'>): void;
     private _renderMainView;
     private _cleanup;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;

package/lib/infinite-query/infinity-query.d.ts

@@ -1,7 +1,6 @@
-import { QueryStateData } from '../query';
-import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
+import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorResponse, QueryCreatorReturnType } from '../query-client';
 import { InfinityQueryConfig } from './infinity-query.types';
-export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query extends QueryCreatorReturnType<QueryCreator>, Args extends QueryCreatorArgs<QueryCreator>, QueryResponse extends QueryStateData<Query['state']>, InfinityResponse extends unknown[]> {
+export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query extends QueryCreatorReturnType<QueryCreator>, Args extends QueryCreatorArgs<QueryCreator>, QueryResponse extends QueryCreatorResponse<QueryCreator>, InfinityResponse extends unknown[]> {
     private _config;
     private readonly _currentPage$;
     private readonly _currentCalculatedPage$;
@@ -25,6 +24,9 @@ export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query e
     constructor(_config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>);
     nextPage(): void;
     reset(newConfig?: Omit<InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>, 'queryCreator' | 'response'>): void;
+    /**
+     * @internal
+     */
     _clearSubscriptions(): void;
     private _handleNewQuery;
     private _prepareArgs;

package/lib/infinite-query/infinity-query.types.d.ts

@@ -1,5 +1,6 @@
 import { BaseArguments, QueryStateData } from '../query';
-import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
+import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorResponse, QueryCreatorReturnType } from '../query-client';
+import { InfinityQuery } from './infinity-query';
 export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
 export type AppendItemsLocation = 'start' | 'end';
 export interface PageParamCalculatorOptions {
@@ -11,7 +12,7 @@ export interface TotalPagesExtractorOptions<QueryResponse> {
     response: QueryResponse;
     itemsPerPage: number;
 }
-export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Arguments extends BaseArguments, QueryResponse, InfinityResponse extends unknown[]> {
+export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Arguments extends BaseArguments | undefined, QueryResponse, InfinityResponse extends unknown[]> {
     /**
      * The query creator to use for fetching pages.
      */
@@ -90,5 +91,8 @@ export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Argum
     };
 }
 type OmitUndefined<T> = T extends undefined ? never : T;
+export type AnyInfinityQueryConfig = InfinityQueryConfig<any, any, any, any>;
+export type AnyInfinityQuery = InfinityQuery<any, any, any, any, any>;
 export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryCreatorArgs<QueryCreator>>, QueryStateData<QueryCreatorReturnType<QueryCreator>['state']>, InfinityResponse>;
+export type InfinityQueryOf<Cfg extends AnyInfinityQueryConfig> = InfinityQuery<Cfg['queryCreator'], QueryCreatorReturnType<Cfg['queryCreator']>, QueryCreatorArgs<Cfg['queryCreator']>, QueryCreatorResponse<Cfg['queryCreator']>, Cfg['response']['arrayType']>;
 export {};

package/lib/query/query.d.ts

@@ -10,6 +10,10 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
     private _pollingSubscription;
     private _onAbort$;
     private _currentPollConfig;
+    /**
+     * @internal
+     */
+    _isPollingPaused: boolean;
     private readonly _state$;
     private get _nextId();
     get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
@@ -18,6 +22,10 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
     get isInUse(): boolean;
     get isPolling(): boolean;
     get autoRefreshOnConfig(): Readonly<QueryAutoRefreshConfig>;
+    /**
+     * @internal
+     */
+    get _enableSmartPolling(): boolean;
     constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _routeWithParams: Route, _args: Arguments | undefined);
     clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;
     execute<ComputedResponse extends ReturnType<ResponseTransformer>>(options?: RunQueryOptions): this;

package/lib/query/query.types.d.ts

@@ -124,6 +124,15 @@ export interface RunQueryOptions {
      * @default false
      */
     skipCache?: boolean;
+    /**
+     * The trigger type for this query.
+     * - `program`: The query was triggered by the user.
+     * - `poll`: The query was triggered by polling.
+     * - `auto`: The query was triggered by an auto refresh event.
+     * @default 'program'
+     * @internal
+     */
+    _triggeredVia?: QueryTrigger;
 }
 export type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
     pathParams: infer PathParams;
@@ -178,6 +187,9 @@ export interface Cancelled {
 export interface QueryStateMeta {
     id: number;
     triggeredVia: QueryTrigger;
+    isWaitingForRetry?: boolean;
+    retryNumber?: number;
+    retryDelay?: number;
 }
 export interface QueryStateSuccessMeta extends QueryStateMeta {
     expiresAt?: number;

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

@@ -1,9 +1,10 @@
 import { BehaviorSubject, Observable } from 'rxjs';
-import { ResponseTransformerType } from '../query-client';
+import { AnyQueryCreator, QueryCreator, QueryCreatorArgs, QueryCreatorMethod, QueryCreatorResponse, QueryCreatorResponseTransformer, ResponseTransformerType } from '../query-client';
 import { Method, RequestHeaders, RequestHeadersMethodMap } from '../request';
 import { AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryRawResponseType, QueryResponseType, QueryState, QueryStateData, QueryStateRawData, QueryStateType, RouteType, Success } from './query.types';
 type OmitNull<T> = T extends null ? never : T;
 export declare function filterSuccess(): <T extends QueryState<unknown, unknown> | null, Response_1 extends QueryStateData<OmitNull<T>>, RawResponse extends QueryStateRawData<OmitNull<T>>>(source: Observable<T>) => Observable<Success<Response_1, RawResponse>>;
+export declare function ignoreAutoRefresh(): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<T>;
 export declare function filterFailure(): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<Failure>;
 export declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<T>;
 export declare function takeUntilResponse(config?: {
@@ -20,6 +21,7 @@ export declare const isQueryStateSuccess: (state: QueryState | null | undefined)
 export declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
 export declare const isQueryStateCancelled: (state: QueryState | null | undefined) => state is Cancelled;
 export declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
+export declare const isAutoRefresh: (state: QueryState | null | undefined) => boolean;
 export declare const mergeHeaders: (...headers: Array<RequestHeaders | null | undefined>) => RequestHeaders | null | undefined;
 export declare const isGqlQueryConfig: <Response_1, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> | undefined>(config: unknown) => config is GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>;
 export declare const isQuery: <T extends AnyQuery>(query: unknown) => query is T;
@@ -29,4 +31,9 @@ export declare const extractQuery: <T extends AnyQuery | {
     query: import("@ethlete/query").Query<any, any, any, any, any>;
 } | null>(v: T) => import("@ethlete/query").Query<any, any, any, any, any> | null;
 export declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
+export declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryCreatorArgs<QC>, Method_1 extends QueryCreatorMethod<QC>, Response_1 extends QueryCreatorResponse<QC>, Route extends RouteType<Arguments>, ResponseTransformer extends QueryCreatorResponseTransformer<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response_1 | undefined>(config: {
+    creator: QC;
+    args?: OverrideArguments | undefined;
+    response?: OverrideResponse | undefined;
+}) => QueryCreator<OverrideArguments, Method_1, OverrideResponse, Route, ResponseTransformer>;
 export {};

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

@@ -1,7 +1,7 @@
 import { BehaviorSubject } from 'rxjs';
 import { Query } from '../query/query';
 import { BaseArguments, EmptyObject, RouteType, WithHeaders, WithUseResultIn } from '../query/query.types';
-import { CacheAdapterFn, Method as MethodType, RequestHeaders, RequestHeadersMethodMap } from '../request';
+import { CacheAdapterFn, Method as MethodType, RequestHeaders, RequestHeadersMethodMap, RequestRetryFn } from '../request';
 import { QueryClient } from './query-client';
 export interface QueryClientConfig {
     /**
@@ -49,6 +49,11 @@ export interface QueryClientConfig {
          * @default true
          */
         enableSmartPolling?: boolean;
+        /**
+         * A retry function to be used for all queries.
+         * @default shouldRetryRequest()
+         */
+        retryFn?: RequestRetryFn;
     };
     /**
      * Parent query client.
@@ -64,7 +69,11 @@ export type QueryCreator<Arguments extends BaseArguments | undefined, Method ext
     behaviorSubject: <T extends Query<Response, Arguments, Route, Method, ResponseTransformer>>(initialValue?: T | null) => BehaviorSubject<T | null>;
 };
 export type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
-export type QueryCreatorArgs<T extends AnyQueryCreator> = Parameters<T['prepare']>[0];
+export type QueryCreatorArgs<T extends AnyQueryCreator> = T extends QueryCreator<infer Args, any, any, any, any> ? Args : never;
+export type QueryCreatorMethod<Q extends AnyQueryCreator> = Q extends QueryCreator<any, infer Method, any, any, any> ? Method : never;
+export type QueryCreatorResponse<T extends AnyQueryCreator> = T extends QueryCreator<any, any, infer Response, any, any> ? Response : never;
+export type QueryCreatorRoute<Q extends AnyQueryCreator> = Q extends QueryCreator<infer Args, any, any, any, any> ? RouteType<Args> : never;
+export type QueryCreatorResponseTransformer<Q extends AnyQueryCreator> = Q extends QueryCreator<any, any, any, any, infer ResponseTransformer> ? ResponseTransformer : never;
 export type ResponseTransformerType<Response> = (response: Response) => unknown;
 export type DefaultResponseTransformer<Response> = (response: Response) => Response;
 export type QueryCreatorReturnType<T extends AnyQueryCreator> = ReturnType<T['prepare']>;

package/lib/query-store/query-store.d.ts

@@ -3,6 +3,8 @@ export declare class QueryStore {
     private _config?;
     private readonly _store;
     private _garbageCollector;
+    private _isInLowResourceMode;
+    private _lastBlurTimestamp;
     constructor(_config?: {
         enableChangeLogging?: boolean | undefined;
         enableGarbageCollectorLogging?: boolean | undefined;

package/lib/request/request.types.d.ts

@@ -24,6 +24,16 @@ export interface PartialXhrState {
     statusText: string;
     url: string;
 }
+export interface RequestRetryFnConfig {
+    error: RequestError;
+    headers: RequestHeaders;
+    currentRetryCount: number;
+}
+export interface RequestRetryFnResult {
+    retry: boolean;
+    delay?: number;
+}
+export type RequestRetryFn = (config: RequestRetryFnConfig) => RequestRetryFnResult;
 export interface RequestConfig {
     method: Method;
     urlWithParams: string;
@@ -33,6 +43,7 @@ export interface RequestConfig {
     responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
     headers?: RequestHeaders;
     cacheAdapter?: CacheAdapterFn;
+    retryFn?: RequestRetryFn;
 }
 export type RequestProgress = {
     current: number;
@@ -42,6 +53,14 @@ export type RequestProgress = {
 export type RequestEvent<Response = unknown> = {
     type: 'start';
     headers: RequestHeaders;
+    isRetry?: boolean;
+    retryNumber?: number;
+    retryDelay?: number;
+} | {
+    type: 'delay-retry';
+    headers: RequestHeaders;
+    retryNumber: number;
+    retryDelay: number;
 } | {
     type: 'download-progress';
     headers: RequestHeaders;

package/lib/request/request.util.d.ts

@@ -1,4 +1,4 @@
-import { Method, ParamArray, Params, QueryParams, RequestError, RequestHeaders, UnfilteredParamPrimitive } from './request.types';
+import { Method, ParamArray, Params, QueryParams, RequestError, RequestHeaders, RequestRetryFn, UnfilteredParamPrimitive } from './request.types';
 export declare const isRequestError: <T = unknown>(error: unknown) => error is RequestError<T>;
 export declare const buildRoute: (options: {
     base: string;
@@ -20,7 +20,9 @@ export declare const hasHeader: (headers: RequestHeaders, header: string) => boo
 export declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;
 export declare const parseAllXhrResponseHeaders: (xhr: XMLHttpRequest) => RequestHeaders;
 export declare const getResponseUrl: (xhr: XMLHttpRequest) => string | null;
+export declare const shouldRetryRequest: RequestRetryFn;
 export declare const enum HttpStatusCode {
+    Unknown = 0,
     Continue = 100,
     SwitchingProtocols = 101,
     Processing = 102,

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "dependencies": {
-    "tslib": "^2.3.0"
+    "tslib": "^2.5.0"
   },
   "peerDependencies": {
-    "@angular/common": "^14.2.0 || ^15.0.0",
-    "@angular/core": "^14.2.0 || ^15.0.0",
-    "@ethlete/core": "1.4.2"
+    "@angular/common": "^15.2.1",
+    "@angular/core": "^15.2.1",
+    "@ethlete/core": "1.4.3"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",