@leancodepl/react-query-cqrs-client 7.1.1

package/index.cjs.d.ts

@@ -0,0 +1 @@
+export * from "./src/index";

package/index.cjs.js

@@ -0,0 +1,227 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var validation = require('@leancodepl/validation');
+var reactQuery = require('@tanstack/react-query');
+var rxjs = require('rxjs');
+var ajax = require('rxjs/ajax');
+var operators = require('rxjs/operators');
+var utils = require('@leancodepl/utils');
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+function authGuard(tokenProvider) {
+    var _tokenProvider;
+    if (!((_tokenProvider = tokenProvider) == null ? void 0 : _tokenProvider.invalidateToken)) {
+        return (response)=>response;
+    }
+    return (response)=>response.pipe(rxjs.catchError((error)=>{
+            if (error.status === 401) {
+                var _tokenProvider_invalidateToken, _tokenProvider;
+                (_tokenProvider_invalidateToken = (_tokenProvider = tokenProvider).invalidateToken) == null ? void 0 : _tokenProvider_invalidateToken.call(_tokenProvider);
+            }
+            return rxjs.throwError(()=>error);
+        }));
+}
+
+function uncapitalizedJSONParse(json) {
+    return JSON.parse(json, (key, value)=>{
+        if (value === null && key !== "") return undefined;
+        if (!value || Array.isArray(value) || typeof value !== "object") return value;
+        return Object.fromEntries(Object.entries(value).map(([key, value])=>[
+                utils.toLowerFirst(key),
+                value
+            ]));
+    });
+}
+
+function uncapitalizedParse() {
+    return ($source)=>$source.pipe(operators.map(uncapitalizedJSONParse));
+}
+function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions }) {
+    function mkFetcher(endpoint, config = {}) {
+        var _tokenProvider;
+        const apiCall = (data, token)=>ajax.ajax(_extends({}, ajaxOptions, config, {
+                headers: {
+                    Authorization: token,
+                    "Content-Type": "application/json"
+                },
+                url: `${cqrsEndpoint}/${endpoint}`,
+                method: "POST",
+                body: data,
+                withCredentials: true
+            }));
+        const getToken = (_tokenProvider = tokenProvider) == null ? void 0 : _tokenProvider.getToken;
+        const mk$apiCall = (data, token)=>apiCall(data, token).pipe(authGuard(tokenProvider), operators.map((result)=>result.response));
+        if (getToken) {
+            return (data)=>rxjs.from(getToken()).pipe(operators.mergeMap((token)=>mk$apiCall(data, token)));
+        }
+        return (data)=>mk$apiCall(data);
+    }
+    return {
+        createQuery (type) {
+            const fetcher = mkFetcher(`query/${type}`, {
+                responseType: "text"
+            });
+            function useApiQuery(data, options) {
+                return reactQuery.useQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>rxjs.firstValueFrom(useApiQuery.fetcher(data, context))
+                }, options));
+            }
+            useApiQuery.fetcher = (data, context)=>{
+                var _context;
+                return rxjs.race([
+                    fetcher(data).pipe(uncapitalizedParse()),
+                    ...((_context = context) == null ? void 0 : _context.signal) ? [
+                        rxjs.fromEvent(context.signal, "abort").pipe(operators.mergeMap(()=>rxjs.throwError(()=>new Error("Query aborted"))))
+                    ] : []
+                ]);
+            };
+            useApiQuery.fetch = (data, options)=>queryClient.fetchQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>rxjs.firstValueFrom(useApiQuery.fetcher(data, context))
+                }, options));
+            useApiQuery.lazy = function(options = {}) {
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                return reactQuery.useMutation([
+                    type
+                ], (variables)=>rxjs.firstValueFrom(useApiQuery.fetcher(variables)), options);
+            };
+            useApiQuery.infinite = function(data, options) {
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                return reactQuery.useInfiniteQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>{
+                        var _options;
+                        return rxjs.firstValueFrom(useApiQuery.fetcher(((_options = options) == null ? void 0 : _options.pageParamKey) ? _extends({}, data, {
+                            [options.pageParamKey]: context.pageParam
+                        }) : data, context));
+                    }
+                }, options));
+            };
+            useApiQuery.key = (query)=>[
+                    type,
+                    query
+                ];
+            function setQueryData(queryOrQueryKey, updater) {
+                const key = Array.isArray(queryOrQueryKey) ? queryOrQueryKey : useApiQuery.key(queryOrQueryKey);
+                return queryClient.setQueryData(key, updater);
+            }
+            useApiQuery.setQueryData = setQueryData;
+            useApiQuery.getQueryData = (query)=>queryClient.getQueryData(useApiQuery.key(query));
+            useApiQuery.getQueriesData = (query)=>queryClient.getQueriesData({
+                    queryKey: useApiQuery.key(query)
+                });
+            useApiQuery.prefetch = (data, options)=>queryClient.prefetchQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>rxjs.firstValueFrom(useApiQuery.fetcher(data, context))
+                }, options));
+            useApiQuery.invalidate = (query)=>queryClient.invalidateQueries({
+                    queryKey: useApiQuery.key(query)
+                });
+            return useApiQuery;
+        },
+        createOperation (type) {
+            const fetcher = mkFetcher(`operation/${type}`, {
+                responseType: "text"
+            });
+            function useApiOperation(_param = {}) {
+                var { onSuccess: onSuccessBase, invalidateQueries } = _param, options = _object_without_properties_loose(_param, [
+                    "onSuccess",
+                    "invalidateQueries"
+                ]);
+                return reactQuery.useMutation(_extends({
+                    mutationKey: [
+                        type
+                    ],
+                    mutationFn: (variables)=>rxjs.firstValueFrom(useApiOperation.fetcher(variables))
+                }, options, {
+                    async onSuccess (data, variables, context) {
+                        var _onSuccessBase;
+                        const result = await ((_onSuccessBase = onSuccessBase) == null ? void 0 : _onSuccessBase(data, variables, context));
+                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((query)=>queryClient.invalidateQueries(query)));
+                        return result;
+                    }
+                }));
+            }
+            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, [
+                    "invalidateQueries",
+                    "handler",
+                    "onSuccess"
+                ]);
+                return reactQuery.useMutation(_extends({
+                    mutationKey: [
+                        type
+                    ],
+                    mutationFn: (variables)=>{
+                        if (!handler) {
+                            return rxjs.firstValueFrom(useApiCommand.fetcher(variables));
+                        }
+                        return rxjs.firstValueFrom(useApiCommand.call(variables, handler));
+                    }
+                }, options, {
+                    async onSuccess (data, variables, context) {
+                        var _onSuccess;
+                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries(queryKey)));
+                        const result = await ((_onSuccess = onSuccess) == null ? void 0 : _onSuccess(data, variables, context));
+                        return result;
+                    }
+                }));
+            }
+            useApiCommand.fetcher = (variables)=>fetcher(variables);
+            useApiCommand.call = (variables, handler)=>{
+                const $response = useApiCommand.fetcher(variables);
+                return $response.pipe(operators.map((result)=>({
+                        isSuccess: true,
+                        result
+                    })), rxjs.catchError((e)=>rxjs.of(useApiCommand.mapError(e))), operators.map(useApiCommand.handleResponse(handler)));
+            };
+            useApiCommand.mapError = (e)=>{
+                if (e instanceof ajax.AjaxError && e.status === 422) {
+                    return {
+                        isSuccess: true,
+                        result: e.response
+                    };
+                }
+                return {
+                    isSuccess: false,
+                    error: e
+                };
+            };
+            useApiCommand.handleResponse = (handler)=>(response)=>handler(validation.handleResponse(response, errorCodes));
+            return useApiCommand;
+        }
+    };
+}
+
+exports.mkCqrsClient = mkCqrsClient;

