@ethlete/query 2.9.2 → 3.0.1

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

@@ -1,42 +1,44 @@
 import { Paginated } from '@ethlete/types';
 import { BehaviorSubject, Observable } from 'rxjs';
-import { AnyQueryCreator, QueryClient, QueryCreator, QueryCreatorArgs, QueryCreatorEntity, QueryCreatorMethod, QueryCreatorResponse, QueryCreatorResponseTransformer, ResponseTransformerType } from '../query-client';
+import { EntityStore } from '../entity';
+import { QueryClient } from '../query-client';
+import { AnyQueryCreator, QueryArgsOf, QueryCreator, QueryDataOf, QueryResponseOf, QueryStoreIdOf, QueryStoreOf } from '../query-creator';
 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';
+import { AnyGqlQueryConfig, AnyQuery, AnyQueryCreatorCollection, AnyRestQueryConfig, BaseArguments, Cancelled, Failure, GqlQueryConfig, Loading, Prepared, QueryCollectionOf, QueryState, QueryStateResponseOf, 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 ignoreAutoRefresh(): <T extends QueryState<unknown, unknown> | null>(source: Observable<T>) => Observable<T>;
-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 filterSuccess(): <T extends QueryState<unknown> | null, Response_1 extends QueryStateResponseOf<OmitNull<T>>>(source: Observable<T>) => Observable<Success<Response_1>>;
+export declare function ignoreAutoRefresh(): <T extends QueryState<unknown> | null>(source: Observable<T>) => Observable<T>;
+export declare function filterFailure(): <T extends QueryState<unknown> | null>(source: Observable<T>) => Observable<Failure>;
+export declare function filterQueryStates(allowedStates: QueryStateType[]): <T extends QueryState<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>;
+}): <T extends QueryState<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 switchQueryState(): <T extends AnyQuery | null, Response_1 extends QueryResponseOf<OmitNull<T>>>(source: Observable<T>) => Observable<QueryState<OmitNull<Response_1>> | null>;
 export declare function switchQueryCollectionState(): <T extends {
     type: string;
     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>;
+} | null, Response_1 extends QueryResponseOf<OmitNull<T>["query"]>>(source: Observable<T>) => Observable<QueryState<OmitNull<Response_1>> | 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 isQueryStateSuccess: (state: QueryState | null | undefined) => state is Success<unknown>;
 export declare const isQueryStateFailure: (state: QueryState | null | undefined) => state is Failure;
 export declare const isQueryStateCancelled: (state: QueryState | null | undefined) => state is Cancelled;
 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, Entity = unknown>(config: unknown) => config is GqlQueryConfig<Route, Response_1, Arguments, ResponseTransformer, Entity>;
