perf: series of perf optimisations

matthew2564 · matthew2564 · commit ae56f48f1ba5 · 2026-02-15T19:30:23.000Z
diff --git a/benchmark.ts b/benchmark.ts
@@ -0,0 +1,141 @@
+import 'reflect-metadata';
+import { validate, IsString, IsInt, IsBoolean, IsEmail, IsOptional, MinLength, MaxLength, Min, Max, IsNotEmpty, ValidateNested } from './src';
+
+// --- Classes with inheritance and nesting ---
+class BaseEntity {
+  @IsString()
+  id!: string;
+
+  @IsString()
+  @MinLength(1)
+  createdBy!: string;
+}
+
+class Address {
+  @IsString()
+  @IsNotEmpty()
+  street!: string;
+
+  @IsString()
+  @IsNotEmpty()
+  city!: string;
+
+  @IsString()
+  @MinLength(2)
+  @MaxLength(10)
+  zip!: string;
+}
+
+class User extends BaseEntity {
+  @IsString()
+  @MinLength(2)
+  @MaxLength(50)
+  firstName!: string;
+
+  @IsString()
+  @MinLength(2)
+  @MaxLength(50)
+  lastName!: string;
+
+  @IsEmail()
+  email!: string;
+
+  @IsInt()
+  @Min(0)
+  @Max(150)
+  age!: number;
+
+  @IsBoolean()
+  isActive!: boolean;
+
+  @IsOptional()
+  @IsString()
+  nickname?: string;
+
+  @IsOptional()
+  @IsString()
+  bio?: string;
+
+  @IsOptional()
+  @IsString()
+  phone?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  score?: number;
+
+  @IsOptional()
+  @IsString()
+  website?: string;
+
+  @ValidateNested()
+  address!: Address;
+}
+
+// --- Benchmark helpers ---
+
+function createValidUser(): User {
+  const user = new User();
+  user.id = 'abc-123';
+  user.createdBy = 'system';
+  user.firstName = 'John';
+  user.lastName = 'Doe';
+  user.email = 'john@example.com';
+  user.age = 30;
+  user.isActive = true;
+  user.nickname = 'johnd';
+  user.bio = 'A developer';
+  user.phone = '555-1234';
+  user.score = 100;
+  user.website = 'https://example.com';
+  const address = new Address();
+  address.street = '123 Main St';
+  address.city = 'Springfield';
+  address.zip = '62704';
+  user.address = address;
+  return user;
+}
+
+async function bench(label: string, iterations: number, fn: () => Promise<void>): Promise<void> {
+  // Warmup
+  for (let i = 0; i < 100; i++) await fn();
+
+  const start = performance.now();
+  for (let i = 0; i < iterations; i++) await fn();
+  const elapsed = performance.now() - start;
+
+  const opsPerSec = Math.round((iterations / elapsed) * 1000);
+  console.log(`${label}: ${iterations} iterations in ${elapsed.toFixed(1)}ms (${opsPerSec.toLocaleString()} ops/sec)`);
+}
+
+async function main(): Promise<void> {
+  const iterations = 10_000;
+  const user = createValidUser();
+
+  console.log('class-validator benchmark');
+  console.log('========================\n');
+
+  await bench('Valid object (13 props, inheritance + nested)', iterations, async () => {
+    await validate(user);
+  });
+
+  const invalidUser = createValidUser();
+  invalidUser.email = 'not-an-email';
+  invalidUser.age = -5;
+  invalidUser.firstName = 'X';
+
+  await bench('Invalid object (3 errors)', iterations, async () => {
+    await validate(invalidUser);
+  });
+
+  await bench('Valid object with groups', iterations, async () => {
+    await validate(user, { groups: ['admin', 'user'] });
+  });
+
+  await bench('Valid object with strictGroups', iterations, async () => {
+    await validate(user, { strictGroups: true });
+  });
+}
+
+main().catch(console.error);
diff --git a/src/container.ts b/src/container.ts
@@ -18,15 +18,15 @@ export interface UseContainerOptions {
  * container simply creates a new instance of the given class.
  */
 const defaultContainer: { get<T>(someClass: { new (...args: any[]): T } | Function): T } = new (class {
-  private instances: { type: Function; object: any }[] = [];
+  private instances = new Map<Function, any>();
   get<T>(someClass: { new (...args: any[]): T }): T {
-    let instance = this.instances.find(instance => instance.type === someClass);
+    let instance = this.instances.get(someClass);
     if (!instance) {
-      instance = { type: someClass, object: new someClass() };
-      this.instances.push(instance);
+      instance = new someClass();
+      this.instances.set(someClass, instance);
     }
 
-    return instance.object;
+    return instance;
   }
 })();
 
diff --git a/src/metadata/ConstraintMetadata.ts b/src/metadata/ConstraintMetadata.ts
@@ -28,6 +28,8 @@ export class ConstraintMetadata {
   // Constructor
   // -------------------------------------------------------------------------
 
+  private _instance!: ValidatorConstraintInterface;
+
   constructor(target: Function, name?: string, async: boolean = false) {
     this.target = target;
     this.name = name;
@@ -42,6 +44,9 @@ export class ConstraintMetadata {
    * Instance of the target custom validation class which performs validation.
    */
   get instance(): ValidatorConstraintInterface {
-    return getFromContainer<ValidatorConstraintInterface>(this.target);
+    if (!this._instance) {
+      this._instance = getFromContainer<ValidatorConstraintInterface>(this.target);
+    }
+    return this._instance;
   }
 }
diff --git a/src/metadata/MetadataStorage.ts b/src/metadata/MetadataStorage.ts
@@ -12,8 +12,12 @@ export class MetadataStorage {
   // Private properties
   // -------------------------------------------------------------------------
 
+  private static _nextId = 0;
+
   private validationMetadatas: Map<any, ValidationMetadata[]> = new Map();
   private constraintMetadatas: Map<any, ConstraintMetadata[]> = new Map();
+  private targetMetadataCache: Map<string, ValidationMetadata[]> = new Map();
+  private groupedMetadataCache: Map<string, Record<string, ValidationMetadata[]>> = new Map();
 
   get hasValidationMetaData(): boolean {
     return !!this.validationMetadatas.size;
@@ -35,6 +39,9 @@ export class MetadataStorage {
    * Adds a new validation metadata.
    */
   addValidationMetadata(metadata: ValidationMetadata): void {
+    this.targetMetadataCache.clear();
+    this.groupedMetadataCache.clear();
+
     const existingMetadata = this.validationMetadatas.get(metadata.target);
 
     if (existingMetadata) {
@@ -60,25 +67,54 @@ export class MetadataStorage {
   /**
    * Groups metadata by their property names.
    */
-  groupByPropertyName(metadata: ValidationMetadata[]): { [propertyName: string]: ValidationMetadata[] } {
+  groupByPropertyName(
+    metadata: ValidationMetadata[],
+    cacheKey?: string
+  ): { [propertyName: string]: ValidationMetadata[] } {
+    if (cacheKey) {
+      const cached = this.groupedMetadataCache.get(cacheKey);
+      if (cached) return cached;
+    }
+
     const grouped: { [propertyName: string]: ValidationMetadata[] } = {};
     metadata.forEach(metadata => {
       if (!grouped[metadata.propertyName]) grouped[metadata.propertyName] = [];
       grouped[metadata.propertyName].push(metadata);
     });
+
+    if (cacheKey) {
+      this.groupedMetadataCache.set(cacheKey, grouped);
+    }
+
     return grouped;
   }
 
   /**
    * Gets all validation metadatas for the given object with the given groups.
    */
+  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}`;
+  }
+
   getTargetValidationMetadatas(
     targetConstructor: Function,
     targetSchema: string,
     always: boolean,
     strictGroups: boolean,
     groups?: string[]
   ): ValidationMetadata[] {
+    const cacheKey = this.buildCacheKey(targetConstructor, targetSchema, always, strictGroups, groups);
+    const cached = this.targetMetadataCache.get(cacheKey);
+    if (cached) return cached;
+
     const includeMetadataBecauseOfAlwaysOption = (metadata: ValidationMetadata): boolean => {
       // `metadata.always` overrides global default.
       if (typeof metadata.always !== 'undefined') return metadata.always;
@@ -145,7 +181,9 @@ export class MetadataStorage {
       });
     });
 
-    return originalMetadatas.concat(uniqueInheritedMetadatas);
+    const result = originalMetadatas.concat(uniqueInheritedMetadatas);
+    this.targetMetadataCache.set(cacheKey, result);
+    return result;
   }
 
   /**
diff --git a/src/validation/ValidationExecutor.ts b/src/validation/ValidationExecutor.ts