package/index.esm.js

@@ -0,0 +1,223 @@
+import { handleResponse } from '@leancodepl/validation';
+import { useMutation, useInfiniteQuery, useQuery } from '@tanstack/react-query';
+import { catchError, throwError, race, fromEvent, firstValueFrom, of, from } from 'rxjs';
+import { AjaxError, ajax } from 'rxjs/ajax';
+import { mergeMap, map } from 'rxjs/operators';
+import { toLowerFirst } from '@leancodepl/utils';
+
+function _extends() {
+    _extends = Object.assign || function assign(target) {
+        for(var i = 1; i < arguments.length; i++){
+            var source = arguments[i];
+            for(var key in source)if (Object.prototype.hasOwnProperty.call(source, key)) target[key] = source[key];
+        }
+        return target;
+    };
+    return _extends.apply(this, arguments);
+}
+
+function _object_without_properties_loose(source, excluded) {
+    if (source == null) return {};
+    var target = {};
+    var sourceKeys = Object.keys(source);
+    var key, i;
+    for(i = 0; i < sourceKeys.length; i++){
+        key = sourceKeys[i];
+        if (excluded.indexOf(key) >= 0) continue;
+        target[key] = source[key];
+    }
+    return target;
+}
+
+function authGuard(tokenProvider) {
+    var _tokenProvider;
+    if (!((_tokenProvider = tokenProvider) == null ? void 0 : _tokenProvider.invalidateToken)) {
+        return (response)=>response;
+    }
+    return (response)=>response.pipe(catchError((error)=>{
+            if (error.status === 401) {
+                var _tokenProvider_invalidateToken, _tokenProvider;
+                (_tokenProvider_invalidateToken = (_tokenProvider = tokenProvider).invalidateToken) == null ? void 0 : _tokenProvider_invalidateToken.call(_tokenProvider);
+            }
+            return throwError(()=>error);
+        }));
+}
+
+function uncapitalizedJSONParse(json) {
+    return JSON.parse(json, (key, value)=>{
+        if (value === null && key !== "") return undefined;
+        if (!value || Array.isArray(value) || typeof value !== "object") return value;
+        return Object.fromEntries(Object.entries(value).map(([key, value])=>[
+                toLowerFirst(key),
+                value
+            ]));
+    });
+}
+
+function uncapitalizedParse() {
+    return ($source)=>$source.pipe(map(uncapitalizedJSONParse));
+}
+function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions }) {
+    function mkFetcher(endpoint, config = {}) {
+        var _tokenProvider;
+        const apiCall = (data, token)=>ajax(_extends({}, ajaxOptions, config, {
+                headers: {
+                    Authorization: token,
+                    "Content-Type": "application/json"
+                },
+                url: `${cqrsEndpoint}/${endpoint}`,
+                method: "POST",
+                body: data,
+                withCredentials: true
+            }));
+        const getToken = (_tokenProvider = tokenProvider) == null ? void 0 : _tokenProvider.getToken;
+        const mk$apiCall = (data, token)=>apiCall(data, token).pipe(authGuard(tokenProvider), map((result)=>result.response));
+        if (getToken) {
+            return (data)=>from(getToken()).pipe(mergeMap((token)=>mk$apiCall(data, token)));
+        }
+        return (data)=>mk$apiCall(data);
+    }
+    return {
+        createQuery (type) {
+            const fetcher = mkFetcher(`query/${type}`, {
+                responseType: "text"
+            });
+            function useApiQuery(data, options) {
+                return useQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>firstValueFrom(useApiQuery.fetcher(data, context))
+                }, options));
+            }
+            useApiQuery.fetcher = (data, context)=>{
+                var _context;
+                return race([
+                    fetcher(data).pipe(uncapitalizedParse()),
+                    ...((_context = context) == null ? void 0 : _context.signal) ? [
+                        fromEvent(context.signal, "abort").pipe(mergeMap(()=>throwError(()=>new Error("Query aborted"))))
+                    ] : []
+                ]);
+            };
+            useApiQuery.fetch = (data, options)=>queryClient.fetchQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>firstValueFrom(useApiQuery.fetcher(data, context))
+                }, options));
+            useApiQuery.lazy = function(options = {}) {
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                return useMutation([
+                    type
+                ], (variables)=>firstValueFrom(useApiQuery.fetcher(variables)), options);
+            };
+            useApiQuery.infinite = function(data, options) {
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                return useInfiniteQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>{
+                        var _options;
+                        return firstValueFrom(useApiQuery.fetcher(((_options = options) == null ? void 0 : _options.pageParamKey) ? _extends({}, data, {
+                            [options.pageParamKey]: context.pageParam
+                        }) : data, context));
+                    }
+                }, options));
+            };
+            useApiQuery.key = (query)=>[
+                    type,
+                    query
+                ];
+            function setQueryData(queryOrQueryKey, updater) {
+                const key = Array.isArray(queryOrQueryKey) ? queryOrQueryKey : useApiQuery.key(queryOrQueryKey);
+                return queryClient.setQueryData(key, updater);
+            }
+            useApiQuery.setQueryData = setQueryData;
+            useApiQuery.getQueryData = (query)=>queryClient.getQueryData(useApiQuery.key(query));
+            useApiQuery.getQueriesData = (query)=>queryClient.getQueriesData({
+                    queryKey: useApiQuery.key(query)
+                });
+            useApiQuery.prefetch = (data, options)=>queryClient.prefetchQuery(_extends({
+                    queryKey: useApiQuery.key(data),
+                    queryFn: (context)=>firstValueFrom(useApiQuery.fetcher(data, context))
+                }, options));
+            useApiQuery.invalidate = (query)=>queryClient.invalidateQueries({
+                    queryKey: useApiQuery.key(query)
+                });
+            return useApiQuery;
+        },
+        createOperation (type) {
+            const fetcher = mkFetcher(`operation/${type}`, {
+                responseType: "text"
+            });
+            function useApiOperation(_param = {}) {
+                var { onSuccess: onSuccessBase, invalidateQueries } = _param, options = _object_without_properties_loose(_param, [
+                    "onSuccess",
+                    "invalidateQueries"
+                ]);
+                return useMutation(_extends({
+                    mutationKey: [
+                        type
+                    ],
+                    mutationFn: (variables)=>firstValueFrom(useApiOperation.fetcher(variables))
+                }, options, {
+                    async onSuccess (data, variables, context) {
+                        var _onSuccessBase;
+                        const result = await ((_onSuccessBase = onSuccessBase) == null ? void 0 : _onSuccessBase(data, variables, context));
+                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((query)=>queryClient.invalidateQueries(query)));
+                        return result;
+                    }
+                }));
+            }
+            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, [
+                    "invalidateQueries",
+                    "handler",
+                    "onSuccess"
+                ]);
+                return useMutation(_extends({
+                    mutationKey: [
+                        type
+                    ],
+                    mutationFn: (variables)=>{
+                        if (!handler) {
+                            return firstValueFrom(useApiCommand.fetcher(variables));
+                        }
+                        return firstValueFrom(useApiCommand.call(variables, handler));
+                    }
+                }, options, {
+                    async onSuccess (data, variables, context) {
+                        var _onSuccess;
+                        invalidateQueries && await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries(queryKey)));
+                        const result = await ((_onSuccess = onSuccess) == null ? void 0 : _onSuccess(data, variables, context));
+                        return result;
+                    }
+                }));
+            }
+            useApiCommand.fetcher = (variables)=>fetcher(variables);
+            useApiCommand.call = (variables, handler)=>{
+                const $response = useApiCommand.fetcher(variables);
+                return $response.pipe(map((result)=>({
+                        isSuccess: true,
+                        result
+                    })), catchError((e)=>of(useApiCommand.mapError(e))), map(useApiCommand.handleResponse(handler)));
+            };
+            useApiCommand.mapError = (e)=>{
+                if (e instanceof AjaxError && e.status === 422) {
+                    return {
+                        isSuccess: true,
+                        result: e.response
+                    };
+                }
+                return {
+                    isSuccess: false,
+                    error: e
+                };
+            };
+            useApiCommand.handleResponse = (handler)=>(response)=>handler(handleResponse(response, errorCodes));
+            return useApiCommand;
+        }
+    };
+}
+
+export { mkCqrsClient };

