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

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "@leancodepl/react-query-cqrs-client",
-  "version": "8.3.6",
+  "version": "8.5.0",
   "license": "Apache-2.0",
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "8.3.6",
-    "@leancodepl/utils": "8.3.6",
-    "@leancodepl/validation": "8.3.6",
+    "@leancodepl/cqrs-client-base": "8.5.0",
+    "@leancodepl/utils": "8.5.0",
+    "@leancodepl/validation": "8.5.0",
     "@tanstack/react-query": ">=5.0.0",
     "rxjs": ">=7.0.0"
   },
@@ -13,16 +13,53 @@
     "@testing-library/react": "*",
     "react": "*"
   },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leancodepl/js_corelibrary.git",
+    "directory": "packages/cqrs-clients/react-query-cqrs-client"
+  },
+  "homepage": "https://github.com/leancodepl/js_corelibrary",
+  "bugs": {
+    "url": "https://github.com/leancodepl/js_corelibrary/issues"
+  },
+  "description": "TanStack Query integration for CQRS commands and queries",
+  "keywords": [
+    "cqrs",
+    "tanstack-query",
+    "react",
+    "hooks",
+    "cache",
+    "typescript",
+    "javascript",
+    "leancode"
+  ],
+  "author": {
+    "name": "LeanCode",
+    "url": "https://leancode.co"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": {
       "module": "./index.esm.js",
-      "types": "./index.esm.d.ts",
+      "types": "./index.d.ts",
       "import": "./index.cjs.mjs",
       "default": "./index.cjs.js"
     }
   },
   "module": "./index.esm.js",
   "main": "./index.cjs.js",
-  "types": "./index.esm.d.ts"
+  "types": "./index.d.ts"
 }

package/index.cjs.d.ts

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

package/index.cjs.default.js

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

package/index.cjs.js

@@ -1,260 +0,0 @@
-'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));
-}
-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(data, options) {
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                return reactQuery.useInfiniteQuery(_extends({
-                    queryKey: useApiQuery.key(data),
-                    queryFn: (context)=>rxjs.firstValueFrom(useApiQuery.fetcher((options == null ? void 0 : options.pageParamKey) ? _extends({}, data, {
-                            [options.pageParamKey]: context.pageParam
-                        }) : data, context))
-                }, 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

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

package/index.esm.d.ts

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

package/index.esm.js

@@ -1,258 +0,0 @@
-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 { 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));
-}
-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(data, options) {
-                // eslint-disable-next-line react-hooks/rules-of-hooks
-                return useInfiniteQuery(_extends({
-                    queryKey: useApiQuery.key(data),
-                    queryFn: (context)=>firstValueFrom(useApiQuery.fetcher((options == null ? void 0 : options.pageParamKey) ? _extends({}, data, {
-                            [options.pageParamKey]: context.pageParam
-                        }) : data, context))
-                }, 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/src/index.d.ts

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

package/src/lib/authGuard.d.ts

@@ -1,3 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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, 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>>;
-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(data: TQuery, options: {
-            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: {
-            (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>): [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>, "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 }?: {
-            invalidateQueries?: QueryKey[];
-        } & Omit<UseMutationOptions<NullableUncapitalizeDeep<TResult>, unknown, TOperation, TContext>, "mutationFn" | "mutationKey">): 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?: {
-            invalidateQueries?: QueryKey[];
-            handler?: undefined;
-            optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
-        } & 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<{
-                success: -1;
-                failure: -2;
-            } & TErrorCodes, never>) => TResult;
-            optimisticUpdate?: (variables: TCommand) => Promise<() => void>[];
-        } & Omit<UseMutationOptions<TResult, TResult, TCommand, TContext>, "mutationFn" | "mutationKey">): UseMutationResult<TResult, TResult, TCommand, TContext>;
-        type: string;
-        key: string[];
-        fetcher(variables: TCommand): Observable<SuccessfulCommandResult>;
-        call<TResult>(variables: TCommand, handler?: (handler: ValidationErrorsHandler<{
-            success: -1;
-            failure: -2;
-        } & TErrorCodes, never>) => TResult): Observable<ApiSuccess<SuccessfulCommandResult> | TResult>;
-        mapError(e: unknown): ApiResponse<CommandResult<TErrorCodes>>;
-        handleResponse<TResult>(handler: (handler: ValidationErrorsHandler<{
-            success: -1;
-            failure: -2;
-        } & TErrorCodes, never>) => TResult): (response: ApiResponse<CommandResult<TErrorCodes>>) => TResult;
-    };
-};

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

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

package/src/lib/uncapitalizedJSONParse.d.ts

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