perf: series of validation execution optimisations

Author: matthew2564

benchmark.ts

@@ -1,5 +1,5 @@
 import 'reflect-metadata';
-import { validate, 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 {
@@ -109,6 +109,18 @@ async function bench(label: string, iterations: number, fn: () => Promise<void>)
   console.log(`${label}: ${iterations} iterations in ${elapsed.toFixed(1)}ms (${opsPerSec.toLocaleString()} ops/sec)`);
 }
 
+function benchSync(label: string, iterations: number, fn: () => void): void {
+  // Warmup
+  for (let i = 0; i < 100; i++) fn();
+
+  const start = performance.now();
+  for (let i = 0; i < iterations; i++) 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();
@@ -136,6 +148,20 @@ async function main(): Promise<void> {
   await bench('Valid object with strictGroups', iterations, async () => {
     await validate(user, { strictGroups: true });
   });
+
+  console.log('\n--- validateSync (no Promise overhead) ---\n');
+
+  benchSync('Valid object (sync)', iterations, () => {
+    validateSync(user);
+  });
+
+  benchSync('Invalid object (sync)', iterations, () => {
+    validateSync(invalidUser);
+  });
+
+  benchSync('Valid object with strictGroups (sync)', iterations, () => {
+    validateSync(user, { strictGroups: true });
+  });
 }
 
 main().catch(console.error);

src/decorator/array/ArrayContains.ts

@@ -10,7 +10,8 @@ export const ARRAY_CONTAINS = 'arrayContains';
 export function arrayContains(array: unknown, values: any[]): boolean {
   if (!Array.isArray(array)) return false;
 
-  return values.every(value => array.indexOf(value) !== -1);
+  const arraySet = new Set(array);
+  return values.every(value => arraySet.has(value));
 }
 
 /**

src/decorator/array/ArrayNotContains.ts

@@ -10,7 +10,8 @@ export const ARRAY_NOT_CONTAINS = 'arrayNotContains';
 export function arrayNotContains(array: unknown, values: any[]): boolean {
   if (!Array.isArray(array)) return false;
 
-  return values.every(value => array.indexOf(value) === -1);
+  const arraySet = new Set(array);
+  return values.every(value => !arraySet.has(value));
 }
 
 /**

src/decorator/array/ArrayUnique.ts

@@ -15,8 +15,7 @@ export function arrayUnique(array: unknown[], identifier?: ArrayUniqueIdentifier
     array = array.map(o => (o != null ? identifier(o) : o));
   }
 
-  const uniqueItems = array.filter((a, b, c) => c.indexOf(a) === b);
-  return array.length === uniqueItems.length;
+  return new Set(array).size === array.length;
 }
 
 /**

src/decorator/common/IsIn.ts

@@ -7,7 +7,7 @@ export const IS_IN = 'isIn';
  * Checks if given value is in a array of allowed values.
  */
 export function isIn(value: unknown, possibleValues: readonly unknown[]): boolean {
-  return Array.isArray(possibleValues) && possibleValues.some(possibleValue => possibleValue === value);
+  return Array.isArray(possibleValues) && possibleValues.includes(value);
 }
 
 /**

src/decorator/common/IsNotIn.ts

@@ -7,7 +7,7 @@ export const IS_NOT_IN = 'isNotIn';
  * Checks if given value not in a array of allowed values.
  */
 export function isNotIn(value: unknown, possibleValues: readonly unknown[]): boolean {
-  return !Array.isArray(possibleValues) || !possibleValues.some(possibleValue => possibleValue === value);
+  return !Array.isArray(possibleValues) || !possibleValues.includes(value);
 }
 
 /**

src/decorator/object/IsNotEmptyObject.ts

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

src/decorator/typechecker/IsEnum.ts

@@ -7,7 +7,7 @@ export const IS_ENUM = 'isEnum';
  * Checks if a given value is the member of the provided enum.
  */
 export function isEnum(value: unknown, entity: any): boolean {
-  const enumValues = Object.keys(entity).map(k => entity[k]);
+  const enumValues = Object.values(entity);
   return enumValues.includes(value);
 }
 
@@ -24,12 +24,13 @@ function validEnumValues(entity: any): string[] {
  * Checks if a given value is the member of the provided enum.
  */
 export function IsEnum(entity: object, validationOptions?: ValidationOptions): PropertyDecorator {
+  const enumValuesSet = new Set(Object.values(entity));
   return ValidateBy(
     {
       name: IS_ENUM,
       constraints: [entity, validEnumValues(entity)],
       validator: {
-        validate: (value, args): boolean => isEnum(value, args?.constraints[0]),
+        validate: (value): boolean => enumValuesSet.has(value),
         defaultMessage: buildMessage(
           eachPrefix => eachPrefix + '$property must be one of the following values: $constraint2',
           validationOptions

src/metadata/MetadataStorage.ts

@@ -3,6 +3,20 @@ import { ConstraintMetadata } from './ConstraintMetadata';
 import { ValidationSchema } from '../validation-schema/ValidationSchema';
 import { ValidationSchemaToMetadataTransformer } from '../validation-schema/ValidationSchemaToMetadataTransformer';
 import { getGlobal } from '../utils';
+import { ValidationTypes } from '../validation/ValidationTypes';
+
+export interface PartitionedPropertyMetadata {
+  defined: ValidationMetadata[];
+  custom: ValidationMetadata[];
+  nested: ValidationMetadata[];
+  conditional: ValidationMetadata[];
+  all: ValidationMetadata[];
+  hasPromiseValidation: boolean;
+  /** True when only custom validators exist (no defined/nested/conditional) — enables fast path */
+  customOnly: boolean;
+}
+
+export type PartitionedMetadata = Record<string, PartitionedPropertyMetadata>;
 
 /**
  * Storage all metadatas.
@@ -18,6 +32,7 @@ export class MetadataStorage {
   private constraintMetadatas: Map<any, ConstraintMetadata[]> = new Map();
   private targetMetadataCache: Map<string, ValidationMetadata[]> = new Map();
   private groupedMetadataCache: Map<string, Record<string, ValidationMetadata[]>> = new Map();
+  private partitionedMetadataCache: Map<string, PartitionedMetadata> = new Map();
 
   get hasValidationMetaData(): boolean {
     return !!this.validationMetadatas.size;
@@ -41,6 +56,7 @@ export class MetadataStorage {
   addValidationMetadata(metadata: ValidationMetadata): void {
     this.targetMetadataCache.clear();
     this.groupedMetadataCache.clear();
+    this.partitionedMetadataCache.clear();
 
     const existingMetadata = this.validationMetadatas.get(metadata.target);
 
@@ -89,6 +105,57 @@ export class MetadataStorage {
     return grouped;
   }
 
+  /**
+   * Returns pre-partitioned metadata grouped by property name, with each property's
+   * metadata split by type. Cached for repeated validations of the same class.
+   */
+  getPartitionedMetadata(
+    groupedMetadatas: Record<string, ValidationMetadata[]>,
+    cacheKey: string
+  ): PartitionedMetadata {
+    const cached = this.partitionedMetadataCache.get(cacheKey);
+    if (cached) return cached;
+
+    const result: PartitionedMetadata = {};
+    for (const propertyName in groupedMetadatas) {
+      const allMetadatas = groupedMetadatas[propertyName];
+      const defined: ValidationMetadata[] = [];
+      const custom: ValidationMetadata[] = [];
+      const nested: ValidationMetadata[] = [];
+      const conditional: ValidationMetadata[] = [];
+      const all: ValidationMetadata[] = [];
+      let hasPromiseValidation = false;
+
+      for (const metadata of allMetadatas) {
+        if (metadata.type === ValidationTypes.IS_DEFINED) {
+          defined.push(metadata);
+        } else if (metadata.type !== ValidationTypes.WHITELIST) {
+          all.push(metadata);
+          switch (metadata.type) {
+            case ValidationTypes.CUSTOM_VALIDATION:
+              custom.push(metadata);
+              break;
+            case ValidationTypes.NESTED_VALIDATION:
+              nested.push(metadata);
+              break;
+            case ValidationTypes.CONDITIONAL_VALIDATION:
+              conditional.push(metadata);
+              break;
+            case ValidationTypes.PROMISE_VALIDATION:
+              hasPromiseValidation = true;
+              break;
+          }
+        }
+      }
+
+      const customOnly = defined.length === 0 && nested.length === 0 && conditional.length === 0 && !hasPromiseValidation;
+      result[propertyName] = { defined, custom, nested, conditional, all, hasPromiseValidation, customOnly };
+    }
+
+    this.partitionedMetadataCache.set(cacheKey, result);
+    return result;
+  }
+
   /**
    * Gets all validation metadatas for the given object with the given groups.
    */
@@ -109,10 +176,11 @@ export class MetadataStorage {
     targetSchema: string,
     always: boolean,
     strictGroups: boolean,
-    groups?: string[]
+    groups?: string[],
+    cacheKey?: string
   ): ValidationMetadata[] {
-    const cacheKey = this.buildCacheKey(targetConstructor, targetSchema, always, strictGroups, groups);
-    const cached = this.targetMetadataCache.get(cacheKey);
+    const key = cacheKey ?? this.buildCacheKey(targetConstructor, targetSchema, always, strictGroups, groups);
+    const cached = this.targetMetadataCache.get(key);
     if (cached) return cached;
 
     const includeMetadataBecauseOfAlwaysOption = (metadata: ValidationMetadata): boolean => {
@@ -182,7 +250,7 @@ export class MetadataStorage {
     });
 
     const result = originalMetadatas.concat(uniqueInheritedMetadatas);
-    this.targetMetadataCache.set(cacheKey, result);
+    this.targetMetadataCache.set(key, result);
     return result;
   }
 

src/metadata/ValidationMetadata.ts

@@ -69,6 +69,23 @@ export class ValidationMetadata {
    */
   validationTypeOptions: any;
 
+  /**
+   * Cached resolved constraint metadatas for this validation.
+   * Populated on first access to avoid repeated Map lookups.
+   */
+  resolvedConstraints: any[] | undefined = undefined;
+
+  /**
+   * Inline validate function for built-in validators, bypassing constraint metadata dispatch.
+   */
+  inlineValidate?: (value: any, args?: any) => Promise<boolean> | boolean;
+
+  /**
+   * Inline defaultMessage function for built-in validators.
+   */
+  inlineDefaultMessage?: (args?: any) => string;
+
+
   // -------------------------------------------------------------------------
   // Constructor
   // -------------------------------------------------------------------------