@leancodepl/rx-cqrs-client 8.5.0 → 8.5.1

package/README.md

@@ -0,0 +1,138 @@
+# @leancodepl/rx-cqrs-client
+
+RxJS-based CQRS client for reactive command and query operations.
+
+## Features
+
+- **RxJS integration** - Reactive streams with operators for real-time data handling
+- **CQRS pattern** - Separate queries, commands, and operations with proper typing
+- **Observable operations** - Stream-based data handling with composable operators
+- **Error handling** - Validation errors with custom error codes and stream operators
+- **Authentication** - Token handling with automatic refresh and retry logic
+- **Custom operators** - Command response handling and stream transformation utilities
+
+## Installation
+
+```bash
+npm install @leancodepl/rx-cqrs-client
+# or
+yarn add @leancodepl/rx-cqrs-client
+```
+
+## API
+
+### `mkCqrsClient(cqrsEndpoint, tokenProvider, ajaxOptions, tokenHeader)`
+
+Creates CQRS client for command and query operations.
+
+**Parameters:**
+
+- `cqrsEndpoint: string` - Base URL for CQRS API endpoints
+- `tokenProvider?: TokenProvider` - Optional token provider for authentication
+- `ajaxOptions?: Omit<AjaxConfig, ...>` - Optional RxJS Ajax configuration options
+- `tokenHeader?: string` - Header name for authentication token (default: "Authorization")
+
+**Returns:** Object with `createQuery`, `createOperation`, and `createCommand` observable factories
+
+### `handleCommandResponse(handlerFunc)`
+
+Handles command responses with RxJS operators for validation error processing.
+
+**Parameters:**
+
+- `handlerFunc: Function` - Function that processes validation error handlers
+
+**Returns:** RxJS operator function for handling command responses
+
+### `reduceBoolean()`
+
+Reduces boolean values in RxJS streams using logical AND operation.
+
+**Returns:** RxJS operator function that reduces boolean values
+
+### `reduceObject()`
+
+Reduces object values in RxJS streams by merging properties.
+
+**Returns:** RxJS operator function that reduces object values
+
+## Usage Examples
+
+### Basic Setup
+
+```typescript
+import { mkCqrsClient } from "@leancodepl/rx-cqrs-client"
+
+const client = mkCqrsClient({
+    cqrsEndpoint: "https://api.example.com",
+    tokenProvider: {
+        getToken: () => Promise.resolve(localStorage.getItem("token")),
+        invalidateToken: () => Promise.resolve(true),
+    },
+})
+```
+
+### Query Operations
+
+```typescript
+import { switchMap } from "rxjs/operators"
+
+interface GetUserQuery {
+    userId: string
+}
+
+interface UserResult {
+    id: string
+    name: string
+    email: string
+}
+
+const getUser = client.createQuery<GetUserQuery, UserResult>("GetUser")
+
+getUser({ userId: "123" }).subscribe({
+    next: user => console.log("User:", user),
+    error: error => console.error("Error:", error),
+})
+```
+
+### Command Operations
+
+```typescript
+import { catchError } from "rxjs/operators"
+import { of } from "rxjs"
+
+interface CreateUserCommand {
+    name: string
+    email: string
+}
+
+const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const
+const createUser = client.createCommand<CreateUserCommand, typeof errorCodes>("CreateUser", errorCodes)
+
+createUser
+    .handle({ name: "John", email: "john@example.com" })
+    .handle("success", () => console.log("User created"))
+    .handle("EmailExists", () => console.log("Email already exists"))
+    .handle("failure", () => console.log("Creation failed"))
+    .check()
+```
+
+### Reactive Patterns
+
+```typescript
+import { fromEvent, switchMap, debounceTime } from "rxjs"
+
+const searchInput = document.getElementById("search") as HTMLInputElement
+
+fromEvent(searchInput, "input")
+    .pipe(
+        debounceTime(300),
+        switchMap(event => {
+            const query = (event.target as HTMLInputElement).value
+            return client.createQuery("SearchUsers")({ query })
+        }),
+    )
+    .subscribe(results => {
+        console.log("Search results:", results)
+    })
+```

package/index.cjs.default.js

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

package/index.cjs.js

