@leancodepl/validation 8.5.0 → 8.6.0

package/README.md

@@ -0,0 +1,106 @@
+# @leancodepl/validation
+
+TypeScript library for handling validation errors in CQRS command responses with type-safe error code mapping.
+
+## Installation
+
+```bash
+npm install @leancodepl/validation
+# or
+yarn add @leancodepl/validation
+```
+
+## API
+
+### `handleValidationErrors(validationErrors, errorCodesMap, validationResults)`
+
+Creates a validation error handler that processes errors with type-safe error code mapping.
+
+**Parameters:**
+
+- `validationErrors: ValidationError<TAllErrors>[]` - Array of validation errors to process
+- `errorCodesMap: TAllErrors` - Mapping of error names to numeric codes
+- `validationResults?: TInResult[]` - Optional array of previous handler results
+
+**Returns:** Handler with `handle`, `handleAll`, and `check` methods
+
+### `handleResponse(response, errorCodesMap)`
+
+Handles CQRS command responses and transforms them into validation error handlers.
+
+**Parameters:**
+
+- `response: ApiResponse<CommandResult<TErrors>>` - API response containing command result
+- `errorCodesMap: TErrors` - Mapping of error names to numeric codes
+
+**Returns:** Validation error handler with success/failure support
+
+## Usage Examples
+
+### Basic Error Handling
+
+```typescript
+import { handleValidationErrors } from "@leancodepl/validation"
+
+const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const
+const errors = [
+    { ErrorCode: 1, ErrorMessage: "Email exists", PropertyName: "Email", AttemptedValue: "user@example.com" },
+]
+
+handleValidationErrors(errors, errorCodes)
+    .handle("EmailExists", () => console.log("Email already registered"))
+    .handle("InvalidEmail", () => console.log("Invalid email format"))
+    .check()
+```
+
+### Command Response Handling
+
+```typescript
+import { handleResponse } from "@leancodepl/validation"
+
+const errorCodes = { UserNotFound: 1 } as const
+const response = await fetch("/api/users/123", { method: "PUT", body: JSON.stringify({ name: "John" }) })
+
+handleResponse(response, errorCodes)
+    .handle("success", () => console.log("User updated"))
+    .handle("UserNotFound", () => console.log("User not found"))
+    .handle("failure", () => console.log("Request failed"))
+    .check()
+```
+
+### Multiple Error Handling
+
+```typescript
+import { handleValidationErrors } from "@leancodepl/validation"
+
+const errorCodes = { Required: 1, Invalid: 2 } as const
+const errors = [
+    { ErrorCode: 1, PropertyName: "email", ErrorMessage: "Email required" },
+    { ErrorCode: 2, PropertyName: "name", ErrorMessage: "Invalid name" },
+]
+
+handleValidationErrors(errors, errorCodes)
+    .handleAll(["Required", "Invalid"], errorGroups => {
+        errorGroups.forEach(({ errors }) => {
+            errors.forEach(error => console.log(`${error.PropertyName}: ${error.ErrorMessage}`))
+        })
+    })
+    .check()
+```
+
+### Success/Failure Result Processing
+
+```typescript
+import { handleResponse } from "@leancodepl/validation"
+
+const errorCodes = { InvalidData: 1 } as const
+const response = await fetch("/api/data")
+
+const isSuccess = handleResponse(response, errorCodes)
+    .handle("success", () => true)
+    .handle(["InvalidData", "failure"], () => false)
+    .check({
+        reducer: (prev, current) => prev && current,
+        initialValue: true,
+    })
+```

package/index.cjs.default.js

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

package/index.cjs.js

