eslint-plugin-class-validator-type-match 1.3.0 → 1.4.0

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 declare const _default: {
     rules: {
-        'decorator-type-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"mismatch" | "nestedArrayMismatch" | "missingValidateNested" | "enumMismatch" | "typeMismatch" | "missingEachOption" | "unnecessaryValidateNested", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+        'decorator-type-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"mismatch" | "nestedArrayMismatch" | "missingValidateNested" | "enumMismatch" | "typeMismatch" | "missingEachOption" | "unnecessaryValidateNested" | "invalidEachOption" | "missingTypeDecorator" | "tupleValidationWarning", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
         'optional-decorator-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"missingOptionalDecorator" | "missingOptionalSyntax" | "conflictingDefiniteAssignment" | "undefinedUnionWithoutDecorator" | "undefinedUnionWithoutOptional" | "nullUnionIncorrect" | "redundantUndefinedInType", [{
             strictNullChecks?: boolean;
             checkDefaultValues?: boolean;

package/dist/rules/decorator-type-match.d.ts

@@ -1,5 +1,5 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
-type MessageIds = 'mismatch' | 'nestedArrayMismatch' | 'missingValidateNested' | 'enumMismatch' | 'typeMismatch' | 'missingEachOption' | 'unnecessaryValidateNested';
+type MessageIds = 'mismatch' | 'nestedArrayMismatch' | 'missingValidateNested' | 'enumMismatch' | 'typeMismatch' | 'missingEachOption' | 'unnecessaryValidateNested' | 'invalidEachOption' | 'missingTypeDecorator' | 'tupleValidationWarning';
 /**
  * ESLint rule to ensure class-validator decorators match TypeScript type annotations.
  *
@@ -10,167 +10,25 @@ type MessageIds = 'mismatch' | 'nestedArrayMismatch' | 'missingValidateNested' |
  * - Arrays of objects requiring @ValidateNested({ each: true })
  * - Nested objects requiring @ValidateNested()
  * - Nullable complex types (Address | null, Address | undefined)
- * - Arrays of nullable complex types ((Address | null)[])
+ * - Nested arrays (Address[][])
  * - Type literals
  * - class-transformer decorators
  * - Enum types (both TypeScript enums and union types)
  * - Literal types (e.g., "admin", 25)
  * - Intersection types (e.g., Profile & Settings)
+ * - Branded types (string & { __brand: 'UserId' })
  * - @Type(() => ClassName) decorator matching
  * - Readonly arrays (readonly T[])
  * - Tuple types ([T, U])
  * - Nullable unions (T | null | undefined)
  * - Unnecessary @ValidateNested on primitive arrays
- *
- * @example
- * // ❌ Bad - will trigger error
- * class User {
- *   @IsString()
- *   name!: number;
- * }
- *
- * @example
- * // ✅ Good - types match
- * class User {
- *   @IsString()
- *   name!: string;
- * }
- *
- * @example
- * // ❌ Bad - @Type doesn't match TypeScript type
- * class User {
- *   @ValidateNested()
- *   @Type(() => Address)
- *   address: string;
- * }
- *
- * @example
- * // ✅ Good - @Type matches TypeScript type
- * class User {
- *   @ValidateNested()
- *   @Type(() => Address)
- *   address: Address;
- * }
- *
- * @example
- * // ❌ Bad - array of objects without @ValidateNested
- * class User {
- *   @IsArray()
- *   addresses!: Address[];
- * }
- *
- * @example
- * // ✅ Good - array of objects with @ValidateNested
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   @Type(() => Address)
- *   addresses!: Address[];
- * }
- *
- * @example
- * // ✅ Good - array of primitives without @ValidateNested
- * class User {
- *   @IsArray()
- *   @IsString({ each: true })
- *   tags!: string[];
- * }
- *
- * @example
- * // ❌ Bad - array of primitives with unnecessary @ValidateNested
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   @IsString({ each: true })
- *   tags!: string[];
- * }
- *
- * @example
- * // ❌ Bad - complex type without @ValidateNested
- * class User {
- *   @IsDefined()
- *   profile!: Profile;
- * }
- *
- * @example
- * // ✅ Good - complex type with @ValidateNested
- * class User {
- *   @ValidateNested()
- *   @Type(() => Profile)
- *   profile!: Profile;
- * }
- *
- * @example
- * // ❌ Bad - intersection type without @ValidateNested
- * class User {
- *   @IsDefined()
- *   data!: Profile & Settings;
- * }
- *
- * @example
- * // ✅ Good - intersection type with @ValidateNested
- * class User {
- *   @ValidateNested()
- *   data!: Profile & Settings;
- * }
- *
- * @example
- * // ✅ Good - literal type
- * class User {
- *   @IsString()
- *   role!: "admin";
- * }
- *
- * @example
- * // ❌ Bad - @IsEnum with wrong enum type
- * class User {
- *   @IsEnum(UserRole)
- *   status!: UserStatus;
- * }
- *
- * @example
- * // ✅ Good - @IsEnum matches enum type
- * class User {
- *   @IsEnum(UserStatus)
- *   status!: UserStatus;
- * }
- *
- * @example
- * // ✅ Good - union type with @IsEnum
- * class User {
- *   @IsEnum({ ACTIVE: 'active', INACTIVE: 'inactive' })
- *   status!: 'active' | 'inactive';
- * }
- *
- * @example
- * // ❌ Bad - enum type used with wrong decorator
- * class User {
- *   @IsString()
- *   status!: UserStatus;  // Should use @IsEnum, will report type mismatch
- * }
- *
- * @example
- * // ✅ Good - nullable union with @IsOptional
- * class User {
- *   @IsOptional()
- *   @IsString()
- *   name!: string | null;
- * }
- *
- * @example
- * // ✅ Good - readonly array
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   addresses!: readonly Address[];
- * }
- *
- * @example
- * // ✅ Good - tuple type
- * class User {
- *   @IsArray()
- *   coords!: [number, number];
- * }
+ * - Decorators with { each: true } option for array element validation
+ * - Template literal types (`user-${string}`)
+ * - Namespace/qualified type references (MyNamespace.MyEnum)
+ * - Invalid { each: true } on non-array types
+ * - Missing @Type decorator when @ValidateNested is present
+ * - Type aliases (via TypeScript type checker)
+ * - Record<K, V> utility types with primitive values
  */
 declare const _default: ESLintUtils.RuleModule<MessageIds, [], unknown, ESLintUtils.RuleListener>;
 export default _default;

package/dist/rules/decorator-type-match.js

@@ -27,43 +27,6 @@ const TYPE_AGNOSTIC_DECORATORS = new Set([
 /**
  * Mapping of class-validator decorators to their expected TypeScript types.
  * Only includes decorators that enforce specific types.
- *
- * @example
- * // ✅ Good - nullable complex type with @ValidateNested
- * class User {
- *   @IsOptional()
- *   @ValidateNested()
- *   @Type(() => Address)
- *   address?: Address | null;
- * }
- *
- * @example
- * // ❌ Bad - nullable complex type without @ValidateNested
- * class User {
- *   @IsOptional()
- *   @Type(() => Address)
- *   address?: Address | null;
- * }
- *
- * @example
- * // ✅ Good - array of nullable complex types
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   @Type(() => Address)
- *   addresses!: (Address | null)[];
- * }
- *
- * @example
- * // ❌ Bad - array of nullable complex types without @ValidateNested
- * class User {
- *   @IsArray()
- *   @Type(() => Address)
- *   addresses!: (Address | null)[];
- * }
- *
- * @example
- * IsString: ["string"] - expects string type
  */
 const decoratorTypeMap = {
     // String validators
@@ -216,12 +179,83 @@ function isNullableUnion(typeNode) {
     }
     return { isNullable: false, baseType: null };
 }
+/**
+ * Extracts the name from a TSQualifiedName or Identifier
+ */
+function getTypeReferenceName(typeName) {
+    if (typeName.type === 'Identifier') {
+        return typeName.name;
+    }
+    // Handle TSQualifiedName (e.g., MyNamespace.MyEnum)
+    if (typeName.type === 'TSQualifiedName') {
+        const parts = [];
+        let current = typeName;
+        while (current.type === 'TSQualifiedName') {
+            if (current.right.type === 'Identifier') {
+                parts.unshift(current.right.name);
+            }
+            current = current.left;
+        }
+        if (current.type === 'Identifier') {
+            parts.unshift(current.name);
+        }
+        return parts.join('.');
+    }
+    return '';
+}
+/**
+ * Uses TypeScript's type checker to resolve the actual type, handling type aliases.
+ * Returns the resolved type string, or null if it cannot be determined.
+ */
+function resolveTypeWithChecker(typeNode, checker, esTreeNodeMap) {
+    if (!checker || !esTreeNodeMap) {
+        return null;
+    }
+    const tsNode = esTreeNodeMap.get(typeNode);
+    if (!tsNode) {
+        return null;
+    }
+    try {
+        const type = checker.getTypeAtLocation(tsNode);
+        // Check for primitive types using TypeScript's type flags
+        if (type.flags & (1 << 2))
+            return 'string'; // ts.TypeFlags.String
+        if (type.flags & (1 << 3))
+            return 'number'; // ts.TypeFlags.Number
+        if (type.flags & (1 << 4))
+            return 'boolean'; // ts.TypeFlags.Boolean
+        // Check if it's an array type
+        if (checker.isArrayType(type)) {
+            return 'array';
+        }
+        // Check if it's a tuple type
+        // TypeScript's ObjectType has objectFlags property, but it's not exposed in the public types
+        if ('objectFlags' in type && type.objectFlags & 8) {
+            // ts.ObjectFlags.Tuple = 8
+            return 'array';
+        }
+        // For other types, fall back to AST analysis
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Converts a TypeScript type node to its string representation for validation purposes.
  * Handles primitives, arrays, tuples, type references, literals, unions, and intersections.
  * Returns null for types that cannot be validated.
+ *
+ * Can optionally use TypeScript's type checker to resolve type aliases.
  */
-function getTypeString(typeNode) {
+function getTypeString(typeNode, checker = null, esTreeNodeMap = null) {
+    // Try to resolve with type checker first (handles type aliases)
+    if (checker && esTreeNodeMap) {
+        const resolved = resolveTypeWithChecker(typeNode, checker, esTreeNodeMap);
+        if (resolved) {
+            return resolved;
+        }
+    }
     const unwrapped = unwrapReadonlyOperator(typeNode);
     switch (unwrapped.type) {
         case 'TSStringKeyword':
@@ -234,11 +268,10 @@ function getTypeString(typeNode) {
             return 'array';
         case 'TSTupleType':
             return 'array';
+        case 'TSTemplateLiteralType':
+            return 'string';
         case 'TSTypeReference':
-            if (unwrapped.typeName.type === 'Identifier') {
-                return unwrapped.typeName.name;
-            }
-            break;
+            return getTypeReferenceName(unwrapped.typeName);
         case 'TSTypeLiteral':
             return 'object';
         case 'TSUnionType':
@@ -254,6 +287,13 @@ function getTypeString(typeNode) {
             }
             return 'literal';
         case 'TSIntersectionType':
+            // Check if intersection contains a primitive type (branded types)
+            for (const type of unwrapped.types) {
+                const typeStr = getTypeString(type, checker, esTreeNodeMap);
+                if (typeStr === 'string' || typeStr === 'number' || typeStr === 'boolean') {
+                    return typeStr;
+                }
+            }
             return 'intersection';
     }
     return null;
@@ -261,7 +301,7 @@ function getTypeString(typeNode) {
 /**
  * Extracts the element type from an array type annotation.
  * Supports T[] and Array<T> syntax.
- * Returns null for tuple types since they don't have a single element type.
+ * For tuple types, returns null since they require per-element validation.
  */
 function getArrayElementTypeNode(typeAnnotation) {
     const unwrapped = unwrapReadonlyOperator(typeAnnotation);
@@ -276,12 +316,28 @@ function getArrayElementTypeNode(typeAnnotation) {
         unwrapped.typeArguments?.params[0]) {
         return unwrapped.typeArguments.params[0];
     }
-    // Tuples don't have a single element type to validate
+    // Tuples require special handling
     if (unwrapped.type === 'TSTupleType') {
         return null;
     }
     return null;
 }
+/**
+ * Gets all element types from a tuple type.
+ */
+function getTupleElementTypes(typeAnnotation) {
+    const unwrapped = unwrapReadonlyOperator(typeAnnotation);
+    if (unwrapped.type === 'TSTupleType') {
+        return unwrapped.elementTypes.map((element) => {
+            // Handle named tuple elements: [name: Type]
+            if (element.type === 'TSNamedTupleMember') {
+                return element.elementType;
+            }
+            return element;
+        });
+    }
+    return [];
+}
 /**
  * Checks if a type is a union of literal types (e.g., 'active' | 'inactive').
  * These are typically used for enum-like type definitions.
@@ -292,13 +348,38 @@ function isUnionOfLiterals(typeNode) {
     }
     return false;
 }
+/**
+ * Checks if a type reference is a Record utility type with a primitive value type.
+ * Record<string, number> = not complex
+ * Record<string, Address> = complex
+ */
+function isRecordWithPrimitiveValue(typeNode, checker, esTreeNodeMap) {
+    const unwrapped = unwrapReadonlyOperator(typeNode);
+    if (unwrapped.type !== 'TSTypeReference') {
+        return false;
+    }
+    const typeName = getTypeReferenceName(unwrapped.typeName);
+    if (typeName !== 'Record') {
+        return false;
+    }
+    // Check if it has type arguments
+    if (!unwrapped.typeArguments || unwrapped.typeArguments.params.length < 2) {
+        return false;
+    }
+    // Get the value type (second type argument)
+    const valueType = unwrapped.typeArguments.params[1];
+    const valueTypeStr = getTypeString(valueType, checker, esTreeNodeMap);
+    // If value type is a primitive, Record is not complex
+    return valueTypeStr === 'string' || valueTypeStr === 'number' || valueTypeStr === 'boolean';
+}
 /**
  * Determines if a type requires @ValidateNested decorator for proper validation.
  * Complex types include objects, class instances, type literals, and intersections.
- * Built-in types with complex generic parameters are also considered complex.
+ * Arrays of complex types are also considered complex.
+ * Built-in types with complex generic parameters are checked selectively.
  * Union types are complex if any non-null/undefined member is complex.
  */
-function isComplexType(typeNode) {
+function isComplexType(typeNode, checker = null, esTreeNodeMap = null) {
     const unwrapped = unwrapReadonlyOperator(typeNode);
     // Type literals are always complex
     if (unwrapped.type === 'TSTypeLiteral') {
@@ -309,7 +390,6 @@ function isComplexType(typeNode) {
         return false;
     }
     // Union types are complex if any non-null/undefined member is complex
-    // This handles cases like: Address | null, Address | undefined, Address | Profile
     if (unwrapped.type === 'TSUnionType') {
         return unwrapped.types.some((type) => {
             // Skip null and undefined - they don't affect complexity
@@ -317,29 +397,53 @@ function isComplexType(typeNode) {
                 return false;
             }
             // Recursively check if this union member is complex
-            return isComplexType(type);
+            return isComplexType(type, checker, esTreeNodeMap);
         });
     }
-    // Intersection types are complex
+    // Intersection types: check if any member is a primitive (branded types)
     if (unwrapped.type === 'TSIntersectionType') {
+        // If intersection contains a primitive, treat as primitive (branded type)
+        for (const type of unwrapped.types) {
+            const typeStr = getTypeString(type, checker, esTreeNodeMap);
+            if (typeStr === 'string' || typeStr === 'number' || typeStr === 'boolean') {
+                return false;
+            }
+        }
+        // Otherwise, it's a complex intersection
         return true;
     }
+    // Arrays are complex if their elements are complex
+    if (unwrapped.type === 'TSArrayType') {
+        return isComplexType(unwrapped.elementType, checker, esTreeNodeMap);
+    }
+    // Tuples are complex if any element is complex
+    if (unwrapped.type === 'TSTupleType') {
+        const elements = getTupleElementTypes(unwrapped);
+        return elements.some((element) => isComplexType(element, checker, esTreeNodeMap));
+    }
     // Check for type references (class names, interfaces, etc.)
-    if (unwrapped.type === 'TSTypeReference' && unwrapped.typeName.type === 'Identifier') {
-        const typeName = unwrapped.typeName.name;
+    if (unwrapped.type === 'TSTypeReference') {
+        const typeName = getTypeReferenceName(unwrapped.typeName);
         // Common built-in types that don't require @ValidateNested
-        // This list focuses on types commonly used in validation contexts
-        const builtInTypes = ['String', 'Number', 'Boolean', 'Date', 'Array', 'Promise', 'Map', 'Set'];
-        // Built-in types with complex generic parameters are considered complex
-        if (builtInTypes.includes(typeName) && unwrapped.typeArguments?.params) {
-            for (const param of unwrapped.typeArguments.params) {
-                if (isComplexType(param)) {
-                    return true;
-                }
-            }
+        const builtInTypes = ['String', 'Number', 'Boolean', 'Date'];
+        // Types that can't be validated even with generic parameters
+        const nonValidatableTypes = ['Promise', 'Map', 'Set'];
+        if (nonValidatableTypes.includes(typeName)) {
             return false;
         }
-        return !builtInTypes.includes(typeName);
+        // Record<K, V> with primitive V is not complex
+        if (isRecordWithPrimitiveValue(unwrapped, checker, esTreeNodeMap)) {
+            return false;
+        }
+        // Array<T> needs to check the element type
+        if (typeName === 'Array' && unwrapped.typeArguments?.params[0]) {
+            return isComplexType(unwrapped.typeArguments.params[0], checker, esTreeNodeMap);
+        }
+        // Other built-in types are not complex
+        if (builtInTypes.includes(typeName)) {
+            return false;
+        }
+        return true;
     }
     return false;
 }
@@ -362,6 +466,13 @@ function isArrayType(typeAnnotation) {
     }
     return false;
 }
+/**
+ * Checks if a type is a tuple type.
+ */
+function isTupleType(typeAnnotation) {
+    const unwrapped = unwrapReadonlyOperator(typeAnnotation);
+    return unwrapped.type === 'TSTupleType';
+}
 /**
  * Checks if a type is a union of literals, used for enum-like type definitions.
  */
@@ -422,35 +533,56 @@ function getTypeDecoratorClassName(decorator) {
     return null;
 }
 /**
- * Checks if @ValidateNested decorator includes the { each: true } option.
+ * Checks if a decorator includes the { each: true } option.
  * Returns false for decorators without parentheses or without the each option.
+ * This works for any decorator, not just @ValidateNested.
+ *
+ * Handles both single and two-parameter decorator signatures:
+ * - @IsString({ each: true })
+ * - @IsNumber({}, { each: true })
+ * - @Min(0, { each: true })
  */
-function hasValidateNestedEachOption(decorator) {
-    // If decorator is used without parentheses (e.g., @ValidateNested), it has no options
+function hasEachOption(decorator) {
+    // If decorator is used without parentheses (e.g., @IsString), it has no options
     if (decorator.expression.type === 'Identifier') {
         return false;
     }
-    if (decorator.expression.type === 'CallExpression' && decorator.expression.arguments.length > 0) {
-        const firstArg = decorator.expression.arguments[0];
-        if (firstArg.type === 'ObjectExpression') {
-            return firstArg.properties.some((prop) => {
-                if (prop.type === 'Property' &&
-                    prop.key.type === 'Identifier' &&
-                    prop.key.name === 'each' &&
-                    prop.value.type === 'Literal') {
-                    return prop.value.value === true;
-                }
-                return false;
-            });
+    if (decorator.expression.type === 'CallExpression') {
+        const args = decorator.expression.arguments;
+        // Check both first and second arguments for { each: true }
+        // Some decorators have validation options as first param: @IsString({ each: true })
+        // Others have it as second param: @Min(0, { each: true })
+        for (let i = 0; i < Math.min(args.length, 2); i++) {
+            const arg = args[i];
+            if (arg.type === 'ObjectExpression') {
+                const hasEach = arg.properties.some((prop) => {
+                    if (prop.type === 'Property' &&
+                        prop.key.type === 'Identifier' &&
+                        prop.key.name === 'each' &&
+                        prop.value.type === 'Literal') {
+                        return prop.value.value === true;
+                    }
+                    return false;
+                });
+                if (hasEach)
+                    return true;
+            }
         }
     }
     return false;
 }
+/**
+ * Checks if @ValidateNested decorator includes the { each: true } option.
+ * Returns false for decorators without parentheses or without the each option.
+ */
+function hasValidateNestedEachOption(decorator) {
+    return hasEachOption(decorator);
+}
 /**
  * Validates if a decorator matches the TypeScript type annotation.
  * Handles special cases like @IsEnum validation and nullable unions.
  */
-function checkTypeMatch(decorator, typeAnnotation, actualType) {
+function checkTypeMatch(decorator, typeAnnotation, actualType, checker, esTreeNodeMap) {
     const expectedTypes = decoratorTypeMap[decorator];
     // Skip decorators not in our map
     if (!expectedTypes || expectedTypes.length === 0) {
@@ -464,7 +596,7 @@ function checkTypeMatch(decorator, typeAnnotation, actualType) {
         if (isUnionEnumType(typeAnnotation)) {
             return expectedTypes.includes('union-literal');
         }
-        if (typeAnnotation.type === 'TSTypeReference' && typeAnnotation.typeName.type === 'Identifier') {
+        if (typeAnnotation.type === 'TSTypeReference') {
             return expectedTypes.includes('type-reference');
         }
         return false;
@@ -472,7 +604,7 @@ function checkTypeMatch(decorator, typeAnnotation, actualType) {
     // For nullable unions (T | null | undefined), validate against the base type
     const nullableCheck = isNullableUnion(typeAnnotation);
     if (nullableCheck.isNullable && nullableCheck.baseType) {
-        const baseTypeString = getTypeString(nullableCheck.baseType);
+        const baseTypeString = getTypeString(nullableCheck.baseType, checker, esTreeNodeMap);
         if (baseTypeString) {
             return expectedTypes.some((expected) => {
                 if (expected === 'array' && baseTypeString === 'Array')
@@ -502,174 +634,32 @@ function checkTypeMatch(decorator, typeAnnotation, actualType) {
  * - Arrays of objects requiring @ValidateNested({ each: true })
  * - Nested objects requiring @ValidateNested()
  * - Nullable complex types (Address | null, Address | undefined)
- * - Arrays of nullable complex types ((Address | null)[])
+ * - Nested arrays (Address[][])
  * - Type literals
  * - class-transformer decorators
  * - Enum types (both TypeScript enums and union types)
  * - Literal types (e.g., "admin", 25)
  * - Intersection types (e.g., Profile & Settings)
+ * - Branded types (string & { __brand: 'UserId' })
  * - @Type(() => ClassName) decorator matching
  * - Readonly arrays (readonly T[])
  * - Tuple types ([T, U])
  * - Nullable unions (T | null | undefined)
  * - Unnecessary @ValidateNested on primitive arrays
- *
- * @example
- * // ❌ Bad - will trigger error
- * class User {
- *   @IsString()
- *   name!: number;
- * }
- *
- * @example
- * // ✅ Good - types match
- * class User {
- *   @IsString()
- *   name!: string;
- * }
- *
- * @example
- * // ❌ Bad - @Type doesn't match TypeScript type
- * class User {
- *   @ValidateNested()
- *   @Type(() => Address)
- *   address: string;
- * }
- *
- * @example
- * // ✅ Good - @Type matches TypeScript type
- * class User {
- *   @ValidateNested()
- *   @Type(() => Address)
- *   address: Address;
- * }
- *
- * @example
- * // ❌ Bad - array of objects without @ValidateNested
- * class User {
- *   @IsArray()
- *   addresses!: Address[];
- * }
- *
- * @example
- * // ✅ Good - array of objects with @ValidateNested
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   @Type(() => Address)
- *   addresses!: Address[];
- * }
- *
- * @example
- * // ✅ Good - array of primitives without @ValidateNested
- * class User {
- *   @IsArray()
- *   @IsString({ each: true })
- *   tags!: string[];
- * }
- *
- * @example
- * // ❌ Bad - array of primitives with unnecessary @ValidateNested
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   @IsString({ each: true })
- *   tags!: string[];
- * }
- *
- * @example
- * // ❌ Bad - complex type without @ValidateNested
- * class User {
- *   @IsDefined()
- *   profile!: Profile;
- * }
- *
- * @example
- * // ✅ Good - complex type with @ValidateNested
- * class User {
- *   @ValidateNested()
- *   @Type(() => Profile)
- *   profile!: Profile;
- * }
- *
- * @example
- * // ❌ Bad - intersection type without @ValidateNested
- * class User {
- *   @IsDefined()
- *   data!: Profile & Settings;
- * }
- *
- * @example
- * // ✅ Good - intersection type with @ValidateNested
- * class User {
- *   @ValidateNested()
- *   data!: Profile & Settings;
- * }
- *
- * @example
- * // ✅ Good - literal type
- * class User {
- *   @IsString()
- *   role!: "admin";
- * }
- *
- * @example
- * // ❌ Bad - @IsEnum with wrong enum type
- * class User {
- *   @IsEnum(UserRole)
- *   status!: UserStatus;
- * }
- *
- * @example
- * // ✅ Good - @IsEnum matches enum type
- * class User {
- *   @IsEnum(UserStatus)
- *   status!: UserStatus;
- * }
- *
- * @example
- * // ✅ Good - union type with @IsEnum
- * class User {
- *   @IsEnum({ ACTIVE: 'active', INACTIVE: 'inactive' })
- *   status!: 'active' | 'inactive';
- * }
- *
- * @example
- * // ❌ Bad - enum type used with wrong decorator
- * class User {
- *   @IsString()
- *   status!: UserStatus;  // Should use @IsEnum, will report type mismatch
- * }
- *
- * @example
- * // ✅ Good - nullable union with @IsOptional
- * class User {
- *   @IsOptional()
- *   @IsString()
- *   name!: string | null;
- * }
- *
- * @example
- * // ✅ Good - readonly array
- * class User {
- *   @IsArray()
- *   @ValidateNested({ each: true })
- *   addresses!: readonly Address[];
- * }
- *
- * @example
- * // ✅ Good - tuple type
- * class User {
- *   @IsArray()
- *   coords!: [number, number];
- * }
+ * - Decorators with { each: true } option for array element validation
+ * - Template literal types (`user-${string}`)
+ * - Namespace/qualified type references (MyNamespace.MyEnum)
+ * - Invalid { each: true } on non-array types
+ * - Missing @Type decorator when @ValidateNested is present
+ * - Type aliases (via TypeScript type checker)
+ * - Record<K, V> utility types with primitive values
  */
 exports.default = createRule({
     name: 'decorator-type-match',
     meta: {
         type: 'problem',
         docs: {
-            description: 'Ensure class-validator decorators match TypeScript type annotations, including arrays of objects, nested objects, enum types, literal types, intersection types, readonly arrays, tuple types, nullable unions, and @Type decorator matching',
+            description: 'Ensure class-validator decorators match TypeScript type annotations, including arrays of objects, nested objects, enum types, literal types, intersection types, readonly arrays, tuple types, nullable unions, @Type decorator matching, { each: true } option handling, template literals, namespace references, type aliases, branded types, and Record utility types',
         },
         messages: {
             mismatch: 'Decorator @{{decorator}} does not match type annotation {{actualType}}. Expected: {{expectedTypes}}',
@@ -679,11 +669,27 @@ exports.default = createRule({
             typeMismatch: '@Type(() => {{typeDecoratorClass}}) does not match type annotation {{actualType}}.',
             missingEachOption: 'Array of complex types requires @ValidateNested({ each: true }), but only @ValidateNested() was found.',
             unnecessaryValidateNested: 'Array of primitive type {{elementType}} does not need @ValidateNested(). Remove @ValidateNested() or use @{{decorator}}({ each: true }) instead.',
+            invalidEachOption: 'Decorator @{{decorator}} has { each: true } option but property type is not an array. Remove { each: true } or change type to an array.',
+            missingTypeDecorator: 'Complex type {{actualType}} with @ValidateNested() requires @Type(() => {{className}}) decorator for proper transformation.',
+            tupleValidationWarning: 'Tuple type contains complex elements. Consider using a regular array with @ValidateNested({ each: true }) or validate elements individually.',
         },
         schema: [],
     },
     defaultOptions: [],
     create(context) {
+        // Get TypeScript type checker if available
+        let checker = null;
+        let esTreeNodeMap = null;
+        try {
+            const parserServices = context.parserServices;
+            if (parserServices?.program && parserServices?.esTreeNodeToTSNodeMap) {
+                checker = parserServices.program.getTypeChecker();
+                esTreeNodeMap = parserServices.esTreeNodeToTSNodeMap;
+            }
+        }
+        catch {
+            // Type checker not available, continue with AST-only analysis
+        }
         return {
             /**
              * Analyzes class property definitions to validate decorator and type annotation matching
@@ -716,28 +722,31 @@ exports.default = createRule({
                 /**
                  * Determine the actual TypeScript type from the annotation.
                  * Supports primitive types, arrays, type references, literals, and intersections.
+                 * Uses TypeScript's type checker when available to resolve type aliases.
                  */
-                actualType = getTypeString(typeAnnotation);
+                actualType = getTypeString(typeAnnotation, checker, esTreeNodeMap);
                 // Skip if we couldn't determine the type
                 if (!actualType)
                     return;
                 const hasValidateNested = decorators.includes('ValidateNested');
                 const hasIsEnum = decorators.includes('IsEnum');
+                const hasTypeDecorator = decorators.includes('Type');
                 // Validate @IsEnum argument matches the type annotation for enum type references
-                if (hasIsEnum && typeAnnotation.type === 'TSTypeReference' && typeAnnotation.typeName.type === 'Identifier') {
+                if (hasIsEnum && typeAnnotation.type === 'TSTypeReference') {
                     const isEnumDecorator = node.decorators?.find((d) => d.expression.type === 'CallExpression' &&
                         d.expression.callee.type === 'Identifier' &&
                         d.expression.callee.name === 'IsEnum');
                     if (isEnumDecorator) {
                         const enumArg = getIsEnumArgument(isEnumDecorator);
+                        const typeName = getTypeReferenceName(typeAnnotation.typeName);
                         // For TypeScript enum references, the argument should match the type
-                        if (enumArg && enumArg !== typeAnnotation.typeName.name) {
+                        if (enumArg && enumArg !== typeName) {
                             context.report({
                                 node,
                                 messageId: 'enumMismatch',
                                 data: {
                                     enumArg,
-                                    actualType: typeAnnotation.typeName.name,
+                                    actualType: typeName,
                                 },
                             });
                         }
@@ -751,8 +760,8 @@ exports.default = createRule({
                     const typeClassName = getTypeDecoratorClassName(typeDecorator);
                     // For non-array types, check if @Type matches the TypeScript type
                     if (typeClassName && !isArrayType(typeAnnotation)) {
-                        if (typeAnnotation.type === 'TSTypeReference' && typeAnnotation.typeName.type === 'Identifier') {
-                            const tsTypeName = typeAnnotation.typeName.name;
+                        if (typeAnnotation.type === 'TSTypeReference') {
+                            const tsTypeName = getTypeReferenceName(typeAnnotation.typeName);
                             if (typeClassName !== tsTypeName) {
                                 context.report({
                                     node,
@@ -764,7 +773,7 @@ exports.default = createRule({
                                 });
                             }
                         }
-                        else if (typeAnnotation.type !== 'TSTypeReference') {
+                        else {
                             // @Type is used with a primitive type
                             context.report({
                                 node,
@@ -780,8 +789,8 @@ exports.default = createRule({
                     if (typeClassName && isArrayType(typeAnnotation)) {
                         const elementTypeNode = getArrayElementTypeNode(typeAnnotation);
                         if (elementTypeNode) {
-                            if (elementTypeNode.type === 'TSTypeReference' && elementTypeNode.typeName.type === 'Identifier') {
-                                const elementTypeName = elementTypeNode.typeName.name;
+                            if (elementTypeNode.type === 'TSTypeReference') {
+                                const elementTypeName = getTypeReferenceName(elementTypeNode.typeName);
                                 if (typeClassName !== elementTypeName) {
                                     context.report({
                                         node,
@@ -795,7 +804,7 @@ exports.default = createRule({
                             }
                             else {
                                 // @Type is used with an array of primitives
-                                const elementType = getTypeString(elementTypeNode);
+                                const elementType = getTypeString(elementTypeNode, checker, esTreeNodeMap);
                                 if (elementType) {
                                     context.report({
                                         node,
@@ -810,13 +819,24 @@ exports.default = createRule({
                         }
                     }
                 }
+                // Special handling for tuple types
+                if (isTupleType(typeAnnotation)) {
+                    const elements = getTupleElementTypes(typeAnnotation);
+                    const hasComplexElements = elements.some((element) => isComplexType(element, checker, esTreeNodeMap));
+                    if (hasComplexElements) {
+                        context.report({
+                            node,
+                            messageId: 'tupleValidationWarning',
+                            data: {},
+                        });
+                    }
+                }
                 // Validate arrays of complex types have proper nested validation
-                if (isArrayType(typeAnnotation)) {
+                if (isArrayType(typeAnnotation) && !isTupleType(typeAnnotation)) {
                     const elementTypeNode = getArrayElementTypeNode(typeAnnotation);
-                    // Tuples return null for elementTypeNode, skip nested validation check
                     if (elementTypeNode) {
-                        const elementTypeName = getTypeString(elementTypeNode);
-                        const isElementComplex = isComplexType(elementTypeNode);
+                        const elementTypeName = getTypeString(elementTypeNode, checker, esTreeNodeMap);
+                        const isElementComplex = isComplexType(elementTypeNode, checker, esTreeNodeMap);
                         if (isElementComplex && elementTypeName) {
                             // Complex element type - requires @ValidateNested({ each: true })
                             if (!hasValidateNested) {
@@ -848,6 +868,26 @@ exports.default = createRule({
                                         data: {},
                                     });
                                 }
+                                // Check if @Type decorator is present for complex element types
+                                if (!hasTypeDecorator) {
+                                    let elementTypeToCheck = elementTypeNode;
+                                    // Handle nullable element types: (Address | null)[]
+                                    const nullableCheck = isNullableUnion(elementTypeNode);
+                                    if (nullableCheck.isNullable && nullableCheck.baseType) {
+                                        elementTypeToCheck = nullableCheck.baseType;
+                                    }
+                                    if (elementTypeToCheck.type === 'TSTypeReference') {
+                                        const className = getTypeReferenceName(elementTypeToCheck.typeName);
+                                        context.report({
+                                            node,
+                                            messageId: 'missingTypeDecorator',
+                                            data: {
+                                                actualType: `${className}[]`,
+                                                className,
+                                            },
+                                        });
+                                    }
+                                }
                             }
                         }
                         else if (!isElementComplex && hasValidateNested && elementTypeName) {
@@ -872,7 +912,43 @@ exports.default = createRule({
                     // Skip type-agnostic decorators
                     if (TYPE_AGNOSTIC_DECORATORS.has(decorator))
                         continue;
-                    const matches = checkTypeMatch(decorator, typeAnnotation, actualType);
+                    // Get the decorator node to check for { each: true }
+                    const decoratorNode = node.decorators?.find((d) => {
+                        if (d.expression.type === 'CallExpression' && d.expression.callee.type === 'Identifier') {
+                            return d.expression.callee.name === decorator;
+                        }
+                        if (d.expression.type === 'Identifier') {
+                            return d.expression.name === decorator;
+                        }
+                        return false;
+                    });
+                    // Check if this decorator has { each: true } option
+                    const hasEach = decoratorNode ? hasEachOption(decoratorNode) : false;
+                    // Validate { each: true } is only used with arrays
+                    if (hasEach && !isArrayType(typeAnnotation)) {
+                        context.report({
+                            node,
+                            messageId: 'invalidEachOption',
+                            data: {
+                                decorator,
+                            },
+                        });
+                        continue;
+                    }
+                    let typeToCheck = actualType;
+                    let typeNodeToCheck = typeAnnotation;
+                    // If decorator has { each: true }, validate against array element type
+                    if (hasEach && isArrayType(typeAnnotation)) {
+                        const elementTypeNode = getArrayElementTypeNode(typeAnnotation);
+                        if (elementTypeNode) {
+                            const elementType = getTypeString(elementTypeNode, checker, esTreeNodeMap);
+                            if (elementType) {
+                                typeToCheck = elementType;
+                                typeNodeToCheck = elementTypeNode;
+                            }
+                        }
+                    }
+                    const matches = checkTypeMatch(decorator, typeNodeToCheck, typeToCheck, checker, esTreeNodeMap);
                     // Report mismatch
                     if (!matches) {
                         const expectedTypes = decoratorTypeMap[decorator];
@@ -881,7 +957,7 @@ exports.default = createRule({
                             messageId: 'mismatch',
                             data: {
                                 decorator,
-                                actualType,
+                                actualType: typeToCheck,
                                 expectedTypes: expectedTypes?.join(' or ') || 'unknown',
                             },
                         });
@@ -889,7 +965,9 @@ exports.default = createRule({
                 }
                 // Validate complex object types have @ValidateNested decorator
                 const hasTypedDecorator = decorators.some((d) => !TYPE_AGNOSTIC_DECORATORS.has(d) && decoratorTypeMap[d]);
-                if (!isArrayType(typeAnnotation) && isComplexType(typeAnnotation) && !hasTypedDecorator) {
+                if (!isArrayType(typeAnnotation) &&
+                    isComplexType(typeAnnotation, checker, esTreeNodeMap) &&
+                    !hasTypedDecorator) {
                     // Complex types should have @ValidateNested()
                     if (!hasValidateNested && decorators.length > 0) {
                         context.report({
@@ -901,6 +979,29 @@ exports.default = createRule({
                         });
                     }
                 }
+                // Check if complex non-array types with @ValidateNested also have @Type
+                if (!isArrayType(typeAnnotation) &&
+                    isComplexType(typeAnnotation, checker, esTreeNodeMap) &&
+                    hasValidateNested &&
+                    !hasTypeDecorator) {
+                    let typeToCheck = typeAnnotation;
+                    // Handle nullable complex types: Address | null | undefined
+                    const nullableCheck = isNullableUnion(typeAnnotation);
+                    if (nullableCheck.isNullable && nullableCheck.baseType) {
+                        typeToCheck = nullableCheck.baseType;
+                    }
+                    if (typeToCheck.type === 'TSTypeReference') {
+                        const className = getTypeReferenceName(typeToCheck.typeName);
+                        context.report({
+                            node,
+                            messageId: 'missingTypeDecorator',
+                            data: {
+                                actualType: className,
+                                className,
+                            },
+                        });
+                    }
+                }
             },
         };
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-class-validator-type-match",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "ESLint plugin to ensure class-validator decorators match TypeScript type annotations",
   "keywords": [
     "eslint",