@@ -0,0 +1,185 @@
+'use strict';
+
+var rxjs = require('rxjs');
+var operators = require('rxjs/operators');
+var ajax = require('rxjs/ajax');
+var validation = require('@leancodepl/validation');
+
+/**
+ * Handles command responses with RxJS operators for validation error processing.
+ * 
+ * Creates an operator that processes validation error handlers and transforms them
+ * into the desired result type using a reducer pattern.
+ * 
+ * @param handlerFunc - Function that processes validation error handlers
+ * @returns RxJS operator function for handling command responses
+ * @example
+ * ```typescript
+ * import { handleCommandResponse } from '@leancodepl/rx-cqrs-client';
+ * 
+ * const handler = handleCommandResponse((handle) => 
+ *   handle('success', () => 'Success!')
+ *     .handle('failure', () => 'Failed!')
+ *     .check()
+ * );
+ * ```
+ */ function handleCommandResponse(handlerFunc) {
+    return (source)=>source.pipe(operators.concatMap((handler)=>{
+            const subj = new rxjs.ReplaySubject();
+            handlerFunc(handler)({
+                reducer: (prev, cur)=>subj.next(cur),
+                initialValue: null
+            });
+            subj.complete();
+            return subj;
+        }));
+}
+
+function authGuard(tokenProvider) {
+    return (response)=>response.pipe(operators.retryWhen((errors$)=>errors$.pipe(operators.mergeMap((error, i)=>{
+                if (i === 0 && error.status === 401) {
+                    return rxjs.from(tokenProvider.invalidateToken()).pipe(operators.mergeMap((success)=>success ? rxjs.of(success) : rxjs.throwError(()=>error)));
+                }
+                return rxjs.throwError(()=>error);
+            }))));
+}
+
+/**
+ * Creates RxJS-based CQRS client for reactive command and query operations.
+ * 
+ * Provides observable-based methods for CQRS operations with automatic authentication,
+ * retry logic, and error handling.
+ * 
+ * @param cqrsEndpoint - Base URL for CQRS API endpoints
+ * @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` observable factories
+ * @example
+ * ```typescript
+ * const client = mkCqrsClient({
+ *   cqrsEndpoint: 'https://api.example.com',
+ *   tokenProvider: { getToken: () => Promise.resolve('token') }
+ * });
+ * ```
+ */ function mkCqrsClient({ cqrsEndpoint, tokenProvider, ajaxOptions, tokenHeader = "Authorization" }) {
+    return {
+        createQuery (type) {
+            const queryCall = (dto, token)=>ajax.ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        [tokenHeader]: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/query/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>rxjs.from(tokenProvider.getToken()).pipe(operators.mergeMap((token)=>queryCall(dto, token).pipe(authGuard(tokenProvider))), operators.map(({ response })=>response));
+            }
+            return (dto)=>queryCall(dto).pipe(operators.map(({ response })=>response));
+        },
+        createOperation (type) {
+            const operationCall = (dto, token)=>ajax.ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/operation/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>rxjs.from(tokenProvider.getToken()).pipe(operators.mergeMap((token)=>operationCall(dto, token).pipe(authGuard(tokenProvider))), operators.map(({ response })=>response));
+            }
+            return (dto)=>operationCall(dto).pipe(operators.map(({ response })=>response));
+        },
+        createCommand (type, errorCodesMap) {
+            const commandCall = (dto, token)=>ajax.ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/command/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            function call(dto) {
+                if (tokenProvider) {
+                    return rxjs.from(tokenProvider.getToken()).pipe(operators.mergeMap((token)=>commandCall(dto, token).pipe(authGuard(tokenProvider))), operators.map(({ response })=>response));
+                }
+                return commandCall(dto).pipe(operators.map(({ response })=>response));
+            }
+            call.handle = (dto)=>call(dto).pipe(operators.map((result)=>({
+                        isSuccess: true,
+                        result
+                    })), rxjs.catchError((e)=>{
+                    if (e instanceof ajax.AjaxError && e.status === 422) {
+                        return rxjs.of({
+                            isSuccess: true,
+                            result: e.response
+                        });
+                    }
+                    return rxjs.of({
+                        isSuccess: false,
+                        error: e
+                    });
+                }), operators.map((response)=>validation.handleResponse(response, errorCodesMap)));
+            return call;
+        }
+    };
+}
+
+/**
+ * Reduces boolean values in RxJS streams using logical AND operation.
+ * 
+ * Creates an operator that combines multiple boolean values into a single result
+ * by applying logical AND. Returns true only if all values are true.
+ * 
+ * @returns RxJS operator function that reduces boolean values
+ * @example
+ * ```typescript
+ * import { of } from 'rxjs';
+ * import { reduceBoolean } from '@leancodepl/rx-cqrs-client';
+ * 
+ * of(true, true, false).pipe(reduceBoolean()).subscribe(result => {
+ *   console.log(result); // false
+ * });
+ * ```
+ */ function reduceBoolean() {
+    return (source)=>source.pipe(rxjs.reduce((prev, cur)=>prev && cur, true));
+}
+
+/**
+ * Reduces object values in RxJS streams by merging properties.
+ * 
+ * Creates an operator that combines multiple objects into a single result
+ * by spreading properties. Later objects override earlier ones.
+ * 
+ * @returns RxJS operator function that reduces object values
+ * @example
+ * ```typescript
+ * import { of } from 'rxjs';
+ * import { reduceObject } from '@leancodepl/rx-cqrs-client';
+ * 
+ * of({ a: 1 }, { b: 2 }, { a: 3 }).pipe(reduceObject()).subscribe(result => {
+ *   console.log(result); // { a: 3, b: 2 }
+ * });
+ * ```
+ */ function reduceObject() {
+    return (source)=>source.pipe(rxjs.reduce((prev, cur)=>({
+                ...prev,
+                ...cur
+            }), {}));
+}
+
+exports.handleCommandResponse = handleCommandResponse;
+exports.mkCqrsClient = mkCqrsClient;
+exports.reduceBoolean = reduceBoolean;
+exports.reduceObject = reduceObject;

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,180 @@
+import { ReplaySubject, from, of, throwError, catchError, reduce } from 'rxjs';
+import { concatMap, retryWhen, mergeMap, map } from 'rxjs/operators';
+import { AjaxError, ajax } from 'rxjs/ajax';
+import { handleResponse } from '@leancodepl/validation';
+
+/**
+ * Handles command responses with RxJS operators for validation error processing.
+ * 
+ * Creates an operator that processes validation error handlers and transforms them
+ * into the desired result type using a reducer pattern.
+ * 
+ * @param handlerFunc - Function that processes validation error handlers
+ * @returns RxJS operator function for handling command responses
+ * @example
+ * ```typescript
+ * import { handleCommandResponse } from '@leancodepl/rx-cqrs-client';
+ * 
+ * const handler = handleCommandResponse((handle) => 
+ *   handle('success', () => 'Success!')
+ *     .handle('failure', () => 'Failed!')
+ *     .check()
+ * );
+ * ```
+ */ function handleCommandResponse(handlerFunc) {
+    return (source)=>source.pipe(concatMap((handler)=>{
+            const subj = new ReplaySubject();
+            handlerFunc(handler)({
+                reducer: (prev, cur)=>subj.next(cur),
+                initialValue: null
+            });
+            subj.complete();
+            return subj;
+        }));
+}
+
+function authGuard(tokenProvider) {
+    return (response)=>response.pipe(retryWhen((errors$)=>errors$.pipe(mergeMap((error, i)=>{
+                if (i === 0 && error.status === 401) {
+                    return from(tokenProvider.invalidateToken()).pipe(mergeMap((success)=>success ? of(success) : throwError(()=>error)));
+                }
+                return throwError(()=>error);
+            }))));
+}
+
+/**
+ * Creates RxJS-based CQRS client for reactive command and query operations.
+ * 
+ * Provides observable-based methods for CQRS operations with automatic authentication,
+ * retry logic, and error handling.
+ * 
+ * @param cqrsEndpoint - Base URL for CQRS API endpoints
+ * @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` observable factories
+ * @example
+ * ```typescript
+ * const client = mkCqrsClient({
+ *   cqrsEndpoint: 'https://api.example.com',
+ *   tokenProvider: { getToken: () => Promise.resolve('token') }
+ * });
+ * ```
+ */ function mkCqrsClient({ cqrsEndpoint, tokenProvider, ajaxOptions, tokenHeader = "Authorization" }) {
+    return {
+        createQuery (type) {
+            const queryCall = (dto, token)=>ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        [tokenHeader]: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/query/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>from(tokenProvider.getToken()).pipe(mergeMap((token)=>queryCall(dto, token).pipe(authGuard(tokenProvider))), map(({ response })=>response));
+            }
+            return (dto)=>queryCall(dto).pipe(map(({ response })=>response));
+        },
+        createOperation (type) {
+            const operationCall = (dto, token)=>ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/operation/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            if (tokenProvider) {
+                return (dto)=>from(tokenProvider.getToken()).pipe(mergeMap((token)=>operationCall(dto, token).pipe(authGuard(tokenProvider))), map(({ response })=>response));
+            }
+            return (dto)=>operationCall(dto).pipe(map(({ response })=>response));
+        },
+        createCommand (type, errorCodesMap) {
+            const commandCall = (dto, token)=>ajax({
+                    ...ajaxOptions,
+                    headers: {
+                        Authorization: token,
+                        "Content-Type": "application/json"
+                    },
+                    url: `${cqrsEndpoint}/command/${type}`,
+                    method: "POST",
+                    responseType: "json",
+                    body: dto
+                });
+            function call(dto) {
+                if (tokenProvider) {
+                    return from(tokenProvider.getToken()).pipe(mergeMap((token)=>commandCall(dto, token).pipe(authGuard(tokenProvider))), map(({ response })=>response));
+                }
+                return commandCall(dto).pipe(map(({ response })=>response));
+            }
+            call.handle = (dto)=>call(dto).pipe(map((result)=>({
+                        isSuccess: true,
+                        result
+                    })), catchError((e)=>{
+                    if (e instanceof AjaxError && e.status === 422) {
+                        return of({
+                            isSuccess: true,
+                            result: e.response
+                        });
+                    }
+                    return of({
+                        isSuccess: false,
+                        error: e
+                    });
+                }), map((response)=>handleResponse(response, errorCodesMap)));
+            return call;
+        }
+    };
+}
+
+/**
+ * Reduces boolean values in RxJS streams using logical AND operation.
+ * 
+ * Creates an operator that combines multiple boolean values into a single result
+ * by applying logical AND. Returns true only if all values are true.
+ * 
+ * @returns RxJS operator function that reduces boolean values
+ * @example
+ * ```typescript
+ * import { of } from 'rxjs';
+ * import { reduceBoolean } from '@leancodepl/rx-cqrs-client';
+ * 
+ * of(true, true, false).pipe(reduceBoolean()).subscribe(result => {
+ *   console.log(result); // false
+ * });
+ * ```
+ */ function reduceBoolean() {
+    return (source)=>source.pipe(reduce((prev, cur)=>prev && cur, true));
+}
+
+/**
+ * Reduces object values in RxJS streams by merging properties.
+ * 
+ * Creates an operator that combines multiple objects into a single result
+ * by spreading properties. Later objects override earlier ones.
+ * 
+ * @returns RxJS operator function that reduces object values
+ * @example
+ * ```typescript
+ * import { of } from 'rxjs';
+ * import { reduceObject } from '@leancodepl/rx-cqrs-client';
+ * 
+ * of({ a: 1 }, { b: 2 }, { a: 3 }).pipe(reduceObject()).subscribe(result => {
+ *   console.log(result); // { a: 3, b: 2 }
+ * });
+ * ```
+ */ function reduceObject() {
+    return (source)=>source.pipe(reduce((prev, cur)=>({
+                ...prev,
+                ...cur
+            }), {}));
+}
+
+export { handleCommandResponse, mkCqrsClient, reduceBoolean, reduceObject };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@leancodepl/rx-cqrs-client",
-  "version": "8.5.0",
+  "version": "8.5.1",
   "license": "Apache-2.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",
     "rxjs": ">=7.0.0"
   },
   "devDependencies": {
@@ -38,11 +38,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,4 @@
+export { handleCommandResponse } from "./lib/handleCommandResponse";
+export { mkCqrsClient } from "./lib/mkCqrsClient";
+export { reduceBoolean } from "./lib/reduceBoolean";
+export { reduceObject } from "./lib/reduceObject";

package/src/lib/authGuard.d.ts

@@ -0,0 +1,3 @@
+import { MonoTypeOperatorFunction } from "rxjs";
+import { TokenProvider } from "@leancodepl/cqrs-client-base";
+export default function authGuard<T>(tokenProvider: TokenProvider): MonoTypeOperatorFunction<T>;

package/src/lib/handleCommandResponse.d.ts

@@ -0,0 +1,22 @@
+import { OperatorFunction } from "rxjs";
+import type { ReducerDescription, ValidationErrorsHandler } from "@leancodepl/validation";
+/**
+ * Handles command responses with RxJS operators for validation error processing.
+ *
+ * Creates an operator that processes validation error handlers and transforms them
+ * into the desired result type using a reducer pattern.
+ *
+ * @param handlerFunc - Function that processes validation error handlers
+ * @returns RxJS operator function for handling command responses
+ * @example
+ * ```typescript
+ * import { handleCommandResponse } from '@leancodepl/rx-cqrs-client';
+ *
+ * const handler = handleCommandResponse((handle) =>
+ *   handle('success', () => 'Success!')
+ *     .handle('failure', () => 'Failed!')
+ *     .check()
+ * );
+ * ```
+ */
+export declare function handleCommandResponse<TErrorCodes extends Record<string, number>, THandlerResult>(handlerFunc: (handler: ValidationErrorsHandler<TErrorCodes, never>) => (reducer: ReducerDescription<THandlerResult, any>) => any): OperatorFunction<ValidationErrorsHandler<TErrorCodes, never>, THandlerResult>;

package/src/lib/mkCqrsClient.d.ts

@@ -0,0 +1,39 @@
+import { AjaxConfig } from "rxjs/ajax";
+import { CommandResult, TokenProvider } from "@leancodepl/cqrs-client-base";
+/**
+ * Creates RxJS-based CQRS client for reactive command and query operations.
+ *
+ * Provides observable-based methods for CQRS operations with automatic authentication,
+ * retry logic, and error handling.
+ *
+ * @param cqrsEndpoint - Base URL for CQRS API endpoints
+ * @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` observable factories
+ * @example
+ * ```typescript
+ * const client = mkCqrsClient({
+ *   cqrsEndpoint: 'https://api.example.com',
+ *   tokenProvider: { getToken: () => Promise.resolve('token') }
+ * });
+ * ```
+ */
+export declare function mkCqrsClient({ cqrsEndpoint, tokenProvider, ajaxOptions, tokenHeader, }: {
+    cqrsEndpoint: string;
+    tokenProvider?: TokenProvider;
+    ajaxOptions?: Omit<AjaxConfig, "body" | "headers" | "method" | "responseType" | "url">;
+    tokenHeader?: string;
+}): {
+    createQuery<TQuery, TResult>(type: string): (dto: TQuery) => import("rxjs").Observable<TResult>;
+    createOperation<TOperation, TResult>(type: string): (dto: TOperation) => import("rxjs").Observable<TResult>;
+    createCommand<TCommand, TErrorCodes extends {
+        [name: string]: number;
+    }>(type: string, errorCodesMap: TErrorCodes): {
+        (dto: TCommand): import("rxjs").Observable<CommandResult<TErrorCodes>>;
+        handle(dto: TCommand): import("rxjs").Observable<import("@leancodepl/validation").ValidationErrorsHandler<TErrorCodes & {
+            readonly success: -1;
+            readonly failure: -2;
+        }, never>>;
+    };
+};

package/src/lib/reduceBoolean.d.ts

@@ -0,0 +1,19 @@
+import { OperatorFunction } from "rxjs";
+/**
+ * Reduces boolean values in RxJS streams using logical AND operation.
+ *
+ * Creates an operator that combines multiple boolean values into a single result
+ * by applying logical AND. Returns true only if all values are true.
+ *
+ * @returns RxJS operator function that reduces boolean values
+ * @example
+ * ```typescript
+ * import { of } from 'rxjs';
+ * import { reduceBoolean } from '@leancodepl/rx-cqrs-client';
+ *
+ * of(true, true, false).pipe(reduceBoolean()).subscribe(result => {
+ *   console.log(result); // false
+ * });
+ * ```
+ */
+export declare function reduceBoolean(): OperatorFunction<boolean, boolean>;

package/src/lib/reduceObject.d.ts

@@ -0,0 +1,21 @@
+import { OperatorFunction } from "rxjs";
+type UnionToIntersection<T> = (T extends any ? (x: T) => any : never) extends (x: infer R) => any ? R : never;
+/**
+ * Reduces object values in RxJS streams by merging properties.
+ *
+ * Creates an operator that combines multiple objects into a single result
+ * by spreading properties. Later objects override earlier ones.
+ *
+ * @returns RxJS operator function that reduces object values
+ * @example
+ * ```typescript
+ * import { of } from 'rxjs';
+ * import { reduceObject } from '@leancodepl/rx-cqrs-client';
+ *
+ * of({ a: 1 }, { b: 2 }, { a: 3 }).pipe(reduceObject()).subscribe(result => {
+ *   console.log(result); // { a: 3, b: 2 }
+ * });
+ * ```
+ */
+export declare function reduceObject<T>(): OperatorFunction<T, Partial<UnionToIntersection<T>>>;
+export {};