@@ -0,0 +1,128 @@
+'use strict';
+
+/**
+ * Creates a validation error handler that processes errors with type-safe error code mapping.
+ * 
+ * @template TAllErrors - Error codes map type extending Record<string, number>
+ * @template TInResult - Type of results accumulated from previous handlers
+ * @param validationErrors - Array of validation errors to process
+ * @param errorCodesMap - Mapping of error names to numeric codes
+ * @param validationResults - Optional array of previous handler results
+ * @returns Handler with handle, handleAll, and check methods
+ * @example
+ * ```typescript
+ * const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const;
+ * const errors = [{ ErrorCode: 1, ErrorMessage: 'Email exists', PropertyName: 'Email', AttemptedValue: 'test@example.com' }];
+ * 
+ * handleValidationErrors(errors, errorCodes)
+ *   .handle('EmailExists', () => console.warn('Email already registered'))
+ *   .handle('InvalidEmail', () => console.warn('Invalid email format'))
+ *   .check();
+ * ```
+ */ function handleValidationErrors(validationErrors, errorCodesMap, validationResults = []) {
+    const handle = (validationErrorsToHandle, handler)=>{
+        let result = undefined;
+        for (const validationErrorToHandle of Array.isArray(validationErrorsToHandle) ? validationErrorsToHandle : [
+            validationErrorsToHandle
+        ]){
+            const ve = validationErrors.find((ve)=>ve.ErrorCode === errorCodesMap[validationErrorToHandle]);
+            if (ve) {
+                result = handler(validationErrorToHandle, ve);
+                break;
+            }
+        }
+        let nextResult = validationResults;
+        if (result !== undefined) {
+            nextResult = [
+                ...nextResult,
+                result
+            ];
+        }
+        return handleValidationErrors(validationErrors, errorCodesMap, nextResult);
+    };
+    const handleAll = (_validationErrorsToHandle, handler)=>{
+        let result = undefined;
+        const validationErrorsToHandle = Array.isArray(_validationErrorsToHandle) ? _validationErrorsToHandle : [
+            _validationErrorsToHandle
+        ];
+        const foundErrors = validationErrorsToHandle.reduce((prev, cur)=>{
+            const ves = validationErrors.filter((ve)=>ve.ErrorCode === errorCodesMap[cur]);
+            if (ves.length === 0) {
+                return prev;
+            }
+            return [
+                ...prev,
+                {
+                    errorName: cur,
+                    errors: ves
+                }
+            ];
+        }, []);
+        if (foundErrors.length > 0) {
+            result = handler(foundErrors);
+        }
+        let nextResult = validationResults;
+        if (result !== undefined) {
+            nextResult = [
+                ...nextResult,
+                result
+            ];
+        }
+        return handleValidationErrors(validationErrors, errorCodesMap, nextResult);
+    };
+    return {
+        handle,
+        handleAll,
+        check: (reducer)=>{
+            if (reducer) {
+                return validationResults.reduce(reducer.reducer, reducer.initialValue);
+            }
+            return;
+        }
+    };
+}
+
+/**
+ * Handles CQRS command responses and transforms them into validation error handlers.
+ * 
+ * @template TErrors - Error codes map type extending Record<string, number>
+ * @param response - API response containing command result
+ * @param errorCodesMap - Mapping of error names to numeric codes
+ * @returns Validation error handler with success/failure support
+ * @example
+ * ```typescript
+ * const errorCodes = { UserNotFound: 1 } as const;
+ * const response = await commandClient.execute(createUserCommand);
+ * 
+ * handleResponse(response, errorCodes)
+ *   .handle('success', () => console.log('User created'))
+ *   .handle('failure', () => console.log('Network error'))
+ *   .handle('UserNotFound', () => console.log('User not found'))
+ *   .check();
+ * ```
+ */ function handleResponse(response, errorCodesMap) {
+    const newErrorCodesMap = {
+        ...errorCodesMap,
+        success: -1,
+        failure: -2
+    };
+    const validationErrors = response.isSuccess ? response.result.WasSuccessful ? [
+        {
+            AttemptedValue: "",
+            ErrorMessage: "",
+            PropertyName: "",
+            ErrorCode: -1
+        }
+    ] : response.result.ValidationErrors : [
+        {
+            AttemptedValue: "",
+            ErrorMessage: "",
+            PropertyName: "",
+            ErrorCode: -2
+        }
+    ];
+    return handleValidationErrors(validationErrors, newErrorCodesMap);
+}
+
+exports.handleResponse = handleResponse;
+exports.handleValidationErrors = handleValidationErrors;

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,125 @@
+/**
+ * Creates a validation error handler that processes errors with type-safe error code mapping.
+ * 
+ * @template TAllErrors - Error codes map type extending Record<string, number>
+ * @template TInResult - Type of results accumulated from previous handlers
+ * @param validationErrors - Array of validation errors to process
+ * @param errorCodesMap - Mapping of error names to numeric codes
+ * @param validationResults - Optional array of previous handler results
+ * @returns Handler with handle, handleAll, and check methods
+ * @example
+ * ```typescript
+ * const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const;
+ * const errors = [{ ErrorCode: 1, ErrorMessage: 'Email exists', PropertyName: 'Email', AttemptedValue: 'test@example.com' }];
+ * 
+ * handleValidationErrors(errors, errorCodes)
+ *   .handle('EmailExists', () => console.warn('Email already registered'))
+ *   .handle('InvalidEmail', () => console.warn('Invalid email format'))
+ *   .check();
+ * ```
+ */ function handleValidationErrors(validationErrors, errorCodesMap, validationResults = []) {
+    const handle = (validationErrorsToHandle, handler)=>{
+        let result = undefined;
+        for (const validationErrorToHandle of Array.isArray(validationErrorsToHandle) ? validationErrorsToHandle : [
+            validationErrorsToHandle
+        ]){
+            const ve = validationErrors.find((ve)=>ve.ErrorCode === errorCodesMap[validationErrorToHandle]);
+            if (ve) {
+                result = handler(validationErrorToHandle, ve);
+                break;
+            }
+        }
+        let nextResult = validationResults;
+        if (result !== undefined) {
+            nextResult = [
+                ...nextResult,
+                result
+            ];
+        }
+        return handleValidationErrors(validationErrors, errorCodesMap, nextResult);
+    };
+    const handleAll = (_validationErrorsToHandle, handler)=>{
+        let result = undefined;
+        const validationErrorsToHandle = Array.isArray(_validationErrorsToHandle) ? _validationErrorsToHandle : [
+            _validationErrorsToHandle
+        ];
+        const foundErrors = validationErrorsToHandle.reduce((prev, cur)=>{
+            const ves = validationErrors.filter((ve)=>ve.ErrorCode === errorCodesMap[cur]);
+            if (ves.length === 0) {
+                return prev;
+            }
+            return [
+                ...prev,
+                {
+                    errorName: cur,
+                    errors: ves
+                }
+            ];
+        }, []);
+        if (foundErrors.length > 0) {
+            result = handler(foundErrors);
+        }
+        let nextResult = validationResults;
+        if (result !== undefined) {
+            nextResult = [
+                ...nextResult,
+                result
+            ];
+        }
+        return handleValidationErrors(validationErrors, errorCodesMap, nextResult);
+    };
+    return {
+        handle,
+        handleAll,
+        check: (reducer)=>{
+            if (reducer) {
+                return validationResults.reduce(reducer.reducer, reducer.initialValue);
+            }
+            return;
+        }
+    };
+}
+
+/**
+ * Handles CQRS command responses and transforms them into validation error handlers.
+ * 
+ * @template TErrors - Error codes map type extending Record<string, number>
+ * @param response - API response containing command result
+ * @param errorCodesMap - Mapping of error names to numeric codes
+ * @returns Validation error handler with success/failure support
+ * @example
+ * ```typescript
+ * const errorCodes = { UserNotFound: 1 } as const;
+ * const response = await commandClient.execute(createUserCommand);
+ * 
+ * handleResponse(response, errorCodes)
+ *   .handle('success', () => console.log('User created'))
+ *   .handle('failure', () => console.log('Network error'))
+ *   .handle('UserNotFound', () => console.log('User not found'))
+ *   .check();
+ * ```
+ */ function handleResponse(response, errorCodesMap) {
+    const newErrorCodesMap = {
+        ...errorCodesMap,
+        success: -1,
+        failure: -2
+    };
+    const validationErrors = response.isSuccess ? response.result.WasSuccessful ? [
+        {
+            AttemptedValue: "",
+            ErrorMessage: "",
+            PropertyName: "",
+            ErrorCode: -1
+        }
+    ] : response.result.ValidationErrors : [
+        {
+            AttemptedValue: "",
+            ErrorMessage: "",
+            PropertyName: "",
+            ErrorCode: -2
+        }
+    ];
+    return handleValidationErrors(validationErrors, newErrorCodesMap);
+}
+
+export { handleResponse, handleValidationErrors };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "@leancodepl/validation",
-  "version": "8.5.0",
+  "version": "8.6.0",
   "license": "Apache-2.0",
   "dependencies": {
-    "@leancodepl/cqrs-client-base": "8.5.0"
+    "@leancodepl/cqrs-client-base": "8.6.0"
   },
   "devDependencies": {
     "sinon": "15.2.0"
@@ -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,2 @@
+export * from "./lib/handleResponse";
+export * from "./lib/handleValidationErrors";

package/src/lib/handleResponse.d.ts

@@ -0,0 +1,28 @@
+import { ApiResponse, CommandResult } from "@leancodepl/cqrs-client-base";
+export type SuccessOrFailureMarker = {
+    success: -1;
+    failure: -2;
+};
+/**
+ * Handles CQRS command responses and transforms them into validation error handlers.
+ *
+ * @template TErrors - Error codes map type extending Record<string, number>
+ * @param response - API response containing command result
+ * @param errorCodesMap - Mapping of error names to numeric codes
+ * @returns Validation error handler with success/failure support
+ * @example
+ * ```typescript
+ * const errorCodes = { UserNotFound: 1 } as const;
+ * const response = await commandClient.execute(createUserCommand);
+ *
+ * handleResponse(response, errorCodes)
+ *   .handle('success', () => console.log('User created'))
+ *   .handle('failure', () => console.log('Network error'))
+ *   .handle('UserNotFound', () => console.log('User not found'))
+ *   .check();
+ * ```
+ */
+export declare function handleResponse<TErrors extends Record<string, number>>(response: ApiResponse<CommandResult<TErrors>>, errorCodesMap: TErrors): import("./handleValidationErrors").ValidationErrorsHandler<TErrors & {
+    readonly success: -1;
+    readonly failure: -2;
+}, never>;

package/src/lib/handleValidationErrors.d.ts

@@ -0,0 +1,43 @@
+import { ValidationError } from "@leancodepl/cqrs-client-base";
+export type ReducerDescription<THandlerResult, TReturnValue = THandlerResult> = {
+    reducer: (prev: TReturnValue, cur: THandlerResult) => TReturnValue;
+    initialValue: TReturnValue;
+};
+export type SpecificValidationError<TErrors extends Record<string, number>, TError extends keyof TErrors> = ValidationError<Record<TError, TErrors[TError]>>;
+export type ValidationErrorHandlerFunc<TErrorsToHandle extends Record<string, number>, THandledErrors extends keyof TErrorsToHandle, TResult> = (errorName: THandledErrors, error: SpecificValidationError<TErrorsToHandle, THandledErrors>) => TResult;
+export type ValidationErrorsHandleFunc<TErrorsToHandle extends Record<string, number>, TInResult> = {
+    <THandledErrors extends keyof TErrorsToHandle, TResult>(validationErrors: THandledErrors | THandledErrors[], handler: ValidationErrorHandlerFunc<TErrorsToHandle, THandledErrors, TResult>): ValidationErrorsHandler<Omit<TErrorsToHandle, THandledErrors>, TInResult | TResult>;
+};
+export type ValidationErrorHandlerAllFunc<TErrorsToHandle extends Record<string, number>, THandledErrors extends keyof TErrorsToHandle, TResult> = (errors: {
+    errorName: THandledErrors;
+    errors: SpecificValidationError<TErrorsToHandle, THandledErrors>[];
+}[]) => TResult;
+export type ValidationErrorsHandleAllFunc<TErrorsToHandle extends Record<string, number>, TInResult> = {
+    <THandledErrors extends keyof TErrorsToHandle, TResult>(validationErrors: THandledErrors | THandledErrors[], handler: ValidationErrorHandlerAllFunc<TErrorsToHandle, THandledErrors, TResult>): ValidationErrorsHandler<Omit<TErrorsToHandle, THandledErrors>, TInResult | TResult>;
+};
+export interface ValidationErrorsHandler<TRemainingErrors extends Record<string, number>, TResult> {
+    handle: ValidationErrorsHandleFunc<TRemainingErrors, TResult>;
+    handleAll: ValidationErrorsHandleAllFunc<TRemainingErrors, TResult>;
+    check: object extends TRemainingErrors ? <TReturnValue = void>(reducer?: ReducerDescription<TResult, TReturnValue>) => TReturnValue : unknown;
+}
+/**
+ * Creates a validation error handler that processes errors with type-safe error code mapping.
+ *
+ * @template TAllErrors - Error codes map type extending Record<string, number>
+ * @template TInResult - Type of results accumulated from previous handlers
+ * @param validationErrors - Array of validation errors to process
+ * @param errorCodesMap - Mapping of error names to numeric codes
+ * @param validationResults - Optional array of previous handler results
+ * @returns Handler with handle, handleAll, and check methods
+ * @example
+ * ```typescript
+ * const errorCodes = { EmailExists: 1, InvalidEmail: 2 } as const;
+ * const errors = [{ ErrorCode: 1, ErrorMessage: 'Email exists', PropertyName: 'Email', AttemptedValue: 'test@example.com' }];
+ *
+ * handleValidationErrors(errors, errorCodes)
+ *   .handle('EmailExists', () => console.warn('Email already registered'))
+ *   .handle('InvalidEmail', () => console.warn('Invalid email format'))
+ *   .check();
+ * ```
+ */
+export declare function handleValidationErrors<TAllErrors extends Record<string, number>, TInResult = never>(validationErrors: ValidationError<TAllErrors>[], errorCodesMap: TAllErrors, validationResults?: TInResult[]): ValidationErrorsHandler<TAllErrors, TInResult>;