@ethlete/query 0.1.0-next.2 → 0.1.0-next.20

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-trigger.directive.d.ts

@@ -11,5 +11,5 @@ export declare class InfinityQueryTriggerDirective implements OnInit, OnDestroy
     ngOnDestroy(): void;
     private _setupIntersectionObserver;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryTriggerDirective, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryTriggerDirective, "[infinityQueryTrigger], infinity-query-trigger", never, { "scrollContainerSelector": "scrollContainerSelector"; }, {}, never, never, true>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryTriggerDirective, "[infinityQueryTrigger], infinity-query-trigger", never, { "scrollContainerSelector": "scrollContainerSelector"; }, {}, never, never, true, never>;
 }

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

@@ -18,26 +18,31 @@ interface InfinityQueryContext<Q extends InfinityQueryConfig<AnyQueryCreator, Ba
 }
 export declare const INFINITY_QUERY_TOKEN: InjectionToken<InfinityQueryDirective<any>>;
 export declare class InfinityQueryDirective<Q extends InfinityQueryConfig<AnyQueryCreator, BaseArguments, any, unknown[]>> implements OnInit, OnDestroy {
+    private readonly _queryConfigChanged$;
     private readonly _viewContext;
     private _infinityQueryInstance;
-    private _destroy$;
+    private readonly _destroy$;
     private readonly _cdr;
     private readonly _viewContainerRef;
     private readonly _mainTemplateRef;
     private readonly _errorHandler;
+    private readonly _data$;
     private _isMainViewCreated;
     get infinityQuery(): Q;
     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 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>;
     ngOnInit(): void;
     ngOnDestroy(): void;
     private _setupInfinityQuery;
     _loadNextPage(): void;
     private _renderMainView;
+    private _cleanup;
     static ɵfac: i0.ɵɵFactoryDeclaration<InfinityQueryDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", never, { "infinityQuery": "infinityQuery"; }, {}, never, never, true>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<InfinityQueryDirective<any>, "[infinityQuery]", ["infinityQuery"], { "infinityQuery": "infinityQuery"; }, {}, never, never, true, never>;
 }
 export {};

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

@@ -1,5 +1,5 @@
 import { ChangeDetectorRef, ErrorHandler, OnDestroy, OnInit, TemplateRef, ViewContainerRef } from '@angular/core';
-import { AnyQuery, QueryRawResponseType, QueryResponseType } from '../query';
+import { AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, QueryOf, QueryRawResponseType, QueryResponseType } from '../query';
 import { RequestError } from '../request';
 import * as i0 from "@angular/core";
 interface QueryContext<Q extends AnyQuery | null> {
@@ -9,7 +9,7 @@ interface QueryContext<Q extends AnyQuery | null> {
     loading: boolean;
     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,14 +23,14 @@ 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;
     private _updateView;
     private _renderMainView;
     static ɵfac: i0.ɵɵFactoryDeclaration<QueryDirective<any>, never>;
-    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryDirective<any>, "[query]", never, { "query": "query"; "cache": "queryCache"; }, {}, never, never, true>;
+    static ɵdir: i0.ɵɵDirectiveDeclaration<QueryDirective<any>, "[query]", never, { "query": "query"; "cache": "queryCache"; }, {}, never, never, true, never>;
 }
 export {};

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

@@ -1,7 +1,7 @@
-import { BaseArguments } from '../query';
-import { AnyQueryCreator } from '../query-client';
-export declare type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
-export declare type AppendItemsLocation = 'start' | 'end';
+import { BaseArguments, QueryStateData } from '../query';
+import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorReturnType } from '../query-client';
+export type InfinityQueryParamLocation = 'path' | 'query' | 'body' | 'header' | 'variable';
+export type AppendItemsLocation = 'start' | 'end';
 export interface PageParamCalculatorOptions {
     page: number;
     totalPages: number | null;
@@ -89,3 +89,6 @@ export interface InfinityQueryConfig<QueryCreator extends AnyQueryCreator, Argum
         totalPagesExtractor?: (data: TotalPagesExtractorOptions<QueryResponse>) => number;
     };
 }
+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,7 +1,7 @@
 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;
@@ -9,16 +9,18 @@ export declare class Query<Response, Arguments extends BaseArguments | undefined
     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>, _route: 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 _updateUseResultInDependencies;
     private _handleExecuteError;
 }

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

@@ -1,8 +1,8 @@
 import { Observable } from 'rxjs';
-import { ResponseTransformerType } from '../query-client';
+import { AnyQueryCreator, QueryCreatorReturnType, ResponseTransformerType } from '../query-client';
 import { Method, PathParams, QueryParams, RequestError } 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 RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> {
     /**
      * The http method to use for the query.
      */
@@ -51,9 +51,9 @@ export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined,
         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 +69,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>;
@@ -117,12 +120,26 @@ export interface QueryStateMeta {
 export interface QueryStateSuccessMeta extends QueryStateMeta {
     readonly expiresAt: number | null;
 }
-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,10 +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';
-export declare function filterSuccess(): <T extends QueryState<unknown, unknown>, Response_1 extends QueryStateData<T>, RawResponse extends QueryStateRawData<T>>(source: Observable<T>) => Observable<Success<Response_1, RawResponse>>;
-export declare function filterFailure(): <T extends QueryState<unknown, unknown>>(source: Observable<T>) => Observable<Failure>;
-export declare function takeUntilResponse(): <T extends QueryState<unknown, unknown>>(source: Observable<T>) => Observable<T>;
+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 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;
@@ -12,3 +22,10 @@ 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 {};

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

@@ -1,22 +1,23 @@
 import { AuthProvider } from '../auth';
-import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfig, QueryConfigWithoutMethod, RouteType } from '../query';
+import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfigWithoutMethod, RestQueryConfig, RouteType } from '../query';
 import { Method as MethodType } 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;
     clearAuthProvider: () => void;
 }

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

