@leancodepl/react-query-cqrs-client 9.7.2 → 9.7.4

package/index.esm.js

@@ -1,280 +0,0 @@
-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: (context)=>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, onMutateResult, context) {
-                        const result = await (onSuccessBase == null ? void 0 : onSuccessBase(data, variables, onMutateResult, 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, context) {
-                        // there's really no good way to do it without type cast
-                        const baseResult = await (onMutate == null ? void 0 : onMutate(variables, context));
-                        var _optimisticUpdate;
-                        const optimisticUpdateReverts = await Promise.all((_optimisticUpdate = optimisticUpdate == null ? void 0 : optimisticUpdate(variables)) != null ? _optimisticUpdate : []);
-                        return _extends({}, baseResult, {
-                            revertOptimisticUpdate: ()=>optimisticUpdateReverts.forEach((revertOptimisticUpdate)=>revertOptimisticUpdate())
-                        });
-                    },
-                    async onError (error, variables, onMutateResult, context) {
-                        await (onError == null ? void 0 : onError(error, variables, onMutateResult, context));
-                        onMutateResult == null ? void 0 : onMutateResult.revertOptimisticUpdate();
-                    },
-                    // eslint-disable-next-line max-params
-                    async onSettled (data, error, variables, onMutateResult, context) {
-                        if (invalidateQueries) {
-                            await Promise.allSettled(invalidateQueries.map((queryKey)=>queryClient.invalidateQueries({
-                                    queryKey
-                                })));
-                        }
-                        return await (onSettled == null ? void 0 : onSettled(data, error, variables, onMutateResult, context));
-                    }
-                }), queryClient);
-            }
-            useApiCommand.type = type;
-            useApiCommand.key = [
-                useApiCommand.type
-            ];
-            useApiCommand.fetcher = fetcher;
-            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, variables)(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, variables)=>(response)=>handler(handleResponse(response, errorCodes), variables);
-            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/types/index.d.ts

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