@ethlete/query 2.5.4 → 2.7.0

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './lib/auth';
 export * from './lib/directives';
+export * from './lib/entity';
 export * from './lib/gql';
 export * from './lib/infinite-query';
 export * from './lib/logger';

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

@@ -0,0 +1,33 @@
+import { EntityKey, EntityStoreActionResult, EntityStoreConfig } from './entity.types';
+export declare class EntityStore<T> {
+    private readonly _config;
+    private readonly _dictionary;
+    private readonly _keys;
+    private readonly _events$;
+    get events$(): import("rxjs").Observable<EntityStoreActionResult>;
+    get keys(): EntityKey[];
+    get values(): T[];
+    get size(): number;
+    get isEmpty(): boolean;
+    get config(): EntityStoreConfig;
+    get idKey(): string;
+    readonly entities$: import("rxjs").Observable<{
+        keys: EntityKey[];
+        values: T[];
+    }>;
+    constructor(_config: EntityStoreConfig);
+    getOne(key: EntityKey): NonNullable<T> | null;
+    getMany(keys: EntityKey[]): (NonNullable<T> | null)[];
+    addOne(value: T): EntityStoreActionResult | null;
+    addMany(values: T[]): (EntityStoreActionResult | null)[];
+    updateOne(value: T): EntityStoreActionResult | null;
+    updateMany(values: T[]): (EntityStoreActionResult | null)[];
+    setOne(value: T): EntityStoreActionResult;
+    setMany(values: T[]): EntityStoreActionResult[];
+    removeOne(key: EntityKey): EntityStoreActionResult | null;
+    removeMany(keys: EntityKey[]): (EntityStoreActionResult | null)[];
+    has(key: EntityKey): boolean;
+    clear(): void;
+    getKey(value: T): string | number;
+    logState(): void;
+}

package/lib/entity/entity.types.d.ts

@@ -0,0 +1,10 @@
+export type EntityKey = string | number;
+export type EntityStoreActionResult = {
+    type: 'add' | 'update' | 'set' | 'remove';
+    key: EntityKey;
+};
+export interface EntityStoreConfig {
+    name: string;
+    idKey?: string;
+    logActions?: boolean;
+}

package/lib/entity/index.d.ts

@@ -0,0 +1,2 @@
+export * from './entity-store';
+export * from './entity.types';

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

