@leancodepl/react-query-cqrs-client 7.8.2 → 8.0.0

package/index.cjs.js

@@ -1,7 +1,5 @@
 'use strict';
 
-Object.defineProperty(exports, '__esModule', { value: true });
-
 var reactQuery = require('@tanstack/react-query');
 var rxjs = require('rxjs');
 var ajax = require('rxjs/ajax');
@@ -92,6 +90,7 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
                     queryFn: (context)=>rxjs.firstValueFrom(useApiQuery.fetcher(data, context))
                 }, options), queryClient);
             }
+            useApiQuery.type = type;
             useApiQuery.fetcher = (data, context)=>rxjs.race([
                     fetcher(data).pipe(uncapitalizedParse()),
                     ...(context == null ? void 0 : context.signal) ? [
@@ -143,6 +142,15 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
             useApiQuery.invalidate = (query)=>queryClient.invalidateQueries({
                     queryKey: useApiQuery.key(query)
                 });
+            useApiQuery.cancel = (query)=>queryClient.cancelQueries({
+                    queryKey: useApiQuery.key(query)
+                });
+            useApiQuery.optimisticUpdate = async (updater, query = {})=>{
+                await useApiQuery.cancel(query);
+                const data = useApiQuery.getQueriesData(query);
+                useApiQuery.setQueriesData(query, updater);
+                return ()=>data.forEach(([key, result])=>queryClient.setQueryData(key, result));
+            };
             return useApiQuery;
         },
         createOperation (type) {
@@ -162,25 +170,31 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
                 }, options, {
                     async onSuccess (data, variables, context) {
                         const result = await (onSuccessBase == null ? void 0 : onSuccessBase(data, variables, context));
-                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
-                                queryKey
-                            })));
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
                         return result;
                     }
                 }), queryClient);
             }
+            useApiOperation.type = type;
             useApiOperation.fetcher = (variables)=>fetcher(variables).pipe(uncapitalizedParse());
             return useApiOperation;
         },
         createCommand (type, errorCodes) {
             const fetcher = mkFetcher(`command/${type}`);
             function useApiCommand(_param = {}) {
-                var { invalidateQueries, handler, onSuccess } = _param, options = _object_without_properties_loose(_param, [
+                var { invalidateQueries, handler, optimisticUpdate, onSuccess, onMutate, onError } = _param, options = _object_without_properties_loose(_param, [
                     "invalidateQueries",
                     "handler",
-                    "onSuccess"
+                    "optimisticUpdate",
+                    "onSuccess",
+                    "onMutate",
+                    "onError"
                 ]);
-                return reactQuery.useMutation(_extends({
+                return reactQuery.useMutation(_extends({}, options, {
                     mutationKey: [
                         type
                     ],
@@ -189,17 +203,32 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
                             return rxjs.firstValueFrom(useApiCommand.fetcher(variables));
                         }
                         return rxjs.firstValueFrom(useApiCommand.call(variables, handler));
-                    }
-                }, options, {
+                    },
+                    async onMutate (variables) {
+                        // there's really no good way to do it without type cast
+                        const baseContext = await (onMutate == null ? void 0 : onMutate(variables));
+                        var _optimisticUpdate;
+                        const optimisticUpdateReverts = await Promise.all((_optimisticUpdate = optimisticUpdate == null ? void 0 : optimisticUpdate(variables)) != null ? _optimisticUpdate : []);
+                        return _extends({}, baseContext, {
+                            revertOptimisticUpdate: ()=>optimisticUpdateReverts.forEach((revertOptimisticUpdate)=>revertOptimisticUpdate())
+                        });
+                    },
                     async onSuccess (data, variables, context) {
-                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
-                                queryKey
-                            })));
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
                         const result = await (onSuccess == null ? void 0 : onSuccess(data, variables, context));
                         return result;
+                    },
+                    async onError (error, variables, context) {
+                        await (onError == null ? void 0 : onError(error, variables, context));
+                        context == null ? void 0 : context.revertOptimisticUpdate();
                     }
                 }), queryClient);
             }
+            useApiCommand.type = type;
             useApiCommand.fetcher = (variables)=>fetcher(variables);
             useApiCommand.call = (variables, handler)=>{
                 const $response = useApiCommand.fetcher(variables);

package/index.esm.js

@@ -88,6 +88,7 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
                     queryFn: (context)=>firstValueFrom(useApiQuery.fetcher(data, context))
                 }, options), queryClient);
             }
