@ethlete/query 0.1.0-next.1 → 0.1.0-next.11

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

@@ -63,6 +63,16 @@ export interface BearerRefreshConfig {
      * The api's refresh route method
      */
     method: Method;
+    /**
+     * The way the refresh token is sent to the api
+     * @default 'body'
+     */
+    paramLocation?: 'body' | 'query';
+    /**
+     * The time in milliseconds before the token expires when the refresh should be triggered.
+     * @default 300000 (5 minutes)
+     */
+    refreshBuffer?: number;
     /**
      * The expires in property name inside the jwt body
      * @default 'exp'
@@ -77,7 +87,7 @@ export interface BearerRefreshConfig {
      * Adapter function used to build the request body for the refresh request.
      * @default { refreshToken: "refreshToken" }
      */
-    bodyAdapter?: (refreshToken: string) => unknown;
+    requestAdapter?: (refreshToken: string) => Record<string, string>;
     /**
      * Adapter function used to extract the token and refreshToken from the response.
      * @default { token: "token", refreshToken: "refreshToken" }

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

@@ -31,6 +31,6 @@ export declare class QueryDirective<Q extends AnyQuery | null> implements OnInit
     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

@@ -2,7 +2,7 @@ import { Observable } from 'rxjs';
 import { 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,12 @@ 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;

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

@@ -1,10 +1,14 @@
 import { 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>;
+import { AnyQuery, 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(): <T extends QueryState<unknown, unknown>>(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 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 +16,4 @@ 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 {};

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

@@ -1,5 +1,5 @@
 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 {
@@ -9,14 +9,14 @@ export declare class QueryClient {
     get config(): QueryClientConfig;
     get authProvider(): AuthProvider | null;
     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,16 +1,18 @@
-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;
     detail: Detail;
     raw: 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/request/request.util.d.ts

@@ -1,4 +1,4 @@
-import { QueryParams, Params, RequestError, ParamArray, UnfilteredParamPrimitive, Method } from './request.types';
+import { Method, ParamArray, Params, QueryParams, RequestError, UnfilteredParamPrimitive } from './request.types';
 export declare const isRequestError: (error: unknown) => error is RequestError<unknown>;
 export declare const isAbortRequestError: (error: unknown) => error is RequestError<unknown>;
 export declare const buildRoute: (options: {
@@ -14,7 +14,7 @@ export declare const filterInvalidParams: (params: QueryParams) => Params;
 export declare const isParamValid: (primitive: UnfilteredParamPrimitive) => boolean;
 export declare const extractExpiresInSeconds: (headers: Headers) => number | null;
 export declare const buildTimestampFromSeconds: (seconds: number | null) => number | null;
-export declare const buildRequestError: <ErrorResponse = unknown>(error: unknown) => Promise<RequestError<null> | RequestError<ErrorResponse>>;
+export declare const buildRequestError: <ErrorResponse = unknown>(error: unknown, route: string, requestInit?: RequestInit) => Promise<RequestError<null> | RequestError<ErrorResponse>>;
 export declare const buildBody: (body: unknown) => string | FormData | null;
 export declare const transformMethod: (method: Method) => "GET" | "POST" | "PUT" | "DELETE" | "PATCH" | "HEAD" | "OPTIONS" | "TRACE" | "CONNECT" | "PURGE" | "LINK" | "UNLINK" | "CUSTOM";
 export declare const guessContentType: (body: unknown) => "text/plain" | "multipart/form-data" | "application/json" | null;

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,16 @@
 {
   "name": "@ethlete/query",
-  "version": "0.1.0-next.1",
+  "version": "0.1.0-next.11",
   "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",
+    "rxjs": "7.8.0",
+    "@ethlete/core": "0.2.0-next.10",
+    "@angular/forms": "15.1.0",
+    "@angular/router": "15.1.0"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",