@leancodepl/axios-cqrs-client 8.5.0 → 8.5.1

package/README.md

@@ -0,0 +1,111 @@
+# @leancodepl/axios-cqrs-client
+
+CQRS client with Axios for HTTP communication and command/query handling.
+
+## Installation
+
+```bash
+npm install @leancodepl/axios-cqrs-client
+# or
+yarn add @leancodepl/axios-cqrs-client
+```
+
+## API
+
+### `mkCqrsClient(cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader)`
+
+Creates CQRS client with Axios for HTTP communication and command/query handling.
+
+**Parameters:**
+
+- `cqrsEndpoint: string` - Base URL for CQRS API endpoints
+- `tokenProvider?: TokenProvider` - Optional token provider for authentication
+- `axiosOptions?: CreateAxiosDefaults` - Optional Axios configuration options
+- `tokenHeader?: string` - Header name for authentication token (default: "Authorization")
+
+**Returns:** Object with `createQuery`, `createOperation`, and `createCommand` methods
+
+### `mkUncapitalizedCqrsClient(params)`
+
+Creates CQRS client with automatic response key uncapitalization using "@leancodepl/utils".
+
+**Parameters:**
+
+- `params: MkCqrsClientParameters` - Configuration object for CQRS client
+- `params.cqrsEndpoint: string` - Base URL for CQRS API endpoints
+- `params.tokenProvider?: TokenProvider` - Optional token provider for authentication
+- `params.axiosOptions?: CreateAxiosDefaults` - Optional Axios configuration options
+- `params.tokenHeader?: string` - Header name for authentication token (default: "Authorization")
+
+**Returns:** CQRS client with response key transformation
+
+## Usage Examples
+
+### Basic Setup
+
+```typescript
+import { mkCqrsClient } from "@leancodepl/axios-cqrs-client"
+
+const client = mkCqrsClient({
+    cqrsEndpoint: "https://api.example.com",
+    tokenProvider: {
+        getToken: () => Promise.resolve(localStorage.getItem("token")),
+        invalidateToken: () => Promise.resolve(true),
+    },
+})
+```
+
+### Query Operations
+
+```typescript
+interface GetUserQuery {
+    userId: string
+}
+
+interface UserResult {
+    id: string
+    name: string
+    email: string
+}
+
+const getUser = client.createQuery<GetUserQuery, UserResult>("GetUser")
+
+const response = await getUser({ userId: "123" })
+
+if (response.isSuccess) {
+    console.log("User:", response.result)
+}
+```
+
+### Command Operations
+
+```typescript
+interface CreateUserCommand {
+    name: string
+    email: string
+}
+
+const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const
+const createUser = client.createCommand<CreateUserCommand, typeof errorCodes>("CreateUser", errorCodes)
+
+const response = await createUser({ name: "John", email: "john@example.com" })
+
+createUser
+    .handle({ name: "John", email: "john@example.com" })
+    .handle("success", () => console.log("User created"))
+    .handle("EmailExists", () => console.log("Email already exists"))
+    .check()
+```
+
+### Uncapitalized Client
+
+```typescript
+import { mkUncapitalizedCqrsClient } from "@leancodepl/axios-cqrs-client"
+
+const client = mkUncapitalizedCqrsClient({
+    cqrsEndpoint: "https://api.example.com",
+})
+
+// Automatically transforms { UserId: '123' } to { userId: '123' }
+const response = await client.createQuery("GetUser")({ userId: "123" })
+```

package/index.cjs.default.js

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

package/index.cjs.js

@@ -0,0 +1,194 @@
+'use strict';
+
+var axios = require('axios');
+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 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 axios.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 axios.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)=>validation.handleResponse(response, errorCodesMap));
+            return call;
+        }
+    };
+}
+
+function uncapitalizeResponse(response) {
+    if (!response.isSuccess) {
+        return response;
+    }
+    return _extends({}, response, {
+        result: utils.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);
+        }
+    });
+}
+
+exports.mkCqrsClient = mkCqrsClient;
+exports.mkUncapitalizedCqrsClient = mkUncapitalizedCqrsClient;

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,191 @@
+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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@leancodepl/axios-cqrs-client",
-  "version": "8.5.0",
+  "version": "8.5.1",
   "license": "Apache-2.0",
   "publishConfig": {
     "access": "public",
@@ -10,8 +10,8 @@
     "node": ">=18.0.0"
   },
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "8.5.0",
-    "@leancodepl/validation": "8.5.0",
+    "@leancodepl/cqrs-client-base": "8.5.1",
+    "@leancodepl/validation": "8.5.1",
     "axios": ">=1.6.0"
   },
   "repository": {
@@ -39,11 +39,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,2 @@
+export * from "./lib/mkCqrsClient";
+export * from "./lib/mkUncapitalizedCqrsClient";

package/src/lib/mkCqrsClient.d.ts

@@ -0,0 +1,45 @@
+import { CreateAxiosDefaults } from "axios";
+import { ApiError, ApiResponse, ApiSuccess, CommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
+export type MkCqrsClientParameters = {
+    cqrsEndpoint: string;
+    tokenProvider?: TokenProvider;
+    axiosOptions?: CreateAxiosDefaults;
+    tokenHeader?: string;
+};
+/**
+ * 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') }
+ * });
+ * ```
+ */
+export declare function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader, }: MkCqrsClientParameters): {
+    createQuery<TQuery, TResult>(type: string): (dto: TQuery) => QueryPromise<TResult>;
+    createOperation<TOperation, TResult>(type: string): (dto: TOperation) => Promise<ApiError | ApiSuccess<TResult>>;
+    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>>;
+    };
+};
+export type QueryAbort = {
+    abort: AbortController["abort"];
+};
+export type QueryPromise<TResult> = Promise<ApiResponse<TResult>> & QueryAbort;

package/src/lib/mkUncapitalizedCqrsClient.d.ts

@@ -0,0 +1,40 @@
+import type { ApiResponse } from "@leancodepl/cqrs-client-base";
+import { type MkCqrsClientParameters } from "./mkCqrsClient";
+/**
+ * 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'
+ * });
+ * ```
+ */
+export declare function mkUncapitalizedCqrsClient(params: MkCqrsClientParameters): {
+    createQuery<TQuery, TResult>(type: string): (dto: TQuery) => Promise<import("@leancodepl/cqrs-client-base").ApiError | {
+        result: import("@leancodepl/utils").TransformDeep<TResult, "uncapitalize">;
+        isSuccess: true;
+    }>;
+    createOperation<TOperation, TResult>(type: string): (dto: TOperation) => Promise<import("@leancodepl/cqrs-client-base").ApiError | {
+        result: import("@leancodepl/utils").TransformDeep<TResult, "uncapitalize">;
+        isSuccess: true;
+    }>;
+    createCommand<TCommand, TErrorCodes extends {
+        [name: string]: number;
+    }>(type: string, errorCodesMap: TErrorCodes): {
+        (dto: TCommand): Promise<ApiResponse<import("@leancodepl/cqrs-client-base").CommandResult<TErrorCodes>>>;
+        handle(dto: TCommand): Promise<import("@leancodepl/validation").ValidationErrorsHandler<TErrorCodes & {
+            readonly success: -1;
+            readonly failure: -2;
+        }, never>>;
+    };
+};