+            useApiQuery.type = type;
             useApiQuery.fetcher = (data, context)=>race([
                     fetcher(data).pipe(uncapitalizedParse()),
                     ...(context == null ? void 0 : context.signal) ? [
@@ -139,6 +140,15 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
             useApiQuery.invalidate = (query)=>queryClient.invalidateQueries({
                     queryKey: useApiQuery.key(query)
                 });
+            useApiQuery.cancel = (query)=>queryClient.cancelQueries({
+                    queryKey: useApiQuery.key(query)
+                });
+            useApiQuery.optimisticUpdate = async (updater, query = {})=>{
+                await useApiQuery.cancel(query);
+                const data = useApiQuery.getQueriesData(query);
+                useApiQuery.setQueriesData(query, updater);
+                return ()=>data.forEach(([key, result])=>queryClient.setQueryData(key, result));
+            };
             return useApiQuery;
         },
         createOperation (type) {
@@ -158,25 +168,31 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
                 }, options, {
                     async onSuccess (data, variables, context) {
                         const result = await (onSuccessBase == null ? void 0 : onSuccessBase(data, variables, context));
-                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
-                                queryKey
-                            })));
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
                         return result;
                     }
                 }), queryClient);
             }
+            useApiOperation.type = type;
             useApiOperation.fetcher = (variables)=>fetcher(variables).pipe(uncapitalizedParse());
             return useApiOperation;
         },
         createCommand (type, errorCodes) {
             const fetcher = mkFetcher(`command/${type}`);
             function useApiCommand(_param = {}) {
-                var { invalidateQueries, handler, onSuccess } = _param, options = _object_without_properties_loose(_param, [
+                var { invalidateQueries, handler, optimisticUpdate, onSuccess, onMutate, onError } = _param, options = _object_without_properties_loose(_param, [
                     "invalidateQueries",
                     "handler",
-                    "onSuccess"
+                    "optimisticUpdate",
+                    "onSuccess",
+                    "onMutate",
+                    "onError"
                 ]);
-                return useMutation(_extends({
+                return useMutation(_extends({}, options, {
                     mutationKey: [
                         type
                     ],
@@ -185,17 +201,32 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions })
                             return firstValueFrom(useApiCommand.fetcher(variables));
                         }
                         return firstValueFrom(useApiCommand.call(variables, handler));
-                    }
-                }, options, {
+                    },
+                    async onMutate (variables) {
+                        // there's really no good way to do it without type cast
+                        const baseContext = await (onMutate == null ? void 0 : onMutate(variables));
+                        var _optimisticUpdate;
+                        const optimisticUpdateReverts = await Promise.all((_optimisticUpdate = optimisticUpdate == null ? void 0 : optimisticUpdate(variables)) != null ? _optimisticUpdate : []);
+                        return _extends({}, baseContext, {
+                            revertOptimisticUpdate: ()=>optimisticUpdateReverts.forEach((revertOptimisticUpdate)=>revertOptimisticUpdate())
+                        });
+                    },
                     async onSuccess (data, variables, context) {
-                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
-                                queryKey
-                            })));
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
                         const result = await (onSuccess == null ? void 0 : onSuccess(data, variables, context));
                         return result;
+                    },
+                    async onError (error, variables, context) {
+                        await (onError == null ? void 0 : onError(error, variables, context));
+                        context == null ? void 0 : context.revertOptimisticUpdate();
                     }
                 }), queryClient);
             }
+            useApiCommand.type = type;
             useApiCommand.fetcher = (variables)=>fetcher(variables);
             useApiCommand.call = (variables, handler)=>{
                 const $response = useApiCommand.fetcher(variables);

package/package.json

@@ -1,22 +1,28 @@
 {
   "name": "@leancodepl/react-query-cqrs-client",
-  "version": "7.8.2",
+  "version": "8.0.0",
   "license": "Apache-2.0",
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "7.8.2",
-    "@leancodepl/utils": "7.8.2",
-    "@leancodepl/validation": "7.8.2",
+    "@leancodepl/cqrs-client-base": "8.0.0",
+    "@leancodepl/utils": "8.0.0",
+    "@leancodepl/validation": "8.0.0",
     "@tanstack/react-query": ">=5.0.0",
     "rxjs": ">=7.0.0"
   },
+  "devDependencies": {
+    "@testing-library/react": "*",
+    "react": "*"
+  },
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "module": "./index.esm.js",
+      "types": "./index.esm.d.ts",
       "import": "./index.cjs.mjs",
       "default": "./index.cjs.js"
     }
   },
   "module": "./index.esm.js",
