@leancodepl/axios-cqrs-client 9.7.1 → 9.7.3

package/index.esm.js

@@ -1,191 +0,0 @@
-import axios, { AxiosError, AxiosHeaders } from 'axios';
-import { handleResponse } from '@leancodepl/validation';
-import { uncapitalizeDeep } 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 createSuccess(result) {
-    return {
-        isSuccess: true,
-        result
-    };
-}
-function createError(error, options) {
-    return {
-        isSuccess: false,
-        isAborted: !!(options == null ? void 0 : options.isAborted),
-        error
-    };
-}
-/**
- * Creates CQRS client with Axios for HTTP communication and command/query handling.
- *
- * Provides type-safe methods for creating queries, operations, and commands with automatic
- * token management, retry logic, and response handling. Supports validation error handling
- * and HTTP status code management.
- *
- * @param cqrsEndpoint - Base URL for CQRS API endpoints
- * @param tokenProvider - Optional token provider for authentication
- * @param axiosOptions - Optional Axios configuration options
- * @param tokenHeader - Header name for authentication token (default: "Authorization")
- * @returns Object with `createQuery`, `createOperation`, and `createCommand` methods
- * @example
- * ```typescript
- * const client = mkCqrsClient({
- *   cqrsEndpoint: 'https://api.example.com',
- *   tokenProvider: { getToken: () => Promise.resolve('token') }
- * });
- * ```
- */ function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader = "Authorization" }) {
-    const apiAxios = axios.create(_extends({
-        baseURL: cqrsEndpoint
-    }, axiosOptions));
-    apiAxios.interceptors.request.use(async (config)=>{
-        const token = await (tokenProvider == null ? void 0 : tokenProvider.getToken());
-        if (token) {
-            var _config_headers;
-            (_config_headers = config.headers) == null ? void 0 : _config_headers.set(tokenHeader, `Bearer ${token}`);
-        }
-        return config;
-    });
-    apiAxios.interceptors.response.use((response)=>{
-        response.data = createSuccess(response.data);
-        return response;
-    }, async (error)=>{
-        if (!(error instanceof AxiosError)) {
-            return {
-                data: createError(`Unknown error ${error}`)
-            };
-        }
-        if (error.code === "ERR_CANCELED") {
-            return {
-                data: createError(error, {
-                    isAborted: true
-                })
-            };
-        }
-        if (!error.response) {
-            return {
-                data: createError(error)
-            };
-        }
-        const response = error.response;
-        switch(error.response.status){
-            case 401:
-                {
-                    var _config_params;
-                    var _config;
-                    let config = error.config;
-                    if (config == null ? void 0 : (_config_params = config.params) == null ? void 0 : _config_params.isRetry) {
-                        response.data = createError("The request has not been authorized and token refresh did not help");
-                        break;
-                    }
-                    if (!(tokenProvider == null ? void 0 : tokenProvider.invalidateToken)) {
-                        response.data = createError("User needs to be authenticated to execute the command/query/operation");
-                        break;
-                    }
-                    if (!await tokenProvider.invalidateToken()) {
-                        response.data = createError("Cannot refresh access token after the server returned 401 Unauthorized");
-                        break;
-                    }
-                    config != null ? config : config = {
-                        headers: new AxiosHeaders()
-                    };
-                    var _params;
-                    (_params = (_config = config).params) != null ? _params : _config.params = {};
-                    config.params.isRetry = true;
-                    return await apiAxios.request(config);
-                }
-            case 400:
-                response.data = createError("The request was malformed");
-                break;
-            case 403:
-                response.data = createError("User is not authorized to execute the command/query/operation");
-                break;
-            case 404:
-                response.data = createError("Command/query/operation not found");
-                break;
-            case 422:
-                response.data = createSuccess(error.response.data);
-                break;
-            default:
-                response.data = createError(`Cannot execute command/query/operation, server returned a ${error.response.status} code`);
-                break;
-        }
-        return response;
-    });
-    return {
-        createQuery (type) {
-            return (dto)=>{
-                const abortController = new AbortController();
-                const promise = apiAxios.post("query/" + type, dto, {
-                    signal: abortController.signal
-                }).then((r)=>r.data);
-                promise.abort = abortController.abort.bind(abortController);
-                return promise;
-            };
-        },
-        createOperation (type) {
-            return (dto)=>apiAxios.post("operation/" + type, dto).then((r)=>r.data);
-        },
-        createCommand (type, errorCodesMap) {
-            async function call(dto) {
-                const response = await apiAxios.post("command/" + type, dto);
-                return response.data;
-            }
-            call.handle = (dto)=>call(dto).then((response)=>handleResponse(response, errorCodesMap));
-            return call;
-        }
-    };
-}
-
-function uncapitalizeResponse(response) {
-    if (!response.isSuccess) {
-        return response;
-    }
-    return _extends({}, response, {
-        result: uncapitalizeDeep(response.result)
-    });
-}
-/**
- * Creates CQRS client with automatic response key uncapitalization using "@leancodepl/utils".
- *
- * Extends the base CQRS client to automatically transform response object keys from
- * PascalCase to camelCase using deep transformation.
- *
- * @param params - Configuration object for CQRS client
- * @param params.cqrsEndpoint - Base URL for CQRS API endpoints
- * @param params.tokenProvider - Optional token provider for authentication
- * @param params.axiosOptions - Optional Axios configuration options
- * @param params.tokenHeader - Header name for authentication token (default: "Authorization")
- * @returns CQRS client with response key transformation
- * @example
- * ```typescript
- * const client = mkUncapitalizedCqrsClient({
- *   cqrsEndpoint: 'https://api.example.com'
- * });
- * ```
- */ function mkUncapitalizedCqrsClient(params) {
-    const baseClient = mkCqrsClient(params);
-    return _extends({}, baseClient, {
-        createQuery (type) {
-            const query = baseClient.createQuery(type);
-            return (dto)=>query(dto).then(uncapitalizeResponse);
-        },
-        createOperation (type) {
-            const operation = baseClient.createOperation(type);
-            return (dto)=>operation(dto).then(uncapitalizeResponse);
-        }
-    });
-}
-
-export { mkCqrsClient, mkUncapitalizedCqrsClient };

package/src/index.d.ts

@@ -1,2 +0,0 @@
-export * from "./lib/mkCqrsClient";
-export * from "./lib/mkUncapitalizedCqrsClient";