@@ -1,3 +1,4 @@
+import { Observable } from 'rxjs';
 import { AnyQueryCreator, QueryCreatorArgs, QueryCreatorResponse, QueryCreatorReturnType } from '../query-client';
 import { InfinityQueryConfig } from './infinity-query.types';
 export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query extends QueryCreatorReturnType<QueryCreator>, Args extends QueryCreatorArgs<QueryCreator>, QueryResponse extends QueryCreatorResponse<QueryCreator>, InfinityResponse extends unknown[]> {
@@ -9,17 +10,18 @@ export declare class InfinityQuery<QueryCreator extends AnyQueryCreator, Query e
     private readonly _currentQuery$;
     private readonly _data$;
     private _subscriptions;
-    get currentPage$(): import("rxjs").Observable<number | null>;
+    private _responsiveDataSubscription;
+    get currentPage$(): Observable<number | null>;
     get currentPage(): number | null;
-    get currentCalculatedPage$(): import("rxjs").Observable<number | null>;
+    get currentCalculatedPage$(): Observable<number | null>;
     get currentCalculatedPage(): number | null;
-    get totalPages$(): import("rxjs").Observable<number | null>;
+    get totalPages$(): Observable<number | null>;
     get totalPages(): number | null;
-    get itemsPerPage$(): import("rxjs").Observable<number>;
+    get itemsPerPage$(): Observable<number>;
     get itemsPerPage(): number;
-    get currentQuery$(): import("rxjs").Observable<Query | null>;
+    get currentQuery$(): Observable<Query | null>;
     get currentQuery(): Query | null;
-    get data$(): import("rxjs").Observable<InfinityResponse>;
+    get data$(): Observable<InfinityResponse>;
     get data(): InfinityResponse;
     constructor(_config: InfinityQueryConfig<QueryCreator, Args, QueryResponse, InfinityResponse>);
     nextPage(): void;

package/lib/query/query.d.ts

@@ -1,13 +1,14 @@
-import { DefaultResponseTransformer, QueryClient, ResponseTransformerType } from '../query-client';
+import { QueryClient, ResponseTransformerType } from '../query-client';
 import { Method as MethodType } from '../request';
 import { BaseArguments, GqlQueryConfig, PollConfig, QueryAutoRefreshConfig, QueryState, RestQueryConfig, RouteType, RunQueryOptions, WithUseResultIn } from './query.types';
-export declare class Query<Response, Arguments extends (BaseArguments & WithUseResultIn<Response, ResponseTransformer>) | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response> = DefaultResponseTransformer<Response>> {
+export declare class Query<Response, Arguments extends (BaseArguments & WithUseResultIn<Response, ResponseTransformer>) | undefined, Route extends RouteType<Arguments>, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response>, Entity> {
     private _client;
     private _queryConfig;
     private _routeWithParams;
     private _args;
     private _currentId;
     private _pollingSubscription;
+    private _entitySubscription;
     private _onAbort$;
     private _currentPollConfig;
     /**
@@ -26,13 +27,18 @@ export declare class Query<Response, Arguments extends (BaseArguments & WithUseR
      * @internal
      */
     get _enableSmartPolling(): boolean;
-    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, _routeWithParams: Route, _args: Arguments | undefined);
-    clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer>;
-    execute<ComputedResponse extends ReturnType<ResponseTransformer>>(options?: RunQueryOptions): this;
+    get store(): import("@ethlete/query").EntityStore<Entity> | null;
+    constructor(_client: QueryClient, _queryConfig: RestQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity> | GqlQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity>, _routeWithParams: Route, _args: Arguments);
+    clone(): import("../query-client").QueryCreator<Arguments, Method, Response, Route, ResponseTransformer, Entity>;
+    execute<ComputedResponse extends ReturnType<ResponseTransformer>, EntityResponse extends ResponseTransformer extends (response: Response) => infer R ? R : Response>(options?: RunQueryOptions): this;
     abort(): this;
     poll(config: PollConfig): this;
     stopPolling(): this;
     pausePolling(): this;
     resumePolling(): this;
     private _updateUseResultInDependencies;
+    /**
+     * @internal
+     */
+    _destroy(): void;
 }

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

@@ -1,4 +1,5 @@
 import { Observable } from 'rxjs';
+import { EntityStore, EntityStoreActionResult } from '../entity';
 import { AnyQueryCreator, QueryCreatorReturnType, ResponseTransformerType } from '../query-client';
 import { Method, PathParams, QueryParams, RequestError, RequestProgress } from '../request';
 import { Query } from './query';
@@ -16,7 +17,7 @@ export interface QueryAutoRefreshConfig {
      */
     windowFocus?: boolean;
 }
-export type QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = {
+export type QueryConfigBase<Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = {
     /**
      * The http method to use for the query.
      */
@@ -78,15 +79,33 @@ export type QueryConfigBase<Response, Arguments extends BaseArguments | undefine
          */
         args?: Arguments;
     };
+    entity?: {
+        store: EntityStore<Entity>;
+        successAction: (data: {
+            rawResponse: Response;
+            response: ResponseTransformer extends (response: Response) => infer R ? R : Response;
+            args: Arguments;
+            store: EntityStore<Entity>;
+        }) => EntityStoreActionResult | null | Array<EntityStoreActionResult | null>;
+        valueUpdater?: (data: {
+            rawResponse: Response;
+            response: ResponseTransformer extends (response: Response) => infer R ? R : Response;
+            args: Arguments;
+            entity: Entity;
+        }) => {
+            rawResponse: Response;
+            response: ResponseTransformer extends (response: Response) => infer R ? R : Response;
+        } | null;
+    };
 };
-export type RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = QueryConfigBase<Response, Arguments, ResponseTransformer> & {
+export type RestQueryConfig<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = QueryConfigBase<Response, Arguments, ResponseTransformer, Entity> & {
     /**
      * The api route to use for the query.
      */
     route: Route;
 };
 export type GqlTransferOption = 'GET' | 'POST';
-export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> extends QueryConfigBase<Response, Arguments, ResponseTransformer> {
+export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> extends QueryConfigBase<Response, Arguments, ResponseTransformer, Entity> {
     /**
      * The graphql query to use for the query.
      */
@@ -103,10 +122,10 @@ export interface GqlQueryConfig<Route extends RouteType<Arguments> | undefined,
      */
     route?: Route;
 }
-export type AnyRestQueryConfig = RestQueryConfig<any, any, any, any>;
-export type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any>;
-export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<RestQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
-export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer>, 'method'>;
+export type AnyRestQueryConfig = RestQueryConfig<any, any, any, any, any>;
+export type AnyGqlQueryConfig = GqlQueryConfig<any, any, any, any, any>;
+export type QueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = Omit<RestQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity>, 'method'>;
+export type GqlQueryConfigWithoutMethod<Route extends RouteType<Arguments>, Response, Arguments extends BaseArguments | undefined, ResponseTransformer extends ResponseTransformerType<Response> | undefined, Entity> = Omit<GqlQueryConfig<Route, Response, Arguments, ResponseTransformer, Entity>, 'method'>;
 export type BaseArguments = WithHeaders & WithVariables & WithBody & WithQueryParams & WithPathParams;
 export interface WithHeaders {
     headers?: Record<string, string>;
@@ -124,7 +143,7 @@ export interface WithPathParams {
     pathParams?: PathParams;
 }
 export type WithUseResultIn<Response, ResponseTransformer extends ResponseTransformerType<Response>> = {
-    useResultIn?: Query<Response, any, any, any, ResponseTransformer>[];
+    useResultIn?: Query<Response, any, any, any, ResponseTransformer, any>[];
 };
 export type QueryTrigger = 'program' | 'poll' | 'auto';
 export type EmptyObject = {};
@@ -207,7 +226,7 @@ export interface QueryStateSuccessMeta extends QueryStateMeta {
 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 AnyQuery = Query<any, 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;

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

@@ -1,5 +1,6 @@
+import { Paginated } from '@ethlete/types';
 import { BehaviorSubject, Observable } from 'rxjs';
-import { AnyQueryCreator, QueryClient, QueryCreator, QueryCreatorArgs, QueryCreatorMethod, QueryCreatorResponse, QueryCreatorResponseTransformer, ResponseTransformerType } from '../query-client';
+import { AnyQueryCreator, QueryClient, QueryCreator, QueryCreatorArgs, QueryCreatorEntity, QueryCreatorMethod, QueryCreatorResponse, QueryCreatorResponseTransformer, ResponseTransformerType } from '../query-client';
 import { Method, RequestHeaders, RequestHeadersMethodMap } from '../request';
 import { AnyGqlQueryConfig, AnyQuery, AnyQueryCreatorCollection, AnyQueryOfCreatorCollection, AnyRestQueryConfig, BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryRawResponseType, QueryResponseType, QueryState, QueryStateData, QueryStateRawData, QueryStateType, RouteType, Success } from './query.types';
 type OmitNull<T> = T extends null ? never : T;
@@ -14,7 +15,7 @@ export declare function filterNull(): <T>(source: Observable<T>) => Observable<O
 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>;
+    query: import("@ethlete/query").Query<any, 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>;
@@ -23,19 +24,19 @@ export declare const isQueryStateCancelled: (state: QueryState | null | undefine
 export declare const isQueryStatePrepared: (state: QueryState | null | undefined) => state is Prepared;
 export declare const isAutoRefresh: (state: QueryState | null | undefined) => boolean;
 export declare const mergeHeaders: (...headers: Array<RequestHeaders | null | undefined>) => RequestHeaders | null | undefined;
-export declare const isGqlQueryConfig: <Response_1, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> | undefined>(config: unknown) => config is GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer>;
+export declare const isGqlQueryConfig: <Response_1, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, ResponseTransformer extends ResponseTransformerType<Response_1> | undefined, Entity = unknown>(config: unknown) => config is GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer, Entity>;
 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;
+    query: import("@ethlete/query").Query<any, any, any, any, any, any>;
+} | null>(v: T) => import("@ethlete/query").Query<any, any, any, any, any, any> | null;
 export declare const getDefaultHeaders: (headers: RequestHeaders | RequestHeadersMethodMap | null | undefined, method: Method) => RequestHeaders;
-export declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryCreatorArgs<QC>, Method_1 extends QueryCreatorMethod<QC>, Response_1 extends QueryCreatorResponse<QC>, Route extends RouteType<Arguments>, ResponseTransformer extends QueryCreatorResponseTransformer<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response_1 | undefined>(config: {
+export declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryCreatorArgs<QC>, Method_1 extends QueryCreatorMethod<QC>, Response_1 extends QueryCreatorResponse<QC>, Route extends RouteType<Arguments>, ResponseTransformer extends QueryCreatorResponseTransformer<QC>, Entity extends QueryCreatorEntity<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response_1 | undefined>(config: {
     creator: QC;
     args?: OverrideArguments | undefined;
     response?: OverrideResponse | undefined;
-}) => QueryCreator<OverrideArguments, Method_1, OverrideResponse, Route, ResponseTransformer>;
+}) => QueryCreator<OverrideArguments, Method_1, OverrideResponse, Route, ResponseTransformer, Entity>;
 export declare const computeQueryMethod: (config: {
     config: AnyRestQueryConfig | AnyGqlQueryConfig;
     client: QueryClient;
@@ -60,4 +61,17 @@ export declare const computeQueryQueryParams: (config: {
     client: QueryClient;
     args?: BaseArguments | undefined;
 }) => import("../request").QueryParams | undefined;
+export declare const paginatedEntityValueUpdater: <T extends Paginated<unknown>, Args extends BaseArguments, Entity, J extends T extends Paginated<infer X> ? X : never>(findFn: (val: J, entity: Entity) => boolean) => ({ response, rawResponse, entity }: {
+    rawResponse: T;
+    response: T;
+    args: Args;
+    entity: Entity;
+}) => {
+    response: T & {
+        items: unknown[];
+    };
+    rawResponse: T & {
+        items: unknown[];
+    };
+} | null;
 export {};

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

@@ -10,14 +10,14 @@ export declare class QueryClient {
     get authProvider$(): import("rxjs").Observable<AuthProvider | null>;
     private readonly _authProvider$;
     constructor(_clientConfig: QueryClientConfig);
-    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>;
+    get: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "GET", Response_1, Route, ResponseTransformer, Entity>;
+    post: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "POST", Response_1, Route, ResponseTransformer, Entity>;
+    put: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "PUT", Response_1, Route, ResponseTransformer, Entity>;
+    patch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "PATCH", Response_1, Route, ResponseTransformer, Entity>;
+    delete: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "DELETE", Response_1, Route, ResponseTransformer, Entity>;
+    gqlQuery: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "GQL_QUERY", Response_1, Route, ResponseTransformer, Entity>;
+    gqlMutate: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined = undefined, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, "GQL_MUTATE", Response_1, Route, ResponseTransformer, Entity>;
+    fetch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, Method extends MethodType, ResponseTransformer extends ResponseTransformerType<Response_1> = DefaultResponseTransformer<Response_1>, Entity = unknown>(queryConfig: RestQueryConfig<Route, Response_1, Arguments, ResponseTransformer, Entity> | GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer, Entity>) => QueryCreator<Arguments, Method, Response_1, Route, ResponseTransformer, Entity>;
     setAuthProvider: (authProvider: AuthProvider) => void;
     setDefaultHeaders: (config: {
         headers: RequestHeaders | RequestHeadersMethodMap | null;

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

@@ -73,19 +73,21 @@ export interface QueryClientConfig {
      */
     parent?: QueryClient;
 }
-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>;
+export type QueryCreator<Arguments extends BaseArguments | undefined, Method extends MethodType, Response, Route extends RouteType<Arguments>, ResponseTransformer extends ResponseTransformerType<Response>, Entity> = (Arguments extends BaseArguments ? {
+    prepare: (args: Arguments & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer, Entity>;
 } : {
-    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer>;
+    prepare: (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders & WithUseResultIn<Response, ResponseTransformer>) => Query<Response, Arguments, Route, Method, ResponseTransformer, Entity>;
 }) & {
-    behaviorSubject: <T extends Query<Response, Arguments, Route, Method, ResponseTransformer>>(initialValue?: T | null) => BehaviorSubject<T | null>;
+    behaviorSubject: <T extends Query<Response, Arguments, Route, Method, ResponseTransformer, Entity>>(initialValue?: T | null) => BehaviorSubject<T | null>;
 };
-export type AnyQueryCreator = QueryCreator<any, any, any, any, any>;
-export type QueryCreatorArgs<T extends AnyQueryCreator> = T extends QueryCreator<infer Args, any, any, any, any> ? Args : never;
-export type QueryCreatorMethod<Q extends AnyQueryCreator> = Q extends QueryCreator<any, infer Method, any, any, any> ? Method : never;
-export type QueryCreatorResponse<T extends AnyQueryCreator> = T extends QueryCreator<any, any, infer Response, any, any> ? Response : never;
-export type QueryCreatorRoute<Q extends AnyQueryCreator> = Q extends QueryCreator<infer Args, any, any, any, any> ? RouteType<Args> : never;
-export type QueryCreatorResponseTransformer<Q extends AnyQueryCreator> = Q extends QueryCreator<any, any, any, any, infer ResponseTransformer> ? ResponseTransformer : never;
+export type AnyQueryCreator = QueryCreator<any, any, any, any, any, any>;
+export type QueryCreatorArgs<T extends AnyQueryCreator> = T extends QueryCreator<infer Args, any, any, any, any, any> ? Args : never;
+export type QueryCreatorMethod<Q extends AnyQueryCreator> = Q extends QueryCreator<any, infer Method, any, any, any, any> ? Method : never;
+export type QueryCreatorResponse<T extends AnyQueryCreator> = T extends QueryCreator<any, any, infer Response, any, any, any> ? Response : never;
+export type QueryCreatorRoute<Q extends AnyQueryCreator> = Q extends QueryCreator<infer Args, any, any, any, any, any> ? RouteType<Args> : never;
+export type QueryCreatorResponseTransformer<Q extends AnyQueryCreator> = Q extends QueryCreator<any, any, any, any, infer ResponseTransformer, any> ? ResponseTransformer : never;
+export type QueryCreatorEntity<Q extends AnyQueryCreator> = Q extends QueryCreator<any, any, any, any, any, infer Entity> ? Entity : never;
 export type ResponseTransformerType<Response> = (response: Response) => unknown;
 export type DefaultResponseTransformer<Response> = (response: Response) => Response;
+export type ResponseTransformerReturnType<T, J> = T extends (response: Response) => infer R ? R : J;
 export type QueryCreatorReturnType<T extends AnyQueryCreator> = ReturnType<T['prepare']>;

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

@@ -1,4 +1,4 @@
-import { BaseArguments, GqlQueryConfig } from '../query/query.types';
+import { AnyGqlQueryConfig, BaseArguments } from '../query/query.types';
 import { Method } from '../request';
 export declare const shouldCacheQuery: (method: Method) => boolean;
-export declare const buildGqlCacheKey: (config: GqlQueryConfig<any, any, any, any>, args: BaseArguments | undefined) => string;
+export declare const buildGqlCacheKey: (config: AnyGqlQueryConfig, args: BaseArguments | undefined) => string;

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

@@ -10,7 +10,9 @@ 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 QueryParams = {
+    [key: string | number | symbol]: UnfilteredParamPrimitive | UnfilteredParamArray | QueryParams;
+};
 export type PathParams = Record<string, string | number>;
 export type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;
 export type CacheAdapterFn = (headers: RequestHeaders) => number | null;

package/lib/request/request.util.d.ts

@@ -8,6 +8,7 @@ export declare const buildRoute: (options: {
 }) => string;
 export declare const buildQueryString: (params: QueryParams) => string | null;
 export declare const buildQueryArrayString: (key: string, array: ParamArray) => string;
+export declare const buildQueryObjectString: (key: string, object: QueryParams) => string;
 export declare const isFetchResponse: (response: unknown) => response is Response;
 export declare const filterInvalidParams: (params: QueryParams) => Params;
 export declare const isParamValid: (primitive: UnfilteredParamPrimitive) => boolean;

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ethlete/query",
-  "version": "2.5.4",
+  "version": "2.7.0",
   "dependencies": {
     "tslib": "^2.5.0"
   },
   "peerDependencies": {
     "@angular/common": "^15.2.1",
     "@angular/core": "^15.2.1",
-    "@ethlete/core": "1.7.0"
+    "@ethlete/core": "1.8.0"
   },
   "module": "fesm2015/ethlete-query.mjs",
   "es2020": "fesm2020/ethlete-query.mjs",