@leancodepl/axios-cqrs-client 8.4.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.js

@@ -21,13 +21,33 @@ function createSuccess(result) {
         result
     };
 }
-function createError(error) {
+function createError(error, options) {
     return {
         isSuccess: false,
+        isAborted: !!(options == null ? void 0 : options.isAborted),
         error
     };
 }
-function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader = "Authorization" }) {
+/**
+ * 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));
@@ -43,13 +63,31 @@ function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader =
         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;
-                    const config = error.config;
-                    if ((_config_params = config.params) == null ? void 0 : _config_params.isRetry) {
+                    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;
                     }
@@ -61,7 +99,11 @@ function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader =
                         response.data = createError("Cannot refresh access token after the server returned 401 Unauthorized");
                         break;
                     }
-                    config.params = error.config.params || {};
+                    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);
                 }
@@ -116,7 +158,25 @@ function uncapitalizeResponse(response) {
         result: utils.uncapitalizeDeep(response.result)
     });
 }
-function mkUncapitalizedCqrsClient(params) {
+/**
+ * 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) {

package/index.esm.js

@@ -1,4 +1,4 @@
-import axios from 'axios';
+import axios, { AxiosError, AxiosHeaders } from 'axios';
 import { handleResponse } from '@leancodepl/validation';
 import { uncapitalizeDeep } from '@leancodepl/utils';
 
@@ -19,13 +19,33 @@ function createSuccess(result) {
         result
     };
 }
-function createError(error) {
+function createError(error, options) {
     return {
         isSuccess: false,
+        isAborted: !!(options == null ? void 0 : options.isAborted),
         error
     };
 }
-function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader = "Authorization" }) {
+/**
+ * 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));
@@ -41,13 +61,31 @@ function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader =
         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;
-                    const config = error.config;
-                    if ((_config_params = config.params) == null ? void 0 : _config_params.isRetry) {
+                    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;
                     }
@@ -59,7 +97,11 @@ function mkCqrsClient({ cqrsEndpoint, tokenProvider, axiosOptions, tokenHeader =
                         response.data = createError("Cannot refresh access token after the server returned 401 Unauthorized");
                         break;
                     }
-                    config.params = error.config.params || {};
+                    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);
                 }
@@ -114,7 +156,25 @@ function uncapitalizeResponse(response) {
         result: uncapitalizeDeep(response.result)
     });
 }
-function mkUncapitalizedCqrsClient(params) {
+/**
+ * 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) {

package/package.json

@@ -1,22 +1,55 @@
 {
   "name": "@leancodepl/axios-cqrs-client",
-  "version": "8.4.0",
+  "version": "8.5.1",
   "license": "Apache-2.0",
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "8.4.0",
-    "@leancodepl/validation": "8.4.0",
+    "@leancodepl/cqrs-client-base": "8.5.1",
+    "@leancodepl/validation": "8.5.1",
     "axios": ">=1.6.0"
   },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/leancodepl/js_corelibrary.git",
+    "directory": "packages/cqrs-clients/axios-cqrs-client"
+  },
+  "homepage": "https://github.com/leancodepl/js_corelibrary",
+  "bugs": {
+    "url": "https://github.com/leancodepl/js_corelibrary/issues"
+  },
+  "description": "HTTP CQRS client implementation using Axios",
+  "keywords": [
+    "cqrs",
+    "http",
+    "axios",
+    "commands",
+    "queries",
+    "api",
+    "typescript",
+    "javascript",
+    "leancode"
+  ],
+  "author": {
+    "name": "LeanCode",
+    "url": "https://leancode.co"
+  },
+  "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/src/lib/mkCqrsClient.d.ts

@@ -6,6 +6,26 @@ export type MkCqrsClientParameters = {
     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>>;

package/src/lib/mkUncapitalizedCqrsClient.d.ts

@@ -1,5 +1,24 @@
 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">;
@@ -13,7 +32,7 @@ export declare function mkUncapitalizedCqrsClient(params: MkCqrsClientParameters
         [name: string]: number;
     }>(type: string, errorCodesMap: TErrorCodes): {
         (dto: TCommand): Promise<ApiResponse<import("@leancodepl/cqrs-client-base").CommandResult<TErrorCodes>>>;
-        handle(dto: TCommand): Promise<import("dist/packages/validation/src").ValidationErrorsHandler<TErrorCodes & {
+        handle(dto: TCommand): Promise<import("@leancodepl/validation").ValidationErrorsHandler<TErrorCodes & {
             readonly success: -1;
             readonly failure: -2;
         }, never>>;

package/index.esm.d.ts

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