@ballistix.digital/exception-mapper 0.3.0 → 0.4.0

package/CHANGELOG.md

@@ -6,6 +6,17 @@ follows [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## Unreleased
 
+### Changed
+
+- `ValidationExceptionMapper` fills the `args` of a detail from the rule's own
+  constraint values when the decorator sets no `context`: `{ max: 24 }` for
+  `@Max(24)`, `{ pattern, modifiers }` for `@Matches`, `{ values }` for
+  `@IsIn` and `@IsEnum`, and a positional `{ constraints }` for any other rule
+  with values. A rule without values still carries no `args`. The mapper reads
+  the class-validator metadata of a class once per mapped failure.
+- `ExceptionDtoMapper` copies the `type` of an exception into the envelope
+  when the exception carries one.
+
 ## 0.1.0 - 2026-09-07
 
 ### Added

package/README.md

@@ -6,8 +6,8 @@ turns one kind of thrown value into an exception, and the **registry** holds
 the mappers in order. The exception classes, the codes and the envelope live
 in [`@ballistix.digital/exception-types`](../exception-types/README.md).
 
-This file is the consumer guide. [docs/](../docs/index.md) describes how the
-package is built.
+This file is the consumer guide. The pages that describe how the package is
+built live in the [Ballistix wiki](https://github.com/layeredprints/ballistix-okf-wiki/blob/main/general/libraries/exception-mapper/).
 
 ## Install
 
@@ -109,7 +109,27 @@ deadlock or a connection failure gives 500.
 
 `ValidationExceptionMapper` matches the `ValidationException` that
 `convertAndValidate` throws, and gives one detail for each field and rule that
-failed. `GenericExceptionMapper` is the fallback the registry uses when no mapper in
+failed. The `args` of a detail come from the decorator's explicit `context`
+when it sets one, else from the rule's own constraint values, read from the
+class-validator metadata of the validated class. So `@Max(24)` on `months`
+gives `{ inputField: 'months', rule: 'MAX', args: { max: 24 } }` with no
+change to the DTO.
+
+| Rule | args |
+| --- | --- |
+| `min`, `max`, `minLength`, `maxLength`, `arrayMinSize`, `arrayMaxSize`, `minDate`, `maxDate` | `{ min }` or `{ max }` |
+| `isLength`, `isByteLength` | `{ min, max }` |
+| `matches` | `{ pattern, modifiers }`, the source and flags of the RegExp |
+| `isIn`, `isNotIn`, `isEnum` | `{ values }` |
+| `isDivisibleBy` | `{ divisor }` |
+| `contains`, `notContains` | `{ seed }` |
+| `equals`, `notEquals` | `{ comparison }` |
+| any other rule with constraint values | `{ constraints: [...] }`, positional |
+| a rule without constraint values (`isString`, `isNotEmpty`) | no `args` |
+
+The values are JSON-safe: a RegExp becomes its source and flags, a Date its
+ISO string, and a function or class object is left out. An error without a
+`target` keeps the contexts only. `GenericExceptionMapper` is the fallback the registry uses when no mapper in
 the list supports the value, so `map()` never returns `undefined`.
 
 ## Write your HTTP filter
@@ -137,7 +157,7 @@ export class HttpExceptionFilter implements ExceptionFilter {
 The filter stays in the application, so a breakpoint on the raw thrown value
 sits in application code. What the filter logs, and what request context it
 adds, is the decision of the application. See
-[ADR 0002](../docs/decisions/0002-filter-stays-in-the-app.md).
+[ADR 0002](https://github.com/layeredprints/ballistix-okf-wiki/blob/main/general/libraries/exception-mapper/decisions/0002-filter-stays-in-the-app.md).
 
 Register it as the global filter:
 

package/dist/module/exception/mapper/exceptionDto.mapper.js

@@ -17,6 +17,9 @@ let ExceptionDtoMapper = class ExceptionDtoMapper {
             code: exception.code,
             errors: exception.errors,
         };
+        if (exception.type !== undefined) {
+            plain.type = exception.type;
+        }
         try {
             return (0, exception_types_1.convertAndValidate)(exception_types_1.ExceptionDto, plain, true);
         }

package/dist/module/exception/mapper/validationException.mapper.d.ts

@@ -1,6 +1,14 @@
 import { ValidationException, ValidationFailedException } from '@ballistix.digital/exception-types';
 import { ExceptionMapper } from './exceptionMapper.interface';
 export declare class ValidationExceptionMapper implements ExceptionMapper<ValidationException> {
+    private static readonly argsByRuleName;
+    private readonly metadataByClass;
     supports(error: unknown): error is ValidationException;
     map(error: ValidationException): ValidationFailedException;
+    private toDetails;
+    private argsFromMetadata;
+    private metadataOf;
+    private argsFromConstraints;
+    private toJsonValue;
+    private static patternArgs;
 }

package/dist/module/exception/mapper/validationException.mapper.js

@@ -5,27 +5,108 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var ValidationExceptionMapper_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ValidationExceptionMapper = void 0;
 const common_1 = require("@nestjs/common");
+const class_validator_1 = require("class-validator");
 const exception_types_1 = require("@ballistix.digital/exception-types");
-const collectValidationDetails = (error) => {
-    const ownDetails = Object.keys(error.constraints ?? {}).map((ruleName) => ({
-        inputField: error.property,
-        rule: exception_types_1.validationRuleByName[ruleName] ?? exception_types_1.ValidationRuleEnum.UNKNOWN,
-        args: error.contexts?.[ruleName],
-    }));
-    return ownDetails.concat((error.children ?? []).flatMap(collectValidationDetails));
-};
 let ValidationExceptionMapper = class ValidationExceptionMapper {
+    constructor() {
+        this.metadataByClass = new Map();
+    }
+    static { ValidationExceptionMapper_1 = this; }
+    static { this.argsByRuleName = {
+        [class_validator_1.MIN]: ([min]) => ({ min }),
+        [class_validator_1.MAX]: ([max]) => ({ max }),
+        [class_validator_1.MIN_LENGTH]: ([min]) => ({ min }),
+        [class_validator_1.MAX_LENGTH]: ([max]) => ({ max }),
+        [class_validator_1.ARRAY_MIN_SIZE]: ([min]) => ({ min }),
+        [class_validator_1.ARRAY_MAX_SIZE]: ([max]) => ({ max }),
+        [class_validator_1.MIN_DATE]: ([min]) => ({ min }),
+        [class_validator_1.MAX_DATE]: ([max]) => ({ max }),
+        [class_validator_1.IS_LENGTH]: ([min, max]) => ({ min, max }),
+        [class_validator_1.IS_BYTE_LENGTH]: ([min, max]) => ({ min, max }),
+        [class_validator_1.MATCHES]: (constraints) => ValidationExceptionMapper_1.patternArgs(constraints),
+        [class_validator_1.IS_IN]: ([values]) => ({ values }),
+        [class_validator_1.IS_NOT_IN]: ([values]) => ({ values }),
+        [class_validator_1.IS_ENUM]: ([, values]) => ({ values }),
+        [class_validator_1.IS_DIVISIBLE_BY]: ([divisor]) => ({ divisor }),
+        [class_validator_1.CONTAINS]: ([seed]) => ({ seed }),
+        [class_validator_1.NOT_CONTAINS]: ([seed]) => ({ seed }),
+        [class_validator_1.EQUALS]: ([comparison]) => ({ comparison }),
+        [class_validator_1.NOT_EQUALS]: ([comparison]) => ({ comparison }),
+    }; }
     supports(error) {
         return error instanceof exception_types_1.ValidationException;
     }
     map(error) {
-        return new exception_types_1.ValidationFailedException(error.getValidationErrors().flatMap(collectValidationDetails));
+        this.metadataByClass.clear();
+        return new exception_types_1.ValidationFailedException(error.getValidationErrors().flatMap((root) => this.toDetails(root)));
+    }
+    toDetails(error) {
+        const ownDetails = Object.keys(error.constraints ?? {}).map((ruleName) => {
+            const args = error.contexts?.[ruleName] ?? this.argsFromMetadata(error, ruleName);
+            return {
+                inputField: error.property,
+                rule: exception_types_1.validationRuleByName[ruleName] ?? exception_types_1.ValidationRuleEnum.UNKNOWN,
+                ...(args === undefined ? {} : { args }),
+            };
+        });
+        return ownDetails.concat((error.children ?? []).flatMap((child) => this.toDetails(child)));
+    }
+    argsFromMetadata(error, ruleName) {
+        try {
+            const rule = this.metadataOf(error).find((candidate) => candidate.propertyName === error.property && candidate.name === ruleName);
+            const constraints = rule?.constraints ?? [];
+            return constraints.length === 0 ? undefined : this.argsFromConstraints(ruleName, constraints);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    metadataOf(error) {
+        const target = error.target?.constructor;
+        if (typeof target !== 'function') {
+            return [];
+        }
+        const cached = this.metadataByClass.get(target);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const metadata = (0, class_validator_1.getMetadataStorage)().getTargetValidationMetadatas(target, undefined, false, false);
+        this.metadataByClass.set(target, metadata);
+        return metadata;
+    }
+    argsFromConstraints(ruleName, constraints) {
+        const named = ValidationExceptionMapper_1.argsByRuleName[ruleName];
+        const raw = named ? named(constraints) : { constraints };
+        const entries = Object.entries(raw ?? {})
+            .map(([key, value]) => [key, this.toJsonValue(value)])
+            .filter(([, value]) => value !== undefined);
+        const empty = entries.every(([, value]) => Array.isArray(value) && value.length === 0);
+        return empty ? undefined : Object.fromEntries(entries);
+    }
+    toJsonValue(value) {
+        if (value === null || ['string', 'number', 'boolean'].includes(typeof value)) {
+            return value;
+        }
+        if (value instanceof RegExp) {
+            return ValidationExceptionMapper_1.patternArgs([value]);
+        }
+        if (value instanceof Date) {
+            return value.toISOString();
+        }
+        if (Array.isArray(value)) {
+            return value.map((entry) => this.toJsonValue(entry)).filter((entry) => entry !== undefined);
+        }
+        return undefined;
+    }
+    static patternArgs([regex, modifiers]) {
+        return regex instanceof RegExp ? { pattern: regex.source, modifiers: regex.flags } : { pattern: regex, modifiers };
     }
 };
 exports.ValidationExceptionMapper = ValidationExceptionMapper;
-exports.ValidationExceptionMapper = ValidationExceptionMapper = __decorate([
+exports.ValidationExceptionMapper = ValidationExceptionMapper = ValidationExceptionMapper_1 = __decorate([
     (0, common_1.Injectable)()
 ], ValidationExceptionMapper);

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@ballistix.digital/exception-mapper",
-	"version": "0.3.0",
+	"version": "0.4.0",
 	"description": "A NestJS module that maps any thrown value to a coded BaseException and to the ExceptionDto envelope, for HTTP filters and task processors.",
 	"license": "MIT",
 	"repository": {
@@ -30,7 +30,7 @@
 		"build": "rm -rf dist && tsc -p tsconfig.build.json"
 	},
 	"peerDependencies": {
-		"@ballistix.digital/exception-types": "^0.3.0",
+		"@ballistix.digital/exception-types": "^0.4.0",
 		"@nestjs/common": "^11 || ^12",
 		"class-validator": "^0.15.1",
 		"reflect-metadata": "^0.2.2",