@leancodepl/react-query-cqrs-client 8.5.0 → 8.6.0

package/README.md

@@ -0,0 +1,155 @@
+# @leancodepl/react-query-cqrs-client
+
+TanStack Query CQRS client with hooks for queries, operations, and commands.
+
+## Features
+
+- **TanStack Query integration** - Built-in caching, optimistic updates, and background refetching
+- **CQRS pattern** - Separate queries, commands, and operations with proper typing
+- **Custom hooks** - Hook factories for all operation types with loading states
+- **Error handling** - Validation errors with custom error codes and handlers
+- **Authentication** - Token handling with automatic refresh integration
+- **Cache management** - Smart invalidation and query dependency management
+
+## Installation
+
+```bash
+npm install @leancodepl/react-query-cqrs-client
+# or
+yarn add @leancodepl/react-query-cqrs-client
+```
+
+## API
+
+### `mkCqrsClient(cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, tokenHeader)`
+
+Creates TanStack Query CQRS client with hooks for queries, operations, and commands.
+
+**Parameters:**
+
+- `cqrsEndpoint: string` - Base URL for CQRS API endpoints
+- `queryClient: QueryClient` - TanStack Query client instance
+- `tokenProvider?: Partial<TokenProvider>` - Optional token provider for authentication
+- `ajaxOptions?: Omit<AjaxConfig, ...>` - Optional RxJS Ajax configuration options
+- `tokenHeader?: string` - Header name for authentication token (default: "Authorization")
+
+**Returns:** Object with `createQuery`, `createOperation`, and `createCommand` hook factories
+
+## Usage Examples
+
+### Basic Setup
+
+```typescript
+import { mkCqrsClient } from "@leancodepl/react-query-cqrs-client"
+import { QueryClient } from "@tanstack/react-query"
+
+const queryClient = new QueryClient()
+
+const client = mkCqrsClient({
+    cqrsEndpoint: "https://api.example.com",
+    queryClient,
+    tokenProvider: {
+        getToken: () => Promise.resolve(localStorage.getItem("token")),
+    },
+})
+```
+
+### Query Hook
+
+```typescript
+import React from 'react';
+
+interface GetUserQuery {
+  userId: string;
+}
+
+interface UserResult {
+  id: string;
+  name: string;
+  email: string;
+}
+
+const useGetUser = client.createQuery<GetUserQuery, UserResult>('GetUser');
+
+function UserProfile({ userId }: { userId: string }) {
+  const { data, isLoading, error } = useGetUser({ userId });
+
+  if (isLoading) return <div>Loading...</div>;
+  if (error) return <div>Error loading user</div>;
+
+  return (
+    <div>
+      <h1>{data?.name}</h1>
+      <p>{data?.email}</p>
+    </div>
+  );
+}
+```
+
+### Command Hook
+
+```typescript
+import React from 'react';
+
+interface CreateUserCommand {
+  name: string;
+  email: string;
+}
+
+const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const;
+const useCreateUser = client.createCommand<CreateUserCommand, typeof errorCodes>('CreateUser', errorCodes);
+
+function CreateUserForm() {
+  const { mutate: createUser, isPending } = useCreateUser({
+    handler: (handle) =>
+      handle('success', () => 'User created successfully')
+        .handle('EmailExists', () => 'Email already exists')
+        .handle('failure', () => 'Failed to create user')
+        .check(),
+  });
+
+  const handleSubmit = () => {
+    createUser({ name: 'John', email: 'john@example.com' });
+  };
+
+  return (
+    <button onClick={handleSubmit} disabled={isPending}>
+      {isPending ? 'Creating...' : 'Create User'}
+    </button>
+  );
+}
+```
+
+### Operation Hook
+
+```typescript
+interface UploadFileOperation {
+  file: File;
+  folder: string;
+}
+
+interface UploadResult {
+  url: string;
+  filename: string;
+}
+
+const useUploadFile = client.createOperation<UploadFileOperation, UploadResult>('UploadFile');
+
+function FileUploader() {
+  const { mutate: uploadFile, isPending } = useUploadFile({
+    invalidateQueries: [['GetFiles']],
+  });
+
+  const handleUpload = (file: File) => {
+    uploadFile({ file, folder: 'documents' });
+  };
+
+  return (
+    <input
+      type="file"
+      onChange={(e) => e.target.files?.[0] && handleUpload(e.target.files[0])}
+      disabled={isPending}
+    />
+  );
+}
+```

