@leancodepl/react-query-cqrs-client 8.3.4 → 8.3.6

package/index.cjs.js

@@ -197,12 +197,7 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, t
                 ]);
                 return reactQuery.useMutation(_extends({}, options, {
                     mutationKey: useApiCommand.key,
-                    mutationFn: (variables)=>{
-                        if (!handler) {
-                            return rxjs.firstValueFrom(useApiCommand.fetcher(variables));
-                        }
-                        return rxjs.firstValueFrom(useApiCommand.call(variables, handler));
-                    },
+                    mutationFn: (variables)=>rxjs.firstValueFrom(useApiCommand.call(variables, handler)),
                     async onMutate (variables) {
                         // there's really no good way to do it without type cast
                         const baseContext = await (onMutate == null ? void 0 : onMutate(variables));
@@ -237,7 +232,7 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, t
                         isSuccess: true,
                         result
                     })), rxjs.catchError((e)=>rxjs.of(useApiCommand.mapError(e))), operators.map((response)=>{
-                    const result = useApiCommand.handleResponse(handler)(response);
+                    const result = handler ? useApiCommand.handleResponse(handler)(response) : response;
                     if (!response.isSuccess || !response.result.WasSuccessful) {
                         throw result;
                     }

package/index.esm.js

@@ -195,12 +195,7 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, t
                 ]);
                 return useMutation(_extends({}, options, {
                     mutationKey: useApiCommand.key,
-                    mutationFn: (variables)=>{
-                        if (!handler) {
-                            return firstValueFrom(useApiCommand.fetcher(variables));
-                        }
-                        return firstValueFrom(useApiCommand.call(variables, handler));
-                    },
+                    mutationFn: (variables)=>firstValueFrom(useApiCommand.call(variables, handler)),
                     async onMutate (variables) {
                         // there's really no good way to do it without type cast
                         const baseContext = await (onMutate == null ? void 0 : onMutate(variables));
@@ -235,7 +230,7 @@ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, t
                         isSuccess: true,
                         result
                     })), catchError((e)=>of(useApiCommand.mapError(e))), map((response)=>{
-                    const result = useApiCommand.handleResponse(handler)(response);
+                    const result = handler ? useApiCommand.handleResponse(handler)(response) : response;
                     if (!response.isSuccess || !response.result.WasSuccessful) {
                         throw result;
                     }

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@leancodepl/react-query-cqrs-client",
-  "version": "8.3.4",
+  "version": "8.3.6",
   "license": "Apache-2.0",
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "8.3.4",
-    "@leancodepl/utils": "8.3.4",
-    "@leancodepl/validation": "8.3.4",
+    "@leancodepl/cqrs-client-base": "8.3.6",
+    "@leancodepl/utils": "8.3.6",
+    "@leancodepl/validation": "8.3.6",
     "@tanstack/react-query": ">=5.0.0",
     "rxjs": ">=7.0.0"
   },

package/src/lib/mkCqrsClient.d.ts

@@ -1,7 +1,7 @@
 import { FetchQueryOptions, QueryClient, QueryFunctionContext, QueryKey, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, Updater, UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
 import { Observable, OperatorFunction } from "rxjs";
 import { AjaxConfig } from "rxjs/ajax";
-import { ApiResponse, CommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
+import { ApiResponse, ApiSuccess, CommandResult, FailedCommandResult, SuccessfulCommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
 import { ValidationErrorsHandler } from "@leancodepl/validation";
 import { NullableUncapitalizeDeep } from "./types";
 export declare function uncapitalizedParse<TResult>(): OperatorFunction<string, NullableUncapitalizeDeep<TResult>>;
@@ -49,7 +49,7 @@ export declare function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider,
             invalidateQueries?: QueryKey[];
             handler?: undefined;
             optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
-        } & Omit<UseMutationOptions<CommandResult<TErrorCodes>, CommandResult<TErrorCodes>, TCommand, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<CommandResult<TErrorCodes>, CommandResult<TErrorCodes>, TCommand, TContext>;
+        } & Omit<UseMutationOptions<ApiSuccess<SuccessfulCommandResult>, ApiResponse<FailedCommandResult<TErrorCodes>>, TCommand, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<ApiSuccess<SuccessfulCommandResult>, ApiResponse<FailedCommandResult<TErrorCodes>>, TCommand, TContext>;
         <TResult, TContext extends Record<string, unknown> = {}>(options?: {
             invalidateQueries?: QueryKey[];
             handler: (handler: ValidationErrorsHandler<{
@@ -60,11 +60,11 @@ export declare function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider,
         } & Omit<UseMutationOptions<TResult, TResult, TCommand, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<TResult, TResult, TCommand, TContext>;
         type: string;
         key: string[];
-        fetcher(variables: TCommand): Observable<CommandResult<TErrorCodes>>;
-        call<TResult>(variables: TCommand, handler: (handler: ValidationErrorsHandler<{
+        fetcher(variables: TCommand): Observable<SuccessfulCommandResult>;
+        call<TResult>(variables: TCommand, handler?: (handler: ValidationErrorsHandler<{
             success: -1;
             failure: -2;
-        } & TErrorCodes, never>) => TResult): Observable<TResult>;
+        } & TErrorCodes, never>) => TResult): Observable<ApiSuccess<SuccessfulCommandResult> | TResult>;
         mapError(e: unknown): ApiResponse<CommandResult<TErrorCodes>>;
         handleResponse<TResult>(handler: (handler: ValidationErrorsHandler<{
             success: -1;