@ethlete/query 2.2.0 → 2.4.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

@@ -90,11 +90,20 @@ export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined,
      * The graphql query to use for the query.
      */
     query: string;
+    /**
+     * Determines if the query should be sent via GET or POST.
+     * - `GET`: The query will be sent via query parameters.
+     * - `POST`: The query will be sent via the body.
+     * @default 'POST'
+     */
+    transferVia?: 'GET' | 'POST';
     /**
      * Subroute to use for the query.
      */
     route?: Route;
 }
+export type AnyRestQueryConfig = RestQueryConfig<any, any, any, any>;
+export type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any>;
 export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<RestQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
 export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
 export type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams;
@@ -124,6 +133,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;

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

@@ -1,9 +1,10 @@
 import { BehaviorSubject, Observable } from 'rxjs';
-import { ResponseTransformerType } from '../query-client';
+import { AnyQueryCreator, QueryClient, 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';
+import { AnyGqlQueryConfig, AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, AnyRestQueryConfig, 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,30 @@ 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 declare const computeQueryMethod: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+export declare const computeQueryBody: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    args?: BaseArguments | undefined;
+    method: Method;
+}) => unknown;
+export declare const computeQueryAuthHeader: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+}) => Record<string, string> | null;
+export declare const computeQueryHeaders: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    client: QueryClient;
+    args?: BaseArguments | undefined;
+}) => RequestHeaders | undefined;
+export declare const computeQueryQueryParams: (config: {
+    config: AnyRestQueryConfig | AnyGqlQueryConfig;
+    args?: BaseArguments | undefined;
+}) => import("../request").QueryParams | undefined;
 export {};

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

@@ -69,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.util.d.ts

@@ -14,7 +14,10 @@ export declare const isParamValid: (primitive: UnfilteredParamPrimitive) => bool
 export declare const extractExpiresInSeconds: (headers: RequestHeaders) => number | null;
 export declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
 export declare const serializeBody: (body: unknown) => ArrayBuffer | Blob | FormData | string | null;
-export declare const transformMethod: (method: Method) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
+export declare const transformMethod: (config: {
+    method: Method;
+    transferVia?: 'GET' | 'POST';
+}) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
 export declare const detectContentTypeHeader: (body: unknown) => string | null;
 export declare const hasHeader: (headers: RequestHeaders, header: string) => boolean;
 export declare const forEachHeader: (headers: RequestHeaders, callback: (value: string, key: string) => void) => void;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "2.2.0",
+  "version": "2.4.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.3"
+    "@angular/common": "^15.2.1",
+    "@angular/core": "^15.2.1",
+    "@ethlete/core": "1.5.1"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",