perf: fix issues detected in pipeline

Author: matthew2564

package.json

@@ -20,6 +20,7 @@
     "typescript"
   ],
   "scripts": {
+    "benchmark": "ts-node --transpile-only test/benchmark.ts",
     "build": "npm run build:cjs",
     "build:clean": "rimraf build",
     "build:es2015": "tsc --project tsconfig.prod.esm2015.json",

src/decorator/object/IsNotEmptyObject.ts

@@ -14,8 +14,8 @@ export function isNotEmptyObject(value: unknown, options?: { nullable?: boolean
   }
 
   if (options?.nullable === false) {
-    for (const key in value as object) {
-      if ((value as object).hasOwnProperty(key)) {
+    for (const key in value ) {
+      if ((value ).hasOwnProperty(key)) {
         const propertyValue = (value as any)[key];
         if (propertyValue !== null && propertyValue !== undefined) {
           return true;

src/metadata/MetadataStorage.ts

@@ -148,7 +148,8 @@ export class MetadataStorage {
         }
       }
 
-      const customOnly = defined.length === 0 && nested.length === 0 && conditional.length === 0 && !hasPromiseValidation;
+      const customOnly =
+        defined.length === 0 && nested.length === 0 && conditional.length === 0 && !hasPromiseValidation;
       result[propertyName] = { defined, custom, nested, conditional, all, hasPromiseValidation, customOnly };
     }
 
@@ -159,13 +160,7 @@ export class MetadataStorage {
   /**
    * Gets all validation metadatas for the given object with the given groups.
    */
-  buildCacheKey(
-    target: Function,
-    schema: string,
-    always: boolean,
-    strictGroups: boolean,
-    groups?: string[]
-  ): string {
+  buildCacheKey(target: Function, schema: string, always: boolean, strictGroups: boolean, groups?: string[]): string {
     const targetId = (target as any).__cv_id ?? ((target as any).__cv_id = ++MetadataStorage._nextId);
     const groupKey = groups?.length ? groups.slice().sort().join(',') : '';
     return `${targetId}|${schema || ''}|${always ? 1 : 0}|${strictGroups ? 1 : 0}|${groupKey}`;

src/metadata/ValidationMetadata.ts

@@ -85,7 +85,6 @@ export class ValidationMetadata {
    */
   inlineDefaultMessage?: (args?: any) => string;
 
-
   // -------------------------------------------------------------------------
   // Constructor
   // -------------------------------------------------------------------------

src/validation/ValidationExecutor.ts

@@ -71,7 +71,9 @@ export class ValidationExecutor {
     this.strictGroups = (validatorOptions && validatorOptions.strictGroups) || false;
     this.always = (validatorOptions && validatorOptions.always) || false;
     this.forbidUnknownValues =
-      !validatorOptions || validatorOptions.forbidUnknownValues === undefined || validatorOptions.forbidUnknownValues !== false;
+      !validatorOptions ||
+      validatorOptions.forbidUnknownValues === undefined ||
+      validatorOptions.forbidUnknownValues !== false;
     this.whitelist = (validatorOptions && validatorOptions.whitelist) || false;
     this.forbidNonWhitelisted = (validatorOptions && validatorOptions.forbidNonWhitelisted) || false;
   }
@@ -95,7 +97,13 @@ export class ValidationExecutor {
       );
     }
 
-    const cacheKey = this.metadataStorage.buildCacheKey(object.constructor, targetSchema, this.always, this.strictGroups, this.groups);
+    const cacheKey = this.metadataStorage.buildCacheKey(
+      object.constructor,
+      targetSchema,
+      this.always,
+      this.strictGroups,
+      this.groups
+    );
     const targetMetadatas = this.metadataStorage.getTargetValidationMetadatas(
       object.constructor,
       targetSchema,
@@ -216,19 +224,25 @@ export class ValidationExecutor {
       for (const metadata of metadatas) {
         validationArguments.constraints = metadata.constraints;
 
-        if (metadata.inlineValidate && (!metadata.each || !(Array.isArray(value) || value instanceof Set || value instanceof Map))) {
+        if (
+          metadata.inlineValidate &&
+          (!metadata.each || !(Array.isArray(value) || value instanceof Set || value instanceof Map))
+        ) {
           if (this.stopAtFirstError && validationError && hasConstraints(validationError.constraints)) continue;
 
           const validatedValue = metadata.inlineValidate(value, validationArguments);
           if (validatedValue !== true && validatedValue !== false) {
-            const promise = (validatedValue as Promise<boolean>).then(isValid => {
+            const promise = (validatedValue ).then(isValid => {
               if (!isValid) {
                 if (!validationError) validationError = this.generateValidationError(object, value, propertyName);
                 const [type, message] = this.createValidationErrorInline(metadata, validationArguments);
                 validationError.constraints[type] = message;
                 if (metadata.context) {
                   if (!validationError.contexts) validationError.contexts = {};
-                  validationError.contexts[type] = Object.assign(validationError.contexts[type] || {}, metadata.context);
+                  validationError.contexts[type] = Object.assign(
+                    validationError.contexts[type] || {},
+                    metadata.context
+                  );
                 }
               }
             });
@@ -255,7 +269,11 @@ export class ValidationExecutor {
 
       if (validationError) {
         const hasAsyncPending = this.awaitingPromises.length > asyncCountBefore;
-        if (hasConstraints(validationError.constraints) || (validationError.children && validationError.children.length > 0) || hasAsyncPending) {
+        if (
+          hasConstraints(validationError.constraints) ||
+          (validationError.children && validationError.children.length > 0) ||
+          hasAsyncPending
+        ) {
           validationErrors.push(validationError);
         }
       } else if (this.awaitingPromises.length > asyncCountBefore) {
@@ -379,7 +397,10 @@ export class ValidationExecutor {
       validationArguments.constraints = metadata.constraints;
 
       // Fast path: inline validators (all built-in decorators) bypass constraint metadata dispatch
-      if (metadata.inlineValidate && (!metadata.each || !(Array.isArray(value) || value instanceof Set || value instanceof Map))) {
+      if (
+        metadata.inlineValidate &&
+        (!metadata.each || !(Array.isArray(value) || value instanceof Set || value instanceof Map))
+      ) {
         if (this.stopAtFirstError) {
           const error = getError();
           if (hasConstraints(error.constraints)) continue;
@@ -388,7 +409,7 @@ export class ValidationExecutor {
         const validatedValue = metadata.inlineValidate(value, validationArguments);
         if (validatedValue !== true && validatedValue !== false) {
           // Async result (Promise)
-          const promise = (validatedValue as Promise<boolean>).then(isValid => {
+          const promise = (validatedValue ).then(isValid => {
             if (!isValid) {
               const error = getError();
               const [type, message] = this.createValidationErrorInline(metadata, validationArguments);
@@ -416,7 +437,8 @@ export class ValidationExecutor {
         continue;
       }
 
-      const constraintMetadatas = metadata.resolvedConstraints ??
+      const constraintMetadatas =
+        metadata.resolvedConstraints ??
         (metadata.resolvedConstraints = this.metadataStorage.getTargetValidatorConstraints(metadata.constraintCls));
       for (const customConstraintMetadata of constraintMetadatas) {
         if (customConstraintMetadata.async && this.ignoreAsyncValidations) continue;
@@ -508,10 +530,7 @@ export class ValidationExecutor {
     for (const metadata of metadatas) {
       if (metadata.type !== ValidationTypes.NESTED_VALIDATION && metadata.type !== ValidationTypes.PROMISE_VALIDATION) {
         continue;
-      } else if (
-        this.stopAtFirstError &&
-        Object.keys(error.constraints || {}).length > 0
-      ) {
+      } else if (this.stopAtFirstError && Object.keys(error.constraints || {}).length > 0) {
         continue;
       }
 
@@ -549,9 +568,12 @@ export class ValidationExecutor {
             // Inline validators: use metadata.name directly
             type = metadata.name || metadata.type;
           } else {
-            const customConstraints = metadata.resolvedConstraints ??
-              (metadata.resolvedConstraints = this.metadataStorage.getTargetValidatorConstraints(metadata.constraintCls));
-            type = (customConstraints[0] && customConstraints[0].name) ? customConstraints[0].name : metadata.type;
+            const customConstraints =
+              metadata.resolvedConstraints ??
+              (metadata.resolvedConstraints = this.metadataStorage.getTargetValidatorConstraints(
+                metadata.constraintCls
+              ));
+            type = customConstraints[0] && customConstraints[0].name ? customConstraints[0].name : metadata.type;
           }
         } else {
           type = metadata.type;

benchmark.ts test/benchmark.tsbenchmark.ts renamed to test/benchmark.ts

@@ -1,5 +1,21 @@
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-nocheck
 import 'reflect-metadata';
-import { validate, validateSync, IsString, IsInt, IsBoolean, IsEmail, IsOptional, MinLength, MaxLength, Min, Max, IsNotEmpty, ValidateNested } from './src';
+import {
+  validate,
+  validateSync,
+  IsString,
+  IsInt,
+  IsBoolean,
+  IsEmail,
+  IsOptional,
+  MinLength,
+  MaxLength,
+  Min,
+  Max,
+  IsNotEmpty,
+  ValidateNested,
+} from '../src';
 
 // --- Classes with inheritance and nesting ---
 class BaseEntity {

test/functional/custom-decorators.spec.ts

@@ -274,3 +274,61 @@ describe('decorator with symbol constraint', () => {
     });
   });
 });
+
+describe('inline custom decorator fast-path behavior', () => {
+  function InlineFailing(name: string, validationOptions?: ValidationOptions) {
+    return function (object: object, propertyName: string): void {
+      registerDecorator({
+        target: object.constructor,
+        propertyName,
+        name,
+        options: validationOptions,
+        validator: {
+          validate(): boolean {
+            return false;
+          },
+        },
+      });
+    };
+  }
+
+  function InlineAsyncPassing(name: string, validationOptions?: ValidationOptions) {
+    return function (object: object, propertyName: string): void {
+      registerDecorator({
+        target: object.constructor,
+        propertyName,
+        name,
+        options: validationOptions,
+        validator: {
+          validate(): Promise<boolean> {
+            return Promise.resolve(true);
+          },
+        },
+      });
+    };
+  }
+
+  it('should stop after first inline custom validator failure when stopAtFirstError is enabled', () => {
+    class StopAtFirstErrorModel {
+      @InlineFailing('firstError', { message: 'first message' })
+      @InlineFailing('secondError', { message: 'second message' })
+      value: string = 'x';
+    }
+
+    return validator.validate(new StopAtFirstErrorModel(), { stopAtFirstError: true }).then(errors => {
+      expect(errors.length).toEqual(1);
+      expect(Object.keys(errors[0].constraints).length).toEqual(1);
+    });
+  });
+
+  it('should not create a visible error when inline async validator resolves true', () => {
+    class AsyncPassModel {
+      @InlineAsyncPassing('asyncPass')
+      value: string = 'x';
+    }
+
+    return validator.validate(new AsyncPassModel()).then(errors => {
+      expect(errors.length).toEqual(0);
+    });
+  });
+});

test/functional/metadata-storage.spec.ts

@@ -0,0 +1,97 @@
+import { MetadataStorage } from '../../src/metadata/MetadataStorage';
+import { ValidationMetadata } from '../../src/metadata/ValidationMetadata';
+import { ValidationTypes } from '../../src/validation/ValidationTypes';
+
+describe('MetadataStorage PR-2665 coverage', () => {
+  class TestTarget {}
+
+  function createMetadata(type: string, propertyName: string): ValidationMetadata {
+    return new ValidationMetadata({
+      type,
+      target: TestTarget,
+      propertyName,
+    });
+  }
+
+  it('should build cache keys independent from group order', () => {
+    const storage = new MetadataStorage();
+
+    const first = storage.buildCacheKey(TestTarget, '', false, false, ['beta', 'alpha']);
+    const second = storage.buildCacheKey(TestTarget, '', false, false, ['alpha', 'beta']);
+    const strict = storage.buildCacheKey(TestTarget, '', false, true, ['alpha', 'beta']);
+
+    expect(first).toEqual(second);
+    expect(first).not.toEqual(strict);
+  });
+
+  it('should partition metadata and compute customOnly accurately', () => {
+    const storage = new MetadataStorage();
+    const cacheKey = storage.buildCacheKey(TestTarget, '', false, false, undefined);
+    const grouped = {
+      onlyCustom: [createMetadata(ValidationTypes.CUSTOM_VALIDATION, 'onlyCustom')],
+      withPromise: [
+        createMetadata(ValidationTypes.CUSTOM_VALIDATION, 'withPromise'),
+        createMetadata(ValidationTypes.PROMISE_VALIDATION, 'withPromise'),
+      ],
+      withNestedAndConditional: [
+        createMetadata(ValidationTypes.CUSTOM_VALIDATION, 'withNestedAndConditional'),
+        createMetadata(ValidationTypes.NESTED_VALIDATION, 'withNestedAndConditional'),
+        createMetadata(ValidationTypes.CONDITIONAL_VALIDATION, 'withNestedAndConditional'),
+      ],
+      withDefined: [
+        createMetadata(ValidationTypes.IS_DEFINED, 'withDefined'),
+        createMetadata(ValidationTypes.CUSTOM_VALIDATION, 'withDefined'),
+      ],
+      withWhitelist: [
+        createMetadata(ValidationTypes.WHITELIST, 'withWhitelist'),
+        createMetadata(ValidationTypes.CUSTOM_VALIDATION, 'withWhitelist'),
+      ],
+    };
+
+    const partitioned = storage.getPartitionedMetadata(grouped, cacheKey);
+    const cached = storage.getPartitionedMetadata(grouped, cacheKey);
+
+    expect(cached).toBe(partitioned);
+    expect(partitioned.onlyCustom.customOnly).toEqual(true);
+    expect(partitioned.withPromise.customOnly).toEqual(false);
+    expect(partitioned.withPromise.hasPromiseValidation).toEqual(true);
+    expect(partitioned.withNestedAndConditional.customOnly).toEqual(false);
+    expect(partitioned.withDefined.customOnly).toEqual(false);
+    expect(partitioned.withDefined.defined.length).toEqual(1);
+    expect(partitioned.withWhitelist.all.length).toEqual(1);
+  });
+
+  it('should apply always/strictGroups metadata filtering consistently', () => {
+    class GroupedTarget {}
+    const storage = new MetadataStorage();
+    const plain = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: GroupedTarget,
+      propertyName: 'plain',
+    });
+    const grouped = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: GroupedTarget,
+      propertyName: 'grouped',
+    });
+    grouped.groups = ['g1'];
+    const explicitAlways = new ValidationMetadata({
+      type: ValidationTypes.CUSTOM_VALIDATION,
+      target: GroupedTarget,
+      propertyName: 'always',
+    });
+    explicitAlways.groups = ['g2'];
+    explicitAlways.always = true;
+
+    storage.addValidationMetadata(plain);
+    storage.addValidationMetadata(grouped);
+    storage.addValidationMetadata(explicitAlways);
+
+    const strictNoGroups = storage.getTargetValidationMetadatas(GroupedTarget, '', false, true);
+    const strictProperties = strictNoGroups.map(metadata => metadata.propertyName);
+
+    expect(strictProperties).toContain('plain');
+    expect(strictProperties).toContain('always');
+    expect(strictProperties).not.toContain('grouped');
+  });
+});