@@ -1,6 +1,6 @@
 import { BehaviorSubject } from 'rxjs';
 import { Query } from '../query/query';
-import { BaseArguments, EmptyObject, RouteType, WithHeaders } from '../query/query.types';
+import { BaseArguments, EmptyObject, RouteType, WithHeaders, WithUseResultIn } from '../query/query.types';
 import { CacheAdapterFn, Method as MethodType } from '../request';
 export interface QueryClientConfig {
     /**
@@ -33,15 +33,15 @@ export interface QueryClientConfig {
         cacheAdapter?: CacheAdapterFn;
     };
 }
-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.d.ts

@@ -1,6 +1,6 @@
 import { FormGroup } from '@angular/forms';
 import { Observable } from 'rxjs';
-import { QueryFormGroup, QueryFieldOptions, QueryFormValue } from './query-form.types';
+import { QueryFieldOptions, QueryFormGroup, QueryFormValue } from './query-form.types';
 export declare class QueryField<T> {
     data: QueryFieldOptions<T>;
     changes$: Observable<T | null>;

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

@@ -26,18 +26,28 @@ export interface QueryFieldOptions<T = unknown> {
      * E.g. for a number field, the value from the url query params is a string, but the field requires a number.
      *
      * The following common transformations are already implemented:
+     * - `transformToString`
+     * - `transformToStringArray`
      * - `transformToNumber`
      * - `transformToNumberArray`
      * - `transformToBoolean`
      * - `transformToBooleanArray`
      * - `transformToDate` (expects a string in the default js format)
      * - `transformToDateArray` (expects strings in the default js format)
+     * - `transformToSort` (expects a string in the format `field:direction`)
      */
-    queryParamTransformFn?: (val: unknown) => T | null;
+    queryParamToValueTransformFn?: (val: unknown) => T | null;
+    /**
+     * A function that transforms the value of the field to a value that can be appended to the url query params.
+     *
+     * The following common transformations are already implemented:
+     * - `transformToSortQueryParam` (returns an object containing `field` and `direction` properties)
+     */
+    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/query-form/query-form.utils.d.ts

@@ -6,3 +6,8 @@ export declare const transformToBoolean: (value: unknown) => boolean | null;
 export declare const transformToBooleanArray: (value: unknown) => boolean[] | null;
 export declare const transformToDate: (value: unknown) => Date | null;
 export declare const transformToDateArray: (value: unknown) => Date[] | null;
+export declare const transformToSort: (value: unknown) => {
+    active: string;
+    direction: "desc" | "asc";
+} | null;
+export declare const transformToSortQueryParam: (value: unknown) => string | null;

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

@@ -1,4 +1,4 @@
-export declare type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
+export type Method = 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH' | 'HEAD' | 'OPTIONS' | 'TRACE' | 'CONNECT' | 'PURGE' | 'LINK' | 'UNLINK' | 'GQL_QUERY' | 'GQL_MUTATE' | 'CUSTOM';
 export interface RequestError<Detail = unknown> {
     code: number;
     message: string;
@@ -7,12 +7,12 @@ export interface RequestError<Detail = unknown> {
     route: string;
     requestInit?: RequestInit;
 }
-export declare type ParamPrimitive = string | number | boolean | null | undefined;
-export declare type Params = Record<string | number | symbol, ParamPrimitive | ParamArray>;
-export declare type ParamArray = Array<ParamPrimitive>;
-export declare type UnfilteredParamPrimitive = string | number | boolean | null | undefined;
-export declare type QueryParams = Record<string | number | symbol, UnfilteredParamPrimitive | UnfilteredParamArray>;
-export declare type PathParams = Record<string, string | number>;
-export declare type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
-export declare type CacheAdapterFn = (headers: Headers) => number | null;
-export declare type RequestHeaders = Record<string, string>;
+export type ParamPrimitive = string | number | boolean | null | undefined;
+export type Params = Record<string | number | symbol, ParamPrimitive | ParamArray>;
+export type ParamArray = Array<ParamPrimitive>;
+export type UnfilteredParamPrimitive = string | number | boolean | null | undefined;
+export type QueryParams = Record<string | number | symbol, UnfilteredParamPrimitive | UnfilteredParamArray>;
+export type PathParams = Record<string, string | number>;
+export type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
+export type CacheAdapterFn = (headers: Headers) => number | null;
+export type RequestHeaders = Record<string, string>;

package/lib/utils/deep-freeze.util.d.ts

@@ -1 +1 @@
-export declare const deepFreeze: <T extends Record<string, unknown>>(object: T) => Readonly<T>;
+export declare const deepFreeze: <T extends Record<string, unknown>>(object: T) => T;

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "@ethlete/query",
-  "version": "0.1.0-next.2",
+  "version": "0.1.0-next.20",
   "dependencies": {
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/common": "^14.2.0",
-    "@angular/core": "^14.2.0",
-    "rxjs": "7.5.7",
-    "@angular/forms": "14.2.9",
-    "@angular/router": "14.2.9"
+    "@angular/common": "^14.2.0 || ^15.0.0",
+    "@angular/core": "^14.2.0 || ^15.0.0",
+    "@ethlete/core": "0.2.0-next.16",
+    "@angular/forms": "15.1.2",
+    "@angular/router": "15.1.2"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",