@ethlete/query 0.1.0-next.9 → 1.0.0

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

@@ -1,6 +1,5 @@
-import { RouteString } from '../query';
-import { QueryClient } from '../query-client';
-import { Method } from '../request';
+import { QueryResponseType } from '../query';
+import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
 export interface AuthProvider {
     /**
      * The up to date auth header.
@@ -12,10 +11,6 @@ export interface AuthProvider {
      * @internal
      */
     cleanUp(): void;
-    /**
-     * Reference to the query client
-     */
-    queryClient: QueryClient | null;
 }
 export interface AuthProviderBasicConfig {
     /**
@@ -39,30 +34,39 @@ export interface AuthProviderCustomHeaderConfig {
      */
     value: string;
 }
-export interface AuthProviderBearerConfig {
+export interface AuthProviderBearerConfig<T extends AnyQueryCreator> {
     /**
      * The initial jwt
      */
-    token: string;
+    token?: string;
     /**
      * Refresh token configuration
      */
-    refreshConfig?: BearerRefreshConfig;
+    refreshConfig?: BearerRefreshConfig<T>;
 }
-export interface BearerRefreshConfig {
+export interface BearerRefreshConfig<T extends AnyQueryCreator> {
+    /**
+     * The query used to trade the refresh token for a new token response.
+     */
+    queryCreator: T;
     /**
      * The initial refresh token
      */
-    token: string;
+    token?: string;
+    /**
+     * The cookie name where the refresh token is stored
+     */
+    cookieName?: string;
     /**
-     * The api's refresh route
-     * @example /api/auth/refresh-token
+     * Enable or disable the cookie
+     * @default true
      */
-    route: RouteString;
+    cookieEnabled?: boolean;
     /**
-     * The api's refresh route method
+     * The time in milliseconds before the token expires when the refresh should be triggered.
+     * @default 300000 (5 minutes)
      */
-    method: Method;
+    refreshBuffer?: number;
     /**
      * The expires in property name inside the jwt body
      * @default 'exp'
@@ -75,18 +79,22 @@ export interface BearerRefreshConfig {
     strategy?: AuthBearerRefreshStrategy;
     /**
      * Adapter function used to build the request body for the refresh request.
-     * @default { refreshToken: "refreshToken" }
+     * @default { body: { refreshToken: "refreshToken" } }
      */
-    bodyAdapter?: (refreshToken: string) => unknown;
+    requestArgsAdapter?: (tokens: {
+        token: string | null;
+        refreshToken: string;
+    }) => QueryCreatorArgs<T>;
     /**
      * Adapter function used to extract the token and refreshToken from the response.
      * @default { token: "token", refreshToken: "refreshToken" }
      */
-    responseAdapter?: (response: unknown) => TokenResponse;
+    responseAdapter?: (response: NonNullable<QueryResponseType<QueryCreatorReturnType<T>>>) => TokenResponse;
 }
 export declare const enum AuthBearerRefreshStrategy {
     /**
      * Automatically refresh the token 5 minutes before expiration.
+     * The time can be configured with the `refreshBuffer` property.
      */
     BeforeExpiration = "beforeExpiration"
 }
@@ -94,10 +102,10 @@ export interface TokenResponse {
     /**
      * The access token used inside the authorization http header.
      */
-    token: string;
+    token: string | null;
     /**
      * The refresh token used for requesting a new token response once the current tokes is expired.
      * This property is required if the bearer refresh config is set.
      */
-    refreshToken?: string;
+    refreshToken: string | null;
 }

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

@@ -1,8 +1,9 @@
+import { AnyQueryCreator } from '../query-client';
 import { AuthProvider } from './auth-provider.types';
 import { BasicAuthProvider } from './basic-auth-provider';
 import { BearerAuthProvider } from './bearer-auth-provider';
 import { CustomHeaderAuthProvider } from './custom-header-auth-provider';
 export declare const isBasicAuthProvider: (authProvider: AuthProvider) => authProvider is BasicAuthProvider;
-export declare const isBearerAuthProvider: (authProvider: AuthProvider) => authProvider is BearerAuthProvider;
+export declare const isBearerAuthProvider: <T extends AnyQueryCreator = AnyQueryCreator>(authProvider: AuthProvider) => authProvider is BearerAuthProvider<T>;
 export declare const isCustomHeaderAuthProvider: (authProvider: AuthProvider) => authProvider is CustomHeaderAuthProvider;
 export declare const decryptBearer: <Result = Record<string, unknown>>(token: string) => Result | null;

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

@@ -1,4 +1,3 @@
-import { QueryClient } from '../query-client';
 import { AuthProvider, AuthProviderBasicConfig } from './auth-provider.types';
 export declare class BasicAuthProvider implements AuthProvider {
     private _config;
@@ -6,7 +5,6 @@ export declare class BasicAuthProvider implements AuthProvider {
         Authorization: string;
     };
     private get _basicAuthString();
-    queryClient: QueryClient | null;
     constructor(_config: AuthProviderBasicConfig);
     cleanUp(): void;
 }

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

@@ -1,21 +1,21 @@
-import { Subject } from 'rxjs';
-import { QueryClient } from '../query-client';
-import { RequestError } from '../request';
+import { AnyQueryCreator } from '../query-client';
 import { AuthProvider, AuthProviderBearerConfig, TokenResponse } from './auth-provider.types';
-export declare class BearerAuthProvider implements AuthProvider {
+export declare class BearerAuthProvider<T extends AnyQueryCreator> implements AuthProvider {
     private _config;
-    private _token;
-    private _refreshToken;
-    private _refreshTimerSubscription;
+    private readonly _destroy$;
+    private readonly _currentRefreshQuery$;
+    private readonly _tokens$;
     get header(): {
         Authorization: string;
     };
-    queryClient: QueryClient | null;
-    onRefreshInitiation$: Subject<void>;
-    onRefreshSuccess$: Subject<TokenResponse>;
-    onRefreshFailure$: Subject<RequestError<unknown>>;
-    constructor(_config: AuthProviderBearerConfig);
+    get tokens$(): import("rxjs").Observable<TokenResponse>;
+    get tokens(): TokenResponse;
+    get currentRefreshQuery$(): import("rxjs").Observable<ReturnType<T["prepare"]> | null>;
+    get currentRefreshQuery(): ReturnType<T["prepare"]> | null;
+    constructor(_config: AuthProviderBearerConfig<T>);
     cleanUp(): void;
-    private _setupRefresh;
-    private _refresh;
+    enableCookie(): void;
+    disableCookie(): void;
+    private _prepareForRefresh;
+    private _refreshQuery;
 }

package/lib/auth/custom-header-auth-provider.d.ts

@@ -1,11 +1,9 @@
-import { QueryClient } from '../query-client';
 import { AuthProvider, AuthProviderCustomHeaderConfig } from './auth-provider.types';
 export declare class CustomHeaderAuthProvider implements AuthProvider {
     private _config;
     get header(): {
         [x: string]: string;
     };
-    queryClient: QueryClient | null;
     constructor(_config: AuthProviderCustomHeaderConfig);
     cleanUp(): void;
 }

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

@@ -4,7 +4,6 @@ import { BaseArguments } from '../query';
 import { AnyQueryCreator } from '../query-client';
 import { RequestError } from '../request';
 import * as i0 from "@angular/core";
-import * as i1 from "@ethlete/core";
 interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments, any, unknown[]>> {
     $implicit: Q['response']['arrayType'] | null;
     infinityQuery: Q['response']['arrayType'] | null;
@@ -44,6 +43,6 @@ export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQue
     private _renderMainView;
     private _cleanup;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", ["infinityQuery"], { "infinityQuery": "infinityQuery"; }, {}, never, never, true, [{ directive: typeof i1.DestroyDirective; inputs: {}; outputs: {}; }]>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", ["infinityQuery"], { "infinityQuery": "infinityQuery"; }, {}, never, never, true, never>;
 }
 export {};

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

@@ -1,15 +1,16 @@
 import { ChangeDetectorRef, ErrorHandler, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
-import { AnyQuery, QueryRawResponseType, QueryResponseType } from '../query';
-import { RequestError } from '../request';
+import { AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, QueryOf, QueryRawResponseType, QueryResponseType } from '../query';
+import { RequestError, RequestProgress } from '../request';
 import * as i0 from "@angular/core";
 interface QueryContext<Q extends AnyQuery | null> {
     $implicit: QueryResponseType<Q>;
     query: QueryResponseType<Q>;
     raw: QueryRawResponseType<Q>;
     loading: boolean;
+    progress: RequestProgress | null;
     error: RequestError<unknown> | null;
 }
-export declare class QueryDirective<Q extends AnyQuery | null> implements OnInit, OnDestroy {
+export declare class QueryDirective<Q extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null> implements OnInit, OnDestroy {
     private _mainTemplateRef;
     private _viewContainerRef;
     private _errorHandler;
@@ -23,8 +24,8 @@ export declare class QueryDirective<Q extends AnyQuery | null> implements OnInit
     get cache(): boolean;
     set cache(v: boolean);
     private _cache;
-    constructor(_mainTemplateRef: TemplateRef<QueryContext<Q>>, _viewContainerRef: ViewContainerRef, _errorHandler: ErrorHandler, _cdr: ChangeDetectorRef);
-    static ngTemplateContextGuard<Q extends AnyQuery | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<Q>;
+    constructor(_mainTemplateRef: TemplateRef<QueryContext<QueryOf<Q>>>, _viewContainerRef: ViewContainerRef, _errorHandler: ErrorHandler, _cdr: ChangeDetectorRef);
+    static ngTemplateContextGuard<Q extends AnyQuery | AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | null>(dir: QueryDirective<Q>, ctx: unknown): ctx is QueryContext<QueryOf<Q>>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     private _subscribeToQuery;

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

@@ -1,7 +1,7 @@
 import { BaseArguments, QueryStateData } from '../query';
 import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
-export declare type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
-export declare type AppendItemsLocation = 'start' | 'end';
+export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
+export type AppendItemsLocation = 'start' | 'end';
 export interface PageParamCalculatorOptions {
     page: number;
     totalPages: number | null;
@@ -89,6 +89,6 @@ export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Argum
         totalPagesExtractor?: (data: TotalPagesExtractorOptions<QueryResponse>) => number;
     };
 }
-declare type OmitUndefined<T> = T extends undefined ? never : T;
-export declare type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryCreatorArgs<QueryCreator>>, QueryStateData<QueryCreatorReturnType<QueryCreator>['state']>, InfinityResponse>;
+type OmitUndefined<T> = T extends undefined ? never : T;
+export type InfinityQueryConfigType<QueryCreator extends AnyQueryCreator, InfinityResponse extends unknown[]> = InfinityQueryConfig<QueryCreator, OmitUndefined<QueryCreatorArgs<QueryCreator>>, QueryStateData<QueryCreatorReturnType<QueryCreator>['state']>, InfinityResponse>;
 export {};

package/lib/query/query.d.ts

@@ -1,24 +1,24 @@
 import { DefaultResponseTransformer, QueryClient, ResponseTransformerType } from '../query-client';
 import { Method as MethodType } from '../request';
-import { BaseArguments, GqlQueryConfig, PollConfig, QueryConfig, QueryState, RouteType, RunQueryOptions } from './query.types';
-export declare class Query<Response, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
+import { BaseArguments, GqlQueryConfig, PollConfig, 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;
-    private _route;
+    private _routeWithParams;
     private _args;
     private _currentId;
-    private _abortController;
     private _pollingSubscription;
+    private _onAbort$;
     private readonly _state$;
     private get _nextId();
     get state$(): import("rxjs").Observable<QueryState<ReturnType<ResponseTransformer>, Response>>;
     get state(): QueryState<ReturnType<ResponseTransformer>, Response>;
     get isExpired(): boolean;
-    constructor(_client: QueryClient, _queryConfig: QueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _route: Route, _args: Arguments | undefined);
+    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;
-    private _handleExecuteError;
+    private _updateUseResultInDependencies;
 }

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

@@ -1,16 +1,12 @@
 import { Observable } from 'rxjs';
-import { ResponseTransformerType } from '../query-client';
-import { Method, PathParams, QueryParams, RequestError } from '../request';
+import { AnyQueryCreator, QueryCreatorReturnType, ResponseTransformerType } from '../query-client';
+import { Method, PathParams, QueryParams, RequestError, RequestProgress } from '../request';
 import { Query } from './query';
-export interface QueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
+export interface QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
     /**
      * The http method to use for the query.
      */
     method: Method;
-    /**
-     * The api route to use for the query.
-     */
-    route: Route;
     /**
      * Determines if the auth provider should be used for this query.
      * The query **will throw** if the query client's auth provider is unset.
@@ -21,6 +17,20 @@ export interface QueryConfig<Route extends RouteType<Arguments>, Response, Argum
      * A function that transforms the response to the desired type.
      */
     responseTransformer?: ResponseTransformer;
+    /**
+     * Determines if the query should emit progress events.
+     */
+    reportProgress?: boolean;
+    /**
+     * Determines the query's response type.
+     * @default 'json'
+     */
+    responseType?: 'arraybuffer' | 'blob' | 'json' | 'text';
+    /**
+     * Whether this request should be sent with outgoing credentials (cookies).
+     * @default false
+     */
+    withCredentials?: boolean;
     /**
      * Object containing the query's type information.
      */
@@ -36,24 +46,30 @@ export interface QueryConfig<Route extends RouteType<Arguments>, Response, Argum
          * - `queryParams`: The query parameters for the query. (after the ? in the url)
          * - `body`: The body for the query. Unavailable for GET, HEAD and OPTIONS requests.
          * - `headers`: The headers for the query.
+         * - `variables`: The variables for the query. (graphql only)
          */
         args?: Arguments;
     };
 }
-export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
-    method: Method;
+export interface RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> extends 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.
+     */
     query: string;
+    /**
+     * Subroute to use for the query.
+     */
     route?: Route;
-    secure?: boolean;
-    responseTransformer?: ResponseTransformer;
-    types?: {
-        response?: Response;
-        args?: Arguments;
-    };
 }
-export declare type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<QueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
-export declare type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
-export declare type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams;
+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;
 export interface WithHeaders {
     headers?: Record<string, string>;
 }
@@ -69,14 +85,17 @@ export interface WithQueryParams {
 export interface WithPathParams {
     pathParams?: PathParams;
 }
-export declare type EmptyObject = {};
+export type WithUseResultIn<Response, ResponseTransformer extends ResponseTransformerType<Response>> = {
+    useResultIn?: Query<Response, any, any, any, ResponseTransformer>[];
+};
+export type EmptyObject = {};
 export interface RunQueryOptions {
     skipCache?: boolean;
 }
-export declare type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
+export type RouteType<Arguments extends BaseArguments | undefined> = Arguments extends {
     pathParams: infer PathParams;
 } ? (p: PathParams) => RouteString : RouteString;
-export declare type RouteString = `/${string}`;
+export type RouteString = `/${string}`;
 export interface PollConfig {
     interval: number;
     takeUntil: Observable<unknown>;
@@ -89,40 +108,56 @@ export declare const enum QueryStateType {
     Cancelled = "CANCELLED"
 }
 export interface Prepared {
-    readonly type: QueryStateType.Prepared;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Prepared;
+    meta: QueryStateMeta;
 }
 export interface Success<Response = unknown, RawResponse = unknown> {
-    readonly type: QueryStateType.Success;
-    readonly response: Response;
-    readonly rawResponse: RawResponse;
-    readonly meta: QueryStateSuccessMeta;
+    type: QueryStateType.Success;
+    response: Response;
+    rawResponse: RawResponse;
+    meta: QueryStateSuccessMeta;
 }
 export interface Failure {
-    readonly type: QueryStateType.Failure;
-    readonly error: RequestError;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Failure;
+    error: RequestError;
+    meta: QueryStateMeta;
 }
 export interface Loading {
-    readonly type: QueryStateType.Loading;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Loading;
+    meta: QueryStateMeta;
+    partialText?: string;
+    progress?: RequestProgress;
 }
 export interface Cancelled {
-    readonly type: QueryStateType.Cancelled;
-    readonly meta: QueryStateMeta;
+    type: QueryStateType.Cancelled;
+    meta: QueryStateMeta;
 }
 export interface QueryStateMeta {
-    readonly id: number;
+    id: number;
 }
 export interface QueryStateSuccessMeta extends QueryStateMeta {
-    readonly expiresAt: number | null;
+    expiresAt?: number;
 }
-export declare type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
-export declare type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
-export declare type QueryStateRawData<T extends QueryState = QueryState> = T extends Success<infer Response, infer RawResponse> ? RawResponse : never;
-export declare type AnyQuery = Query<any, any, any, any, any>;
-export declare type QueryType<T extends {
+export type QueryState<Response = unknown, RawResponse = unknown> = Loading | Success<Response, RawResponse> | Failure | Cancelled | Prepared;
+export type QueryStateData<T extends QueryState = QueryState> = T extends Success<infer Response> ? Response : never;
+export type QueryStateRawData<T extends QueryState = QueryState> = T extends Success<infer Response, infer RawResponse> ? RawResponse : never;
+export type AnyQuery = Query<any, any, any, any, any>;
+export type QueryType<T extends {
     prepare: (args: any) => AnyQuery;
 }> = T['prepare'] extends () => infer R ? R : T['prepare'] extends (args: any) => infer R ? R : never;
-export declare type QueryResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateData<Q['state']> | null : null;
-export declare type QueryRawResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateRawData<Q['state']> | null : null;
+export type QueryResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateData<Q['state']> | null : null;
+export type QueryRawResponseType<Q extends AnyQuery | null> = Q extends AnyQuery ? QueryStateRawData<Q['state']> | null : null;
+export type AnyQueryCreatorCollection = {
+    [name: string]: AnyQueryCreator;
+};
+export type AnyQueryOfCreatorCollection<T extends {
+    [name: string]: AnyQueryCreator;
+}> = {
+    [K in keyof T]: {
+        type: K;
+        query: QueryCreatorReturnType<T[K]>;
+    };
+}[keyof T];
+export type QueryOf<T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> | AnyQuery | null> = T extends AnyQuery ? T : T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection> ? T['query'] : never;
+export type AnyQueryResponseOfCreatorCollection<T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection>> = QueryResponseType<T['query']>;
+export type AnyQueryRawResponseOfCreatorCollection<T extends AnyQueryOfCreatorCollection<AnyQueryCreatorCollection>> = QueryRawResponseType<T['query']>;

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

@@ -1,11 +1,20 @@
-import { Observable } from 'rxjs';
+import { BehaviorSubject, Observable } from 'rxjs';
 import { ResponseTransformerType } from '../query-client';
-import { RequestHeaders } from '../request';
-import { BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryState, QueryStateData, QueryStateRawData, RouteType, Success } from './query.types';
-declare type OmitNull<T> = T extends null ? never : T;
+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 filterFailure(): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<Failure>;
-export declare function takeUntilResponse(): <T extends QueryState<unknown, unknown>>(source: Observable<T>) => Observable<T>;
+export declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<T>;
+export declare function takeUntilResponse(config?: {
+    excludeNull?: boolean;
+}): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<T>;
+export declare function filterNull(): <T>(source: Observable<T>) => Observable<OmitNull<T>>;
+export declare function switchQueryState(): <T extends AnyQuery | null, Response_1 extends QueryResponseType<OmitNull<T>>, RawResponse extends QueryRawResponseType<OmitNull<T>>>(source: Observable<T>) => Observable<QueryState<OmitNull<Response_1>, OmitNull<RawResponse>> | null>;
+export declare function switchQueryCollectionState(): <T extends {
+    type: string;
+    query: import("@ethlete/query").Query<any, any, any, any, any>;
+} | null, Response_1 extends QueryResponseType<OmitNull<T>["query"]>, RawResponse extends QueryRawResponseType<OmitNull<T>["query"]>>(source: Observable<T>) => Observable<QueryState<OmitNull<Response_1>, OmitNull<RawResponse>> | null>;
 export declare const isQueryStateLoading: (state: QueryState | null | undefined) => state is Loading;
 export declare const isQueryStateSuccess: (state: QueryState | null | undefined) => state is Success<unknown, unknown>;
 export declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
@@ -13,4 +22,11 @@ export declare const isQueryStateCancelled: (state: QueryState | null | undefine
 export declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
 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;
+export declare const createQueryCollection: <T extends AnyQueryCreatorCollection, R extends AnyQueryOfCreatorCollection<T>>(queryMap: T) => BehaviorSubject<R | null>;
+export declare const extractQuery: <T extends AnyQuery | {
+    type: string;
+    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 {};

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

@@ -1,22 +1,24 @@
 import { AuthProvider } from '../auth';
-import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfig, QueryConfigWithoutMethod, RouteType } from '../query';
-import { Method as MethodType } from '../request';
+import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfigWithoutMethod, RestQueryConfig, RouteType } from '../query';
+import { Method as MethodType, RequestHeaders, RequestHeadersMethodMap } from '../request';
 import { DefaultResponseTransformer, QueryClientConfig, QueryCreator, ResponseTransformerType } from './query-client.types';
 export declare class QueryClient {
     private _clientConfig;
     private readonly _store;
-    private _authProvider;
     get config(): QueryClientConfig;
     get authProvider(): AuthProvider | null;
+    get authProvider$(): import("rxjs").Observable<AuthProvider | null>;
+    private readonly _authProvider$;
     constructor(_clientConfig: QueryClientConfig);
-    get: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GET", Response_1, Route, ResponseTransformer>;
-    post: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "POST", Response_1, Route, ResponseTransformer>;
-    put: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PUT", Response_1, Route, ResponseTransformer>;
-    patch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PATCH", Response_1, Route, ResponseTransformer>;
-    delete: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "DELETE", Response_1, Route, ResponseTransformer>;
-    gqlQuery: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GQL_QUERY", Response_1, Route, ResponseTransformer>;
-    gqlMutate: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | 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: QueryConfig<Route, Response_1, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, Method, Response_1, Route, ResponseTransformer>;
+    get: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "GET", Response_1, Route, ResponseTransformer>;
+    post: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "POST", Response_1, Route, ResponseTransformer>;
+    put: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PUT", Response_1, Route, ResponseTransformer>;
+    patch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "PATCH", Response_1, Route, ResponseTransformer>;
+    delete: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer>) => QueryCreator<Arguments, "DELETE", Response_1, Route, ResponseTransformer>;
+    gqlQuery: <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_QUERY", Response_1, Route, ResponseTransformer>;
+    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;
     clearAuthProvider: () => void;
 }

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

@@ -1,7 +1,8 @@
 import { BehaviorSubject } from 'rxjs';
 import { Query } from '../query/query';
-import { BaseArguments, EmptyObject, RouteType, WithHeaders } from '../query/query.types';
-import { CacheAdapterFn, Method as MethodType } from '../request';
+import { BaseArguments, EmptyObject, RouteType, WithHeaders, WithUseResultIn } from '../query/query.types';
+import { CacheAdapterFn, Method as MethodType, RequestHeaders, RequestHeadersMethodMap } from '../request';
+import { QueryClient } from './query-client';
 export interface QueryClientConfig {
     /**
      * The api base route.
@@ -31,17 +32,28 @@ export interface QueryClientConfig {
          * Should return a number in seconds.
          */
         cacheAdapter?: CacheAdapterFn;
+        /**
+         * Default headers to be sent with every request.
+         * Will be overridden by headers passed to the query.
+         * Do not include the `Authorization` header here. Use an `AuthProvider` instead.
+         */
+        headers?: RequestHeaders | RequestHeadersMethodMap;
     };
+    /**
+     * Parent query client.
+     * Used for sharing the same auth provider.
+     */
+    parent?: QueryClient;
 }
-export declare type QueryCreator<Arguments extends BaseArguments | undefined, Method extends MethodType, Response, Route extends RouteType<Arguments>, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> = (Arguments extends Record<string, unknown> ? {
-    prepare: (args: Arguments & WithHeaders) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+export type QueryCreator<Arguments extends BaseArguments | undefined, Method extends MethodType, Response, Route extends RouteType<Arguments>, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> = (Arguments extends BaseArguments ? {
+    prepare: (args: Arguments & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
 } : {
-    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
 }) & {
     behaviorSubject: <T extends Query<Response, Arguments, Route, Method, ResponseTransformer>>(initialValue?: T | null) => BehaviorSubject<T | null>;
 };
-export declare type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
-export declare type QueryCreatorArgs<T extends AnyQueryCreator> = Parameters<T['prepare']>[0];
-export declare type ResponseTransformerType<Response> = (response: Response) => unknown;
-export declare type DefaultResponseTransformer<Response> = (response: Response) => Response;
-export declare type QueryCreatorReturnType<T extends AnyQueryCreator> = ReturnType<T['prepare']>;
+export type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
+export type QueryCreatorArgs<T extends AnyQueryCreator> = Parameters<T['prepare']>[0];
+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-form/query-form.types.d.ts

@@ -45,9 +45,9 @@ export interface QueryFieldOptions<T = unknown> {
      */
     valueToQueryParamTransformFn?: (val: T | null) => unknown;
 }
-export declare type QueryFormGroup<T extends Record<string, QueryField<any>>> = {
+export type QueryFormGroup<T extends Record<string, QueryField<any>>> = {
     [Property in keyof T]: T[Property]['control'];
 };
-export declare type QueryFormValue<T extends Record<string, QueryField<any>>> = {
+export type QueryFormValue<T extends Record<string, QueryField<any>>> = {
     [Property in keyof T]: T[Property]['control']['value'];
 };

package/lib/request/request.d.ts

@@ -1,9 +1,3 @@
-import { CacheAdapterFn } from './request.types';
-export declare const request: <Response_1 = unknown>(options: {
-    route: string;
-    init?: RequestInit;
-    cacheAdapter?: CacheAdapterFn;
-}) => Promise<{
-    data: Response_1;
-    expiresInTimestamp: number | null;
-}>;
+import { Observable } from 'rxjs';
+import { RequestConfig, RequestEvent } from './request.types';
+export declare const request: <Response_1 = unknown>(config: RequestConfig) => Observable<RequestEvent<Response_1>>;