@leancodepl/axios-cqrs-client 7.1.1

package/index.cjs.d.ts

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

package/index.cjs.js

@@ -0,0 +1,98 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var validation = require('@leancodepl/validation');
+var axios = require('axios');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var axios__default = /*#__PURE__*/_interopDefaultLegacy(axios);
+
+function createSuccess(result) {
+    return {
+        isSuccess: true,
+        result
+    };
+}
+function createError(error) {
+    return {
+        isSuccess: false,
+        error
+    };
+}
+function mkCqrsClient(cqrsEndpoint, tokenProvider) {
+    const apiAxios = axios__default["default"].create({
+        baseURL: cqrsEndpoint
+    });
+    apiAxios.interceptors.request.use(async (config)=>{
+        var _tokenProvider;
+        const token = await ((_tokenProvider = tokenProvider) == null ? void 0 : _tokenProvider.getToken());
+        if (token) {
+            config.headers.set("Authorization", `Bearer ${token}`);
+        }
+        return config;
+    });
+    apiAxios.interceptors.response.use((response)=>{
+        response.data = createSuccess(response.data);
+        return response;
+    }, async (error)=>{
+        const response = error.response;
+        switch(error.response.status){
+            case 401:
+                {
+                    var _config_params, _tokenProvider;
+                    const config = error.config;
+                    if ((_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 = 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.params = error.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)=>apiAxios.post("query/" + type, dto).then((r)=>r.data);
+        },
+        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)=>validation.handleResponse(response, errorCodesMap));
+            return call;
+        }
+    };
+}
+
+exports.mkCqrsClient = mkCqrsClient;

package/index.esm.js

@@ -0,0 +1,90 @@
+import { handleResponse } from '@leancodepl/validation';
+import axios from 'axios';
+
+function createSuccess(result) {
+    return {
+        isSuccess: true,
+        result
+    };
+}
+function createError(error) {
+    return {
+        isSuccess: false,
+        error
+    };
+}
+function mkCqrsClient(cqrsEndpoint, tokenProvider) {
+    const apiAxios = axios.create({
+        baseURL: cqrsEndpoint
+    });
+    apiAxios.interceptors.request.use(async (config)=>{
+        var _tokenProvider;
+        const token = await ((_tokenProvider = tokenProvider) == null ? void 0 : _tokenProvider.getToken());
+        if (token) {
+            config.headers.set("Authorization", `Bearer ${token}`);
+        }
+        return config;
+    });
+    apiAxios.interceptors.response.use((response)=>{
+        response.data = createSuccess(response.data);
+        return response;
+    }, async (error)=>{
+        const response = error.response;
+        switch(error.response.status){
+            case 401:
+                {
+                    var _config_params, _tokenProvider;
+                    const config = error.config;
+                    if ((_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 = 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.params = error.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)=>apiAxios.post("query/" + type, dto).then((r)=>r.data);
+        },
+        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;
+        }
+    };
+}
+
+export { mkCqrsClient };

package/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@leancodepl/axios-cqrs-client",
+  "version": "7.1.1",
+  "dependencies": {
+    "@leancodepl/validation": "7.1.0",
+    "axios": ">=1.0.0"
+  },
+  "type": "commonjs",
+  "main": "./index.cjs.js",
+  "module": "./index.esm.js"
+}

package/src/index.d.ts

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

package/src/lib/mkCqrsClient.d.ts

@@ -0,0 +1,14 @@
+import { ApiError, ApiResponse, ApiSuccess, CommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
+export declare function mkCqrsClient(cqrsEndpoint: string, tokenProvider?: TokenProvider): {
+    createQuery<TQuery, TResult>(type: string): (dto: TQuery) => Promise<ApiError | ApiSuccess<TResult>>;
+    createOperation<TOperation, TResult_1>(type: string): (dto: TOperation) => Promise<ApiError | ApiSuccess<TResult_1>>;
+    createCommand<TCommand, TErrorCodes extends {
+        [name: string]: number;
+    }>(type: string, errorCodesMap: TErrorCodes): {
+        (dto: TCommand): Promise<ApiResponse<CommandResult<TErrorCodes>>>;
+        handle(dto: TCommand): Promise<import("@leancodepl/validation").ValidationErrorsHandler<TErrorCodes & {
+            readonly success: -1;
+            readonly failure: -2;
+        }, never>>;
+    };
+};