-  "main": "./index.cjs.js"
+  "main": "./index.cjs.js",
+  "types": "./index.esm.d.ts"
 }

package/src/lib/mkCqrsClient.d.ts

@@ -12,12 +12,13 @@ export declare function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider,
     ajaxOptions?: Omit<AjaxConfig, "body" | "headers" | "method" | "responseType" | "url">;
 }): {
     createQuery<TQuery, TResult>(type: string): {
-        (data: TQuery, options?: Omit<UndefinedInitialDataOptions<NullableUncapitalizeDeep<TResult>, unknown>, "queryFn" | "queryKey"> | undefined): import("@tanstack/react-query").UseQueryResult<NullableUncapitalizeDeep<TResult>, unknown>;
+        (data: TQuery, options?: Omit<UndefinedInitialDataOptions<NullableUncapitalizeDeep<TResult>, unknown>, "queryFn" | "queryKey">): import("@tanstack/react-query").UseQueryResult<NullableUncapitalizeDeep<TResult>, unknown>;
+        type: string;
         fetcher(data: TQuery, context?: QueryFunctionContext<QueryKey>): Observable<NullableUncapitalizeDeep<TResult>>;
-        fetch(data: TQuery, options?: Omit<FetchQueryOptions<NullableUncapitalizeDeep<TResult>, unknown, NullableUncapitalizeDeep<TResult>, QueryKey, never>, "queryFn" | "queryKey"> | undefined): Promise<NullableUncapitalizeDeep<TResult>>;
+        fetch(data: TQuery, options?: Omit<FetchQueryOptions<NullableUncapitalizeDeep<TResult>, unknown>, "queryFn" | "queryKey">): Promise<NullableUncapitalizeDeep<TResult>>;
         lazy<TContext = unknown>(options?: Omit<UseMutationOptions<NullableUncapitalizeDeep<TResult>, unknown, TQuery, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<NullableUncapitalizeDeep<TResult>, unknown, TQuery, TContext>;
         infinite(data: TQuery, options: {
-            pageParamKey?: keyof TQuery | undefined;
+            pageParamKey?: keyof TQuery;
         } & Omit<UndefinedInitialDataInfiniteOptions<NullableUncapitalizeDeep<TResult>, unknown>, "queryFn" | "queryKey">): import("@tanstack/react-query").UseInfiniteQueryResult<import("@tanstack/react-query").InfiniteData<NullableUncapitalizeDeep<TResult>, unknown>, unknown>;
         key(query: Partial<TQuery>): readonly [string, Partial<TQuery>];
         setQueryData: {
@@ -27,38 +28,44 @@ export declare function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider,
         setQueriesData(query: Partial<TQuery>, updater: Updater<NullableUncapitalizeDeep<TResult> | undefined, NullableUncapitalizeDeep<TResult> | undefined>): [QueryKey, NullableUncapitalizeDeep<TResult> | undefined][];
         getQueryData(query: TQuery): NullableUncapitalizeDeep<TResult> | undefined;
         getQueriesData(query: Partial<TQuery>): [QueryKey, NullableUncapitalizeDeep<TResult> | undefined][];
-        prefetch(data: TQuery, options?: Omit<FetchQueryOptions<NullableUncapitalizeDeep<TResult>, unknown, NullableUncapitalizeDeep<TResult>, QueryKey, never>, "queryFn" | "queryKey" | "initialData"> | undefined): Promise<void>;
+        prefetch(data: TQuery, options?: Omit<FetchQueryOptions<NullableUncapitalizeDeep<TResult>, unknown>, "initialData" | "queryFn" | "queryKey">): Promise<void>;
         invalidate(query: Partial<TQuery>): Promise<void>;
+        cancel(query: Partial<TQuery>): Promise<void>;
+        optimisticUpdate(updater: Updater<NullableUncapitalizeDeep<TResult> | undefined, NullableUncapitalizeDeep<TResult> | undefined>, query?: Partial<TQuery>): Promise<() => void>;
     };
-    createOperation<TOperation, TResult_1>(type: string): {
-        <TContext_1 = unknown>({ onSuccess: onSuccessBase, invalidateQueries, ...options }?: {
-            invalidateQueries?: QueryKey[] | undefined;
-        } & Omit<UseMutationOptions<NullableUncapitalizeDeep<TResult_1>, unknown, TOperation, TContext_1>, "mutationFn" | "mutationKey">): UseMutationResult<NullableUncapitalizeDeep<TResult_1>, unknown, TOperation, TContext_1>;
-        fetcher(variables: TOperation): Observable<NullableUncapitalizeDeep<TResult_1>>;
+    createOperation<TOperation, TResult>(type: string): {
+        <TContext = unknown>({ onSuccess: onSuccessBase, invalidateQueries, ...options }?: {
+            invalidateQueries?: QueryKey[];
+        } & Omit<UseMutationOptions<NullableUncapitalizeDeep<TResult>, unknown, TOperation, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<NullableUncapitalizeDeep<TResult>, unknown, TOperation, TContext>;
+        type: string;
+        fetcher(variables: TOperation): Observable<NullableUncapitalizeDeep<TResult>>;
     };
     createCommand<TCommand, TErrorCodes extends {
         [name: string]: number;
     }>(type: string, errorCodes: TErrorCodes): {
-        <TContext_2 = unknown>(options?: ({
-            invalidateQueries?: QueryKey[] | undefined;
+        <TContext extends Record<string, unknown> = {}>(options?: {
+            invalidateQueries?: QueryKey[];
             handler?: undefined;
-        } & Omit<UseMutationOptions<CommandResult<TErrorCodes>, unknown, TCommand, TContext_2>, "mutationFn" | "mutationKey">) | undefined): UseMutationResult<CommandResult<TErrorCodes>, unknown, TCommand, TContext_2>;
-        <TResult_2, TContext_3 = unknown>(options?: ({
-            invalidateQueries?: QueryKey[] | undefined;
+            optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
+        } & Omit<UseMutationOptions<CommandResult<TErrorCodes>, unknown, TCommand, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<CommandResult<TErrorCodes>, unknown, TCommand, TContext>;
+        <TResult, TContext extends Record<string, unknown> = {}>(options?: {
+            invalidateQueries?: QueryKey[];
             handler: (handler: ValidationErrorsHandler<{
                 success: -1;
                 failure: -2;
-            } & TErrorCodes, never>) => TResult_2;
-        } & Omit<UseMutationOptions<TResult_2, unknown, TCommand, TContext_3>, "mutationFn" | "mutationKey">) | undefined): UseMutationResult<TResult_2, unknown, TCommand, TContext_3>;
+            } & TErrorCodes, never>) => TResult;
+            optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
+        } & Omit<UseMutationOptions<TResult, unknown, TCommand, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<TResult, unknown, TCommand, TContext>;
+        type: string;
         fetcher(variables: TCommand): Observable<CommandResult<TErrorCodes>>;
-        call<TResult_3>(variables: TCommand, handler: (handler: ValidationErrorsHandler<{
+        call<TResult>(variables: TCommand, handler: (handler: ValidationErrorsHandler<{
             success: -1;
             failure: -2;
-        } & TErrorCodes, never>) => TResult_3): Observable<TResult_3>;
+        } & TErrorCodes, never>) => TResult): Observable<TResult>;
         mapError(e: unknown): ApiResponse<CommandResult<TErrorCodes>>;
-        handleResponse<TResult_4>(handler: (handler: ValidationErrorsHandler<{
+        handleResponse<TResult>(handler: (handler: ValidationErrorsHandler<{
             success: -1;
             failure: -2;
-        } & TErrorCodes, never>) => TResult_4): (response: ApiResponse<CommandResult<TErrorCodes>>) => TResult_4;
+        } & TErrorCodes, never>) => TResult): (response: ApiResponse<CommandResult<TErrorCodes>>) => TResult;
     };
 };