@ethlete/query 1.0.1 → 2.1.0

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

@@ -6,11 +6,6 @@ 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/infinite-query/infinity-query.d.ts

@@ -25,7 +25,7 @@ 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;
-    _destroy(): void;
+    _clearSubscriptions(): void;
     private _handleNewQuery;
     private _prepareArgs;
     private _getPageParamLocation;

package/lib/query/query.d.ts

@@ -1,6 +1,6 @@
 import { DefaultResponseTransformer, QueryClient, ResponseTransformerType } from '../query-client';
 import { Method as MethodType } from '../request';
-import { BaseArguments, GqlQueryConfig, PollConfig, QueryState, RestQueryConfig, RouteType, RunQueryOptions, WithUseResultIn } from './query.types';
+import { BaseArguments, GqlQueryConfig, PollConfig, QueryAutoRefreshConfig, QueryState, RestQueryConfig, RouteType, RunQueryOptions, WithUseResultIn } from './query.types';
 export declare class Query<Response, Arguments extends (BaseArguments & WithUseResultIn<Response, ResponseTransformer>) | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
     private _client;
     private _queryConfig;
@@ -9,16 +9,22 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
     private _currentId;
     private _pollingSubscription;
     private _onAbort$;
+    private _currentPollConfig;
     private readonly _state$;
     private get _nextId();
     get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
     get state(): QueryState<ReturnType<ResponseTransformer>, Response>;
     get isExpired(): boolean;
+    get isInUse(): boolean;
+    get isPolling(): boolean;
+    get autoRefreshOnConfig(): Readonly<QueryAutoRefreshConfig>;
     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;
     abort(): this;
     poll(config: PollConfig): this;
     stopPolling(): this;
+    pausePolling(): this;
+    resumePolling(): this;
     private _updateUseResultInDependencies;
 }

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

@@ -2,7 +2,21 @@ import { Observable } from 'rxjs';
 import { AnyQueryCreator, QueryCreatorReturnType, ResponseTransformerType } from '../query-client';
 import { Method, PathParams, QueryParams, RequestError, RequestProgress } from '../request';
 import { Query } from './query';
-export interface QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
+export interface QueryAutoRefreshConfig {
+    /**
+     * Refresh the query when the query client's headers change.
+     * @default true
+     */
+    queryClientDefaultHeadersChange?: boolean;
+    /**
+     * Refresh the query when the window regains focus.
+     *
+     * This can only be disabled if `autoRefreshQueriesOnWindowFocus` is enabled on the query client.
+     * @default true
+     */
+    windowFocus?: boolean;
+}
+export type QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = {
     /**
      * The http method to use for the query.
      */
@@ -31,6 +45,20 @@ export interface QueryConfigBase<Response, Arguments extends BaseArguments | und
      * @default false
      */
     withCredentials?: boolean;
+    /**
+     * Configuration for handling auto refresh triggers.
+     *
+     * **Note:** This is only available for queries that can be refreshed. (`GET`, `HEAD`, `OPTIONS`, `GQL_QUERY`)
+     */
+    autoRefreshOn?: QueryAutoRefreshConfig;
+    /**
+     * Whether to automatically stop polling for this query when the window loses focus.
+     * Polling will resume when the window regains focus.
+     *
+     * This can only be disabled if `enableSmartPolling` is enabled on the query client.
+     * @default true
+     */
+    enableSmartPolling?: boolean;
     /**
      * Object containing the query's type information.
      */
@@ -50,13 +78,13 @@ export interface QueryConfigBase<Response, Arguments extends BaseArguments | und
          */
         args?: Arguments;
     };