+export declare const isGqlQueryConfig: <Response_1, Arguments extends BaseArguments | undefined, Route extends RouteType<Arguments> | undefined, Store extends EntityStore<unknown>, Data, Id>(config: unknown) => config is GqlQueryConfig<Route, Response_1, Arguments, Store, Data, Id>;
 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 createQueryCollection: <T extends AnyQueryCreatorCollection, R extends QueryCollectionOf<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, 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>, Entity extends QueryCreatorEntity<QC>, OverrideArguments extends BaseArguments | undefined, OverrideResponse extends Response_1 | undefined>(config: {
+export declare const castQueryCreatorTypes: <QC extends AnyQueryCreator, Arguments extends QueryArgsOf<QC>, Response_1 extends QueryResponseOf<QC>, Store extends QueryStoreOf<QC>, Data extends QueryDataOf<QC>, Route extends RouteType<Arguments>, Id extends QueryStoreIdOf<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, Entity>;
+}) => QueryCreator<OverrideArguments, OverrideResponse, Route, Store, Data, Id>;
 export declare const computeQueryMethod: (config: {
     config: AnyRestQueryConfig | AnyGqlQueryConfig;
     client: QueryClient;

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

@@ -1,7 +1,9 @@
 import { AuthProvider } from '../auth';
+import { EntityStore } from '../entity';
 import { BaseArguments, GqlQueryConfig, GqlQueryConfigWithoutMethod, QueryConfigWithoutMethod, RestQueryConfig, RouteType } from '../query';
-import { Method as MethodType, RequestHeaders, RequestHeadersMethodMap } from '../request';
-import { DefaultResponseTransformer, QueryClientConfig, QueryCreator, ResponseTransformerType } from './query-client.types';
+import { QueryCreator } from '../query-creator';
+import { RequestHeaders, RequestHeadersMethodMap } from '../request';
+import { QueryClientConfig } from './query-client.types';
 export declare class QueryClient {
     private _clientConfig;
     private readonly _store;
@@ -10,14 +12,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>, 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>;
+    get: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    post: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    put: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    patch: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    delete: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: QueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    gqlQuery: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    gqlMutate: <Route extends RouteType<Arguments>, Response_1, Id, Data = Response_1, Arguments extends BaseArguments | undefined = undefined, Store extends EntityStore<unknown> = EntityStore<unknown>>(queryConfig: GqlQueryConfigWithoutMethod<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
+    fetch: <Route extends RouteType<Arguments>, Response_1, Arguments extends BaseArguments | undefined, Id, Store extends EntityStore<unknown> = EntityStore<unknown>, Data = Response_1>(queryConfig: RestQueryConfig<Route, Response_1, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response_1, Arguments, Store, Data, Id>) => QueryCreator<Arguments, Response_1, Route, Store, Data, Id>;
     setAuthProvider: (authProvider: AuthProvider) => void;
     setDefaultHeaders: (config: {
         headers: RequestHeaders | RequestHeadersMethodMap | null;

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

@@ -1,7 +1,5 @@
-import { BehaviorSubject } from 'rxjs';
-import { Query } from '../query/query';
-import { BaseArguments, EmptyObject, GqlTransferOption, RouteType, WithHeaders, WithUseResultIn } from '../query/query.types';
-import { CacheAdapterFn, Method as MethodType, RequestHeaders, RequestHeadersMethodMap, RequestRetryFn } from '../request';
+import { GqlTransferOption } from '../query/query.types';
+import { CacheAdapterFn, RequestHeaders, RequestHeadersMethodMap, RequestRetryFn } from '../request';
 import { QueryClient } from './query-client';
 export interface QueryClientConfig {
     /**
@@ -73,21 +71,3 @@ export interface QueryClientConfig {
      */
     parent?: QueryClient;
 }
-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, Entity>;
-}) & {
-    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, 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-creator/index.d.ts

@@ -0,0 +1,2 @@
+export * from './query-creator';
+export * from './query-creator.types';

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

@@ -0,0 +1,14 @@
+import { BehaviorSubject } from 'rxjs';
+import { EntityStore } from '../entity';
+import { QueryClient } from '../query-client';
+import { QueryStore } from '../query-store';
+import { BaseArguments, GqlQueryConfig, RestQueryConfig, RouteType } from '../query/query.types';
+import { QueryPrepareFn } from './query-creator.types';
+export declare class QueryCreator<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> {
+    private _queryConfig;
+    private _client;
+    private _store;
+    constructor(_queryConfig: RestQueryConfig<Route, Response, Arguments, Store, Data, Id> | GqlQueryConfig<Route, Response, Arguments, Store, Data, Id>, _client: QueryClient, _store: QueryStore);
+    prepare: QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>;
+    behaviorSubject: (initialValue?: ReturnType<typeof this.prepare> | null) => BehaviorSubject<ReturnType<QueryPrepareFn<Arguments, Response, Route, Store, Data, Id>> | null>;
+}

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

@@ -0,0 +1,13 @@
+import { EntityStore } from '../entity';
+import { Query } from '../query/query';
+import { AnyQuery, BaseArguments, EmptyObject, RouteType, WithHeaders } from '../query/query.types';
+import { QueryCreator } from './query-creator';
+export type QueryPrepareFn<Arguments extends BaseArguments | undefined, Response, Route extends RouteType<Arguments>, Store extends EntityStore<unknown>, Data, Id> = Arguments extends BaseArguments ? (args: Arguments & WithHeaders) => Query<Response, Arguments, Route, Store, Data, Id> : (args?: (Arguments extends EmptyObject ? Arguments : EmptyObject) & WithHeaders) => Query<Response, Arguments, Route, Store, Data, Id>;
+export type AnyQueryCreator = QueryCreator<any, any, any, any, any, any>;
+export type QueryArgsOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<infer Args, any, any, any, any, any> ? Args : T extends Query<any, infer Args, any, any, any, any> ? Args : never;
+export type QueryResponseOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, infer Response, any, any, any, any> ? Response : T extends Query<infer Response, any, any, any, any, any> ? Response : never;
+export type QueryRouteOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, infer Route, any, any, any> ? Route : T extends Query<any, any, infer Route, any, any, any> ? Route : never;
+export type QueryStoreOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, infer Store, any, any> ? Store : T extends Query<any, any, any, infer Store, any, any> ? Store : never;
+export type QueryDataOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, infer Data, any> ? Data : T extends Query<any, any, any, any, infer Data, any> ? Data : never;
+export type QueryStoreIdOf<T extends AnyQueryCreator | AnyQuery | null> = T extends QueryCreator<any, any, any, any, any, infer StoreId> ? StoreId : T extends Query<any, any, any, any, any, infer StoreId> ? StoreId : never;
+export type ConstructQuery<T extends AnyQueryCreator> = ReturnType<T['prepare']>;

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

@@ -11,7 +11,7 @@ export type Params = Record<string | number | symbol, ParamPrimitive | ParamArra
 export type ParamArray = Array<ParamPrimitive>;
 export type UnfilteredParamPrimitive = string | number | boolean | null | undefined;
 export type QueryParams = {
-    [key: string | number | symbol]: UnfilteredParamPrimitive | UnfilteredParamArray | QueryParams;
+    [key: string]: UnfilteredParamPrimitive | UnfilteredParamArray | QueryParams;
 };
 export type PathParams = Record<string, string | number>;
 export type UnfilteredParamArray = Array<UnfilteredParamPrimitive>;

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

@@ -9,7 +9,6 @@ export declare const buildRoute: (options: {
 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;
 export declare const extractExpiresInSeconds: (headers: RequestHeaders) => number | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "2.9.2",
+  "version": "3.0.1",
   "dependencies": {
     "tslib": "^2.5.0"
   },