@lenne.tech/nest-server 11.4.1 → 11.4.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lenne.tech/nest-server",
-  "version": "11.4.1",
+  "version": "11.4.3",
   "description": "Modern, fast, powerful Node.js web framework in TypeScript based on Nest with a GraphQL API and a connection to MongoDB (or other databases).",
   "keywords": [
     "node",

package/src/core/common/pipes/map-and-validate.pipe.ts

@@ -1,31 +1,87 @@
 import { ArgumentMetadata, BadRequestException, Injectable, PipeTransform } from '@nestjs/common';
 import { plainToInstance } from 'class-transformer';
 import { validate, ValidationError } from 'class-validator';
+import { inspect } from 'util';
 
 import { isBasicType } from '../helpers/input.helper';
 
+// Debug mode can be enabled via environment variable: DEBUG_VALIDATION=true
+const DEBUG_VALIDATION = process.env.DEBUG_VALIDATION === 'true';
+
 @Injectable()
 export class MapAndValidatePipe implements PipeTransform {
   async transform(value: any, metadata: ArgumentMetadata) {
     const { metatype } = metadata;
 
+    if (DEBUG_VALIDATION) {
+      console.debug('\n=== MapAndValidatePipe Debug ===');
+      console.debug('Metadata:', {
+        data: metadata.data,
+        metatype: metatype?.name,
+        type: metadata.type,
+      });
+      console.debug('Input value type:', typeof value);
+      console.debug('Input value:', inspect(value, { colors: true, depth: 3 }));
+    }
+
     if (!value || typeof value !== 'object' || !metatype || isBasicType(metatype)) {
+      if (DEBUG_VALIDATION) {
+        console.debug('Skipping validation - basic type or no metatype');
+        console.debug('=== End Debug ===\n');
+      }
       return value;
     }
 
     // Convert to metatype
     if (!(value instanceof metatype)) {
       if ((metatype as any)?.map) {
+        if (DEBUG_VALIDATION) {
+          console.debug('Using custom map function');
+        }
         value = (metatype as any)?.map(value);
       } else {
+        if (DEBUG_VALIDATION) {
+          console.debug('Using plainToInstance to transform to:', metatype.name);
+        }
         value = plainToInstance(metatype, value);
+        if (DEBUG_VALIDATION) {
+          console.debug('Transformed value:', inspect(value, { colors: true, depth: 3 }));
+          console.debug('Transformed value instance of:', value?.constructor?.name);
+        }
       }
     }
 
     // Validate
+    if (DEBUG_VALIDATION) {
+      console.debug('Starting validation...');
+    }
     const errors = await validate(value, { forbidUnknownValues: false });
+
     if (errors.length > 0) {
+      if (DEBUG_VALIDATION) {
+        console.debug('Validation errors found:', errors.length);
+        console.debug('Raw validation errors:');
+        errors.forEach((err, index) => {
+          console.debug(`\nError ${index + 1}:`);
+          console.debug('  Property:', err.property);
+          console.debug('  Value:', err.value);
+          console.debug('  Constraints:', err.constraints);
+          console.debug('  Children:', err.children?.length || 0);
+          if (err.children && err.children.length > 0) {
+            console.debug('  Children details:');
+            err.children.forEach((child, childIndex) => {
+              console.debug(`    Child ${childIndex + 1}:`);
+              console.debug('      Property:', child.property);
+              console.debug('      Value:', child.value);
+              console.debug('      Constraints:', child.constraints);
+              console.debug('      Has children:', (child.children?.length || 0) > 0);
+            });
+          }
+        });
+      }
+
       const result = {};
+      const errorSummary: string[] = [];
 
       const processErrors = (errorList: ValidationError[], parentKey = '') => {
         errorList.forEach((e) => {
@@ -35,12 +91,48 @@ export class MapAndValidatePipe implements PipeTransform {
             processErrors(e.children, key);
           } else {
             result[key] = e.constraints;
+            // Build error summary without exposing values
+            if (e.constraints) {
+              const constraintTypes = Object.keys(e.constraints).join(', ');
+              errorSummary.push(`${key} (${constraintTypes})`);
+            }
           }
         });
       };
 
       processErrors(errors);
-      throw new BadRequestException(result);
+
+      if (DEBUG_VALIDATION) {
+        console.debug('\nProcessed validation result:');
+        console.debug(inspect(result, { colors: true, depth: 5 }));
+        console.debug('Result is empty:', Object.keys(result).length === 0);
+        console.debug('Error summary:', errorSummary);
+        console.debug('=== End Debug ===\n');
+      }
+
+      // Create meaningful error message without exposing sensitive values
+      let errorMessage = 'Validation failed';
+      if (errorSummary.length > 0) {
+        const fieldCount = errorSummary.length;
+        const fieldWord = fieldCount === 1 ? 'field' : 'fields';
+        errorMessage = `Validation failed for ${fieldCount} ${fieldWord}: ${errorSummary.join('; ')}`;
+      } else if (errors.length > 0) {
+        // Handle case where there are validation errors but no constraints (nested errors only)
+        const topLevelProperties = errors.map((e) => e.property).join(', ');
+        errorMessage = `Validation failed for properties: ${topLevelProperties} (nested validation errors)`;
+      }
+
+      // Throw with message and validation errors (backward compatible structure)
+      // Add message property to result object for better error messages
+      throw new BadRequestException({
+        message: errorMessage,
+        ...result,
+      });
+    }
+
+    if (DEBUG_VALIDATION) {
+      console.debug('Validation successful - no errors');
+      console.debug('=== End Debug ===\n');
     }
 
     return value;