-}
-export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> extends QueryConfigBase<Response, Arguments, ResponseTransformer> {
+};
+export type RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = QueryConfigBase<Response, Arguments, ResponseTransformer> & {
     /**
      * The api route to use for the query.
      */
     route: Route;
-}
+};
 export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> extends QueryConfigBase<Response, Arguments, ResponseTransformer> {
     /**
      * The graphql query to use for the query.
@@ -88,8 +116,13 @@ export interface WithPathParams {
 export type WithUseResultIn<Response, ResponseTransformer extends ResponseTransformerType<Response>> = {
     useResultIn?: Query<Response, any, any, any, ResponseTransformer>[];
 };
+export type QueryTrigger = 'program' | 'poll' | 'auto';
 export type EmptyObject = {};
 export interface RunQueryOptions {
+    /**
+     * Whether to skip the cache for this query. This will force the query to be executed. It might still be caught by the native browser cache.
+     * @default false
+     */
     skipCache?: boolean;
 }
 export type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
@@ -97,8 +130,18 @@ export type RouteType<Arguments extends BaseArguments | undefined> = Arguments e
 } ? (p: PathParams) => RouteString : RouteString;
 export type RouteString = `/${string}`;
 export interface PollConfig {
+    /**
+     * The interval in milliseconds to poll the query.
+     */
     interval: number;
+    /**
+     * A observable that will stop the polling when it emits.
+     */
     takeUntil: Observable<unknown>;
+    /**
+     * Whether to trigger the query immediately after polling starts.
+     */
+    triggerImmediately?: boolean;
 }
 export declare const enum QueryStateType {
     Prepared = "PREPARED",
@@ -134,6 +177,7 @@ export interface Cancelled {
 }
 export interface QueryStateMeta {
     id: number;
+    triggeredVia: QueryTrigger;
 }
 export interface QueryStateSuccessMeta extends QueryStateMeta {
     expiresAt?: number;

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

@@ -19,6 +19,9 @@ export declare class QueryClient {
     gqlMutate: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_MUTATE", Response_1, Route, ResponseTransformer>;
     fetch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: RestQueryConfig<Route, Response_1, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, Method, Response_1, Route, ResponseTransformer>;
     setAuthProvider: (authProvider: AuthProvider) => void;
-    setDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null) => void;
+    setDefaultHeaders: (config: {
+        headers: RequestHeaders | RequestHeadersMethodMap | null;
+        refreshQueriesInUse?: boolean;
+    }) => void;
     clearAuthProvider: () => void;
 }

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

@@ -38,6 +38,17 @@ export interface QueryClientConfig {
          * Do not include the `Authorization` header here. Use an `AuthProvider` instead.
          */
         headers?: RequestHeaders | RequestHeadersMethodMap;
+        /**
+         * Whether to automatically refresh expired queries when the window regains focus.
+         * @default true
+         */
+        autoRefreshQueriesOnWindowFocus?: boolean;
+        /**
+         * Whether to automatically stop polling queries when the window loses focus.
+         * Polling will resume when the window regains focus.
+         * @default true
+         */
+        enableSmartPolling?: boolean;
     };
     /**
      * Parent query client.

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

@@ -6,10 +6,18 @@ export declare class QueryStore {
     constructor(_config?: {
         enableChangeLogging?: boolean | undefined;
         enableGarbageCollectorLogging?: boolean | undefined;
+        autoRefreshQueriesOnWindowFocus?: boolean | undefined;
+        enableSmartPolling?: boolean | undefined;
     } | undefined);
     add(id: string, query: AnyQuery): void;
     get(id: string): AnyQuery | null;
     remove(id: string): void;
+    forEach(callback: (value: AnyQuery, key: string) => void): void;
+    refreshQueriesInUse(config?: {
+        ignoreCacheValidity?: boolean;
+        purgeUnused?: boolean;
+    }): void;
+    private _initSmartQueryHandling;
     private _logState;
     private _initGarbageCollector;
     private _stopGarbageCollector;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "1.0.1",
+  "version": "2.1.0",
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
     "@angular/common": "^14.2.0 || ^15.0.0",
     "@angular/core": "^14.2.0 || ^15.0.0",
-    "@ethlete/core": "1.1.0"
+    "@ethlete/core": "1.4.1"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",