package/index.cjs.default.js

@@ -0,0 +1 @@
+exports._default = require('./index.cjs.js').default;

package/index.cjs.js

@@ -0,0 +1,281 @@
+'use strict';
+
+var reactQuery = require('@tanstack/react-query');
+var rxjs = require('rxjs');
+var ajax = require('rxjs/ajax');
+var operators = require('rxjs/operators');
+var validation = require('@leancodepl/validation');
+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) {
+    if (!(tokenProvider == null ? void 0 : tokenProvider.invalidateToken)) {
+        return (response)=>response;
+    }
+    return (response)=>response.pipe(rxjs.catchError((error)=>{
+            if (error.status === 401) {
+                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));
+}
+/**
+ * Creates React Query CQRS client with hooks for queries, operations, and commands.
+ * 
+ * Integrates with React Query to provide caching, background updates, and optimistic updates
+ * for CQRS operations. Automatically handles authentication, retries, and response transformation
+ * with uncapitalized keys.
+ * 
+ * @param cqrsEndpoint - Base URL for CQRS API endpoints
+ * @param queryClient - React Query client instance
+ * @param tokenProvider - Optional token provider for authentication
+ * @param ajaxOptions - Optional RxJS Ajax configuration options
+ * @param tokenHeader - Header name for authentication token (default: "Authorization")
+ * @returns Object with `createQuery`, `createOperation`, and `createCommand` hook factories
+ * @example
+ * ```typescript
+ * const client = mkCqrsClient({
+ *   cqrsEndpoint: 'https://api.example.com',
+ *   queryClient: new QueryClient()
+ * });
+ * ```
+ */ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, tokenHeader = "Authorization" }) {
+    function mkFetcher(endpoint, config = {}) {
+        const apiCall = (data, token)=>{
+            var _ajaxOptions_withCredentials;
+            return ajax.ajax(_extends({}, ajaxOptions, config, {
+                headers: {
+                    [tokenHeader]: token,
+                    "Content-Type": "application/json"
+                },
+                url: `${cqrsEndpoint}/${endpoint}`,
+                method: "POST",
+                body: data,
+                withCredentials: (_ajaxOptions_withCredentials = ajaxOptions == null ? void 0 : ajaxOptions.withCredentials) != null ? _ajaxOptions_withCredentials : true
+            }));
+        };
+        const getToken = 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), queryClient);
+            }
+            useApiQuery.type = type;
+            useApiQuery.fetcher = (data, context)=>rxjs.race([
+                    fetcher(data).pipe(uncapitalizedParse()),
+                    ...(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(_extends({
+                    mutationKey: [
+                        type
+                    ],
+                    mutationFn: (variables)=>rxjs.firstValueFrom(useApiQuery.fetcher(variables))
+                }, options), queryClient);
+            };
+            useApiQuery.infinite = function(initialPageData, options) {
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                return reactQuery.useInfiniteQuery(_extends({
+                    queryKey: [
+                        type
+                    ],
+                    queryFn: async (context)=>await rxjs.firstValueFrom(useApiQuery.fetcher(context.pageParam, context)),
+                    initialPageParam: initialPageData
+                }, options), queryClient);
+            };
+            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.setQueriesData = (query, updater)=>queryClient.setQueriesData({
+                    queryKey: useApiQuery.key(query)
+                }, updater);
+            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)
+                });
+            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) {
+            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: useApiOperation.key,
+                    mutationFn: (variables)=>rxjs.firstValueFrom(useApiOperation.fetcher(variables))
+                }, options, {
+                    async onSuccess (data, variables, context) {
+                        const result = await (onSuccessBase == null ? void 0 : onSuccessBase(data, variables, context));
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
+                        return result;
+                    }
+                }), queryClient);
+            }
+            useApiOperation.type = type;
+            useApiOperation.key = [
+                useApiOperation.type
+            ];
+            useApiOperation.fetcher = (variables)=>fetcher(variables).pipe(uncapitalizedParse());
+            return useApiOperation;
+        },
+        createCommand (type, errorCodes) {
+            const fetcher = mkFetcher(`command/${type}`);
+            function useApiCommand(_param = {}) {
+                var { invalidateQueries, handler, optimisticUpdate, onMutate, onError, onSettled } = _param, options = _object_without_properties_loose(_param, [
+                    "invalidateQueries",
+                    "handler",
+                    "optimisticUpdate",
+                    "onMutate",
+                    "onError",
+                    "onSettled"
+                ]);
+                return reactQuery.useMutation(_extends({}, options, {
+                    mutationKey: useApiCommand.key,
+                    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));
+                        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 onError (error, variables, context) {
+                        await (onError == null ? void 0 : onError(error, variables, context));
+                        context == null ? void 0 : context.revertOptimisticUpdate();
+                    },
+                    async onSettled (data, error, variables, context) {
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
+                        return await (onSettled == null ? void 0 : onSettled(data, error, variables, context));
+                    }
+                }), queryClient);
+            }
+            useApiCommand.type = type;
+            useApiCommand.key = [
+                useApiCommand.type
+            ];
+            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((response)=>{
+                    const result = handler ? useApiCommand.handleResponse(handler)(response) : response;
+                    if (!response.isSuccess || !response.result.WasSuccessful) {
+                        throw result;
+                    }
+                    return result;
+                }));
+            };
+            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.cjs.mjs