package/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@leancodepl/react-query-cqrs-client",
+  "version": "7.1.1",
+  "dependencies": {
+    "@leancodepl/utils": "7.1.1",
+    "@leancodepl/validation": "7.1.0",
+    "@tanstack/react-query": ">=4.32.6",
+    "rxjs": ">=7.0.0"
+  },
+  "type": "commonjs",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js"
+}

package/src/index.d.ts

@@ -0,0 +1 @@
+export { mkCqrsClient } from "./lib/mkCqrsClient";

package/src/lib/authGuard.d.ts

@@ -0,0 +1,3 @@
+import { TokenProvider } from "@leancodepl/cqrs-client-base";
+import { MonoTypeOperatorFunction } from "rxjs";
+export declare function authGuard<T>(tokenProvider?: Partial<TokenProvider>): MonoTypeOperatorFunction<T>;

package/src/lib/mkCqrsClient.d.ts

@@ -0,0 +1,64 @@
+import { ApiResponse, CommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
+import { ValidationErrorsHandler } from "@leancodepl/validation";
+import type { Updater } from "@tanstack/query-core/build/lib/utils";
+import { FetchQueryOptions, QueryClient, QueryFunctionContext, QueryKey, UseInfiniteQueryOptions, UseMutationOptions, UseMutationResult, UseQueryOptions } from "@tanstack/react-query";
+import { Observable, OperatorFunction } from "rxjs";
+import { AjaxConfig } from "rxjs/ajax";
+import { NullableUncapitalizeDeep } from "./types";
+export declare function uncapitalizedParse<TResult>(): OperatorFunction<string, NullableUncapitalizeDeep<TResult>>;
+export declare function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, }: {
+    cqrsEndpoint: string;
+    queryClient: QueryClient;
+    tokenProvider?: Partial<TokenProvider>;
+    ajaxOptions?: Omit<AjaxConfig, "headers" | "url" | "method" | "responseType" | "body" | "withCredentials">;
+}): {
+    createQuery<TQuery, TResult>(type: string): {
+        (data: TQuery, options?: Omit<UseQueryOptions<NullableUncapitalizeDeep<TResult>, unknown, NullableUncapitalizeDeep<TResult>, QueryKey>, "queryKey" | "queryFn" | "initialData" | "onSuccess" | "onError" | "onSettled" | "isDataEqual"> | undefined): import("@tanstack/react-query").UseQueryResult<NullableUncapitalizeDeep<TResult>, unknown>;
+        fetcher(data: TQuery, context?: QueryFunctionContext<QueryKey>): Observable<NullableUncapitalizeDeep<TResult>>;
+        fetch(data: TQuery, options?: Omit<FetchQueryOptions<NullableUncapitalizeDeep<TResult>, unknown, NullableUncapitalizeDeep<TResult>, QueryKey>, "queryKey" | "queryFn"> | undefined): 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?: (Omit<UseInfiniteQueryOptions<NullableUncapitalizeDeep<TResult>, unknown, NullableUncapitalizeDeep<TResult>, NullableUncapitalizeDeep<TResult>, QueryKey>, "queryKey" | "queryFn" | "initialData" | "onSuccess" | "onError" | "onSettled"> & {
+            pageParamKey?: keyof TQuery | undefined;
+        }) | undefined): import("@tanstack/react-query").UseInfiniteQueryResult<NullableUncapitalizeDeep<TResult>, unknown>;
+        key(query: Partial<TQuery>): readonly [string, Partial<TQuery>];
+        setQueryData: {
+            (query: TQuery, updater: Updater<NullableUncapitalizeDeep<TResult> | undefined, NullableUncapitalizeDeep<TResult> | undefined>): NullableUncapitalizeDeep<TResult> | undefined;
+            (queryKey: QueryKey, updater: Updater<NullableUncapitalizeDeep<TResult> | undefined, NullableUncapitalizeDeep<TResult> | undefined>): 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>, "queryKey" | "queryFn" | "initialData"> | undefined): Promise<void>;
+        invalidate(query: Partial<TQuery>): Promise<void>;
+    };
+    createOperation<TOperation, TResult_1>(type: string): {
+        <TContext_1 = unknown>({ onSuccess: onSuccessBase, invalidateQueries, ...options }?: Omit<UseMutationOptions<NullableUncapitalizeDeep<TResult_1>, unknown, TOperation, TContext_1>, "mutationFn" | "mutationKey"> & {
+            invalidateQueries?: QueryKey[] | undefined;
+        }): UseMutationResult<NullableUncapitalizeDeep<TResult_1>, unknown, TOperation, TContext_1>;
+        fetcher(variables: TOperation): Observable<NullableUncapitalizeDeep<TResult_1>>;
+    };
+    createCommand<TCommand, TErrorCodes extends {
+        [name: string]: number;
+    }>(type: string, errorCodes: TErrorCodes): {
+        <TContext_2 = unknown>(options?: (Omit<UseMutationOptions<CommandResult<TErrorCodes>, unknown, TCommand, TContext_2>, "mutationFn" | "mutationKey"> & {
+            invalidateQueries?: QueryKey[] | undefined;
+            handler?: undefined;
+        }) | undefined): UseMutationResult<CommandResult<TErrorCodes>, unknown, TCommand, TContext_2>;
+        <TResult_2, TContext_3 = unknown>(options?: (Omit<UseMutationOptions<TResult_2, unknown, TCommand, TContext_3>, "mutationFn" | "mutationKey"> & {
+            invalidateQueries?: QueryKey[] | undefined;
+            handler: (handler: ValidationErrorsHandler<TErrorCodes & {
+                success: -1;
+                failure: -2;
+            }, never>) => TResult_2;
+        }) | undefined): UseMutationResult<TResult_2, unknown, TCommand, TContext_3>;
+        fetcher(variables: TCommand): Observable<CommandResult<TErrorCodes>>;
+        call<TResult_3>(variables: TCommand, handler: (handler: ValidationErrorsHandler<TErrorCodes & {
+            success: -1;
+            failure: -2;
+        }, never>) => TResult_3): Observable<TResult_3>;
+        mapError(e: unknown): ApiResponse<CommandResult<TErrorCodes>>;
+        handleResponse<TResult_4>(handler: (handler: ValidationErrorsHandler<TErrorCodes & {
+            success: -1;
+            failure: -2;
+        }, never>) => TResult_4): (response: ApiResponse<CommandResult<TErrorCodes>>) => TResult_4;
+    };
+};

package/src/lib/types/index.d.ts

@@ -0,0 +1,2 @@
+import { UncapitalizeDeep } from "@leancodepl/utils";
+export type NullableUncapitalizeDeep<T> = T extends null ? null : UncapitalizeDeep<T>;

package/src/lib/uncapitalizedJSONParse.d.ts

@@ -0,0 +1 @@
+export declare function uncapitalizedJSONParse(json: string): any;