@@ -0,0 +1,2 @@
+export * from './index.cjs.js';
+export { _default as default } from './index.cjs.default.js';

package/index.d.ts

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

package/index.esm.js

@@ -0,0 +1,279 @@
+import { useMutation, useInfiniteQuery, useQuery } from '@tanstack/react-query';
+import { catchError, throwError, of, race, fromEvent, from, firstValueFrom } from 'rxjs';
+import { AjaxError, ajax } from 'rxjs/ajax';
+import { map, mergeMap } from 'rxjs/operators';
+import { handleResponse } from '@leancodepl/validation';
+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) {
+    if (!(tokenProvider == null ? void 0 : tokenProvider.invalidateToken)) {
+        return (response)=>response;
+    }
+    return (response)=>response.pipe(catchError((error)=>{
+            if (error.status === 401) {
+                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));
+}
+/**
+ * Creates React Query CQRS client with hooks for queries, operations, and commands.
+ * 
+ * Integrates with React Query to provide caching, background updates, and optimistic updates
+ * for CQRS operations. Automatically handles authentication, retries, and response transformation
+ * with uncapitalized keys.
+ * 
+ * @param cqrsEndpoint - Base URL for CQRS API endpoints
+ * @param queryClient - React Query client instance
+ * @param tokenProvider - Optional token provider for authentication
+ * @param ajaxOptions - Optional RxJS Ajax configuration options
+ * @param tokenHeader - Header name for authentication token (default: "Authorization")
+ * @returns Object with `createQuery`, `createOperation`, and `createCommand` hook factories
+ * @example
+ * ```typescript
+ * const client = mkCqrsClient({
+ *   cqrsEndpoint: 'https://api.example.com',
+ *   queryClient: new QueryClient()
+ * });
+ * ```
+ */ function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, tokenHeader = "Authorization" }) {
+    function mkFetcher(endpoint, config = {}) {
+        const apiCall = (data, token)=>{
+            var _ajaxOptions_withCredentials;
+            return ajax(_extends({}, ajaxOptions, config, {
+                headers: {
+                    [tokenHeader]: token,
+                    "Content-Type": "application/json"
+                },
+                url: `${cqrsEndpoint}/${endpoint}`,
+                method: "POST",
+                body: data,
+                withCredentials: (_ajaxOptions_withCredentials = ajaxOptions == null ? void 0 : ajaxOptions.withCredentials) != null ? _ajaxOptions_withCredentials : true
+            }));
+        };
+        const getToken = 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), queryClient);
+            }
+            useApiQuery.type = type;
+            useApiQuery.fetcher = (data, context)=>race([
+                    fetcher(data).pipe(uncapitalizedParse()),
+                    ...(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(_extends({
+                    mutationKey: [
+                        type
+                    ],
+                    mutationFn: (variables)=>firstValueFrom(useApiQuery.fetcher(variables))
+                }, options), queryClient);
+            };
+            useApiQuery.infinite = function(initialPageData, options) {
+                // eslint-disable-next-line react-hooks/rules-of-hooks
+                return useInfiniteQuery(_extends({
+                    queryKey: [
+                        type
+                    ],
+                    queryFn: async (context)=>await firstValueFrom(useApiQuery.fetcher(context.pageParam, context)),
+                    initialPageParam: initialPageData
+                }, options), queryClient);
+            };
+            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.setQueriesData = (query, updater)=>queryClient.setQueriesData({
+                    queryKey: useApiQuery.key(query)
+                }, updater);
+            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)
+                });
+            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) {
+            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: useApiOperation.key,
+                    mutationFn: (variables)=>firstValueFrom(useApiOperation.fetcher(variables))
+                }, options, {
+                    async onSuccess (data, variables, context) {
+                        const result = await (onSuccessBase == null ? void 0 : onSuccessBase(data, variables, context));
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
+                        return result;
+                    }
+                }), queryClient);
+            }
+            useApiOperation.type = type;
+            useApiOperation.key = [
+                useApiOperation.type
+            ];
+            useApiOperation.fetcher = (variables)=>fetcher(variables).pipe(uncapitalizedParse());
+            return useApiOperation;
+        },
+        createCommand (type, errorCodes) {
+            const fetcher = mkFetcher(`command/${type}`);
+            function useApiCommand(_param = {}) {
+                var { invalidateQueries, handler, optimisticUpdate, onMutate, onError, onSettled } = _param, options = _object_without_properties_loose(_param, [
+                    "invalidateQueries",
+                    "handler",
+                    "optimisticUpdate",
+                    "onMutate",
+                    "onError",
+                    "onSettled"
+                ]);
+                return useMutation(_extends({}, options, {
+                    mutationKey: useApiCommand.key,
+                    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));
+                        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 onError (error, variables, context) {
+                        await (onError == null ? void 0 : onError(error, variables, context));
+                        context == null ? void 0 : context.revertOptimisticUpdate();
+                    },
+                    async onSettled (data, error, variables, context) {
+                        if (invalidateQueries) {
+                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
+                                    queryKey
+                                })));
+                        }
+                        return await (onSettled == null ? void 0 : onSettled(data, error, variables, context));
+                    }
+                }), queryClient);
+            }
+            useApiCommand.type = type;
+            useApiCommand.key = [
+                useApiCommand.type
+            ];
+            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((response)=>{
+                    const result = handler ? useApiCommand.handleResponse(handler)(response) : response;
+                    if (!response.isSuccess || !response.result.WasSuccessful) {
+                        throw result;
+                    }
+                    return result;
+                }));
+            };
+            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

@@ -1,11 +1,11 @@
 {
   "name": "@leancodepl/react-query-cqrs-client",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "license": "Apache-2.0",
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "8.5.0",
-    "@leancodepl/utils": "8.5.0",
-    "@leancodepl/validation": "8.5.0",
+    "@leancodepl/cqrs-client-base": "8.6.0",
+    "@leancodepl/utils": "8.6.0",
+    "@leancodepl/validation": "8.6.0",
     "@tanstack/react-query": ">=5.0.0",
     "rxjs": ">=7.0.0"
   },
@@ -44,11 +44,6 @@
     "name": "LeanCode",
     "url": "https://leancode.co"
   },
-  "files": [
-    "dist",
-    "README.md",
-    "CHANGELOG.md"
-  ],
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",

package/src/index.d.ts

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

package/src/lib/authGuard.d.ts

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

package/src/lib/mkCqrsClient.d.ts

@@ -0,0 +1,93 @@
+import { FetchQueryOptions, InfiniteData, QueryClient, QueryFunctionContext, QueryKey, UndefinedInitialDataInfiniteOptions, UndefinedInitialDataOptions, Updater, UseMutationOptions, UseMutationResult } from "@tanstack/react-query";
+import { Observable, OperatorFunction } from "rxjs";
+import { AjaxConfig } from "rxjs/ajax";
+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>>;
+/**
+ * Creates React Query CQRS client with hooks for queries, operations, and commands.
+ *
+ * Integrates with React Query to provide caching, background updates, and optimistic updates
+ * for CQRS operations. Automatically handles authentication, retries, and response transformation
+ * with uncapitalized keys.
+ *
+ * @param cqrsEndpoint - Base URL for CQRS API endpoints
+ * @param queryClient - React Query client instance
+ * @param tokenProvider - Optional token provider for authentication
+ * @param ajaxOptions - Optional RxJS Ajax configuration options
+ * @param tokenHeader - Header name for authentication token (default: "Authorization")
+ * @returns Object with `createQuery`, `createOperation`, and `createCommand` hook factories
+ * @example
+ * ```typescript
+ * const client = mkCqrsClient({
+ *   cqrsEndpoint: 'https://api.example.com',
+ *   queryClient: new QueryClient()
+ * });
+ * ```
+ */
+export declare function mkCqrsClient({ cqrsEndpoint, queryClient, tokenProvider, ajaxOptions, tokenHeader, }: {
+    cqrsEndpoint: string;
+    queryClient: QueryClient;
+    tokenProvider?: Partial<TokenProvider>;
+    ajaxOptions?: Omit<AjaxConfig, "body" | "headers" | "method" | "responseType" | "url">;
+    tokenHeader?: string;
+}): {
+    createQuery<TQuery, TResult>(type: string): {
+        (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>, "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(initialPageData: TQuery, options: Omit<UndefinedInitialDataInfiniteOptions<NullableUncapitalizeDeep<TResult>, unknown, InfiniteData<NullableUncapitalizeDeep<TResult>>, QueryKey, TQuery>, "initialPageParam" | "queryFn" | "queryKey" | "select">): import("@tanstack/react-query").UseInfiniteQueryResult<InfiniteData<NullableUncapitalizeDeep<TResult>, TQuery>, 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;
+        };
+        setQueriesData(query: Partial<TQuery>, updater: Updater<NullableUncapitalizeDeep<TResult> | undefined, NullableUncapitalizeDeep<TResult> | undefined>): [readonly unknown[], unknown][];
+        getQueryData(query: TQuery): NullableUncapitalizeDeep<TResult> | undefined;
+        getQueriesData(query: Partial<TQuery>): [readonly unknown[], NullableUncapitalizeDeep<TResult> | undefined][];
+        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>(type: string): {
+        <TContext = unknown>({ onSuccess: onSuccessBase, invalidateQueries, ...options }?: Omit<UseMutationOptions<NullableUncapitalizeDeep<TResult>, unknown, TOperation, TContext>, "mutationFn" | "mutationKey"> & {
+            invalidateQueries?: QueryKey[];
+        }): UseMutationResult<NullableUncapitalizeDeep<TResult>, unknown, TOperation, TContext>;
+        type: string;
+        key: string[];
+        fetcher(variables: TOperation): Observable<NullableUncapitalizeDeep<TResult>>;
+    };
+    createCommand<TCommand, TErrorCodes extends {
+        [name: string]: number;
+    }>(type: string, errorCodes: TErrorCodes): {
+        <TContext extends Record<string, unknown> = {}>(options?: Omit<UseMutationOptions<ApiSuccess<SuccessfulCommandResult>, ApiResponse<FailedCommandResult<TErrorCodes>>, TCommand, TContext>, "mutationFn" | "mutationKey"> & {
+            invalidateQueries?: QueryKey[];
+            handler?: undefined;
+            optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
+        }): UseMutationResult<ApiSuccess<SuccessfulCommandResult>, ApiResponse<FailedCommandResult<TErrorCodes>>, TCommand, TContext>;
+        <TResult, TContext extends Record<string, unknown> = {}>(options?: Omit<UseMutationOptions<TResult, TResult, TCommand, TContext>, "mutationFn" | "mutationKey"> & {
+            invalidateQueries?: QueryKey[];
+            handler: (handler: ValidationErrorsHandler<TErrorCodes & {
+                success: -1;
+                failure: -2;
+            }, never>) => TResult;
+            optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
+        }): UseMutationResult<TResult, TResult, TCommand, TContext>;
+        type: string;
+        key: string[];
+        fetcher(variables: TCommand): Observable<SuccessfulCommandResult>;
+        call<TResult>(variables: TCommand, handler?: (handler: ValidationErrorsHandler<TErrorCodes & {
+            success: -1;
+            failure: -2;
+        }, never>) => TResult): Observable<ApiSuccess<SuccessfulCommandResult> | TResult>;
+        mapError(e: unknown): ApiResponse<CommandResult<TErrorCodes>>;
+        handleResponse<TResult>(handler: (handler: ValidationErrorsHandler<TErrorCodes & {
+            success: -1;
+            failure: -2;
+        }, never>) => TResult): (response: ApiResponse<CommandResult<TErrorCodes>>) => TResult;
+    };
+};

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;