eslint-plugin-class-validator-type-match 3.1.0 → 3.1.2

package/dist/index.d.ts

@@ -8,7 +8,7 @@ declare const _default: {
         }], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
         'validate-nested-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"nestedArrayMismatch" | "missingValidateNested" | "missingEachOption" | "unnecessaryValidateNested" | "tupleValidationWarning" | "multiTypeUnionWarning" | "mixedComplexityUnionWarning" | "pickOmitWarning", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
         'type-decorator-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"typeMismatch" | "missingTypeDecorator", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
-        'definite-assignment-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"missingDefiniteAssignment", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+        'definite-assignment-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"incorrectDefiniteAssignment", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
         'dto-filename-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"incorrectDtoClassName", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
     };
     configs: {

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

@@ -122,7 +122,8 @@ exports.default = createRule({
                     return;
                 const hasIsEnum = decorators.includes('IsEnum');
                 // Validate @IsEnum argument matches the type annotation for enum type references
-                if (hasIsEnum && typeAnnotation.type === 'TSTypeReference') {
+                // Skip this check for array types with { each: true }, as those validate array elements
+                if (hasIsEnum && typeAnnotation.type === 'TSTypeReference' && !(0, type_helpers_util_1.isArrayType)(typeAnnotation)) {
                     const isEnumDecorator = node.decorators?.find((d) => d.expression.type === 'CallExpression' &&
                         d.expression.callee.type === 'Identifier' &&
                         d.expression.callee.name === 'IsEnum');

package/dist/rules/definite-assignment-match.d.ts

@@ -1,24 +1,29 @@
 import { ESLintUtils } from '@typescript-eslint/utils';
 /**
- * ESLint rule to ensure properties with decorators use definite assignment assertion (!) when required.
+ * ESLint rule to ensure definite assignment assertion (!) is used correctly with decorators.
  *
  * This rule validates that:
- * - Properties with decorators that are not optional (no ?)
- * - Don't have an initializer (no = value)
- * - Don't have undefined in their type
- * - Use the definite assignment assertion (!)
- *
- * Note: Properties with | null still require ! unless they also have ?
+ * - Properties with ! should NOT have:
+ *   - Optional marker (?)
+ *   - An initializer (= value)
+ *   - undefined in their type
  *
  * @example
- * // ✅ Good - has definite assignment assertion
+ * // ✅ Good - ! without optional or initializer
  * class User {
  *   @IsString()
  *   name!: string;
  * }
  *
  * @example
- * // ✅ Good - optional property doesn't need !
+ * // ✅ Good - no ! is also fine for non-optional
+ * class User {
+ *   @IsString()
+ *   name: string;
+ * }
+ *
+ * @example
+ * // ✅ Good - optional property without !
  * class User {
  *   @IsOptional()
  *   @IsString()
@@ -26,32 +31,40 @@ import { ESLintUtils } from '@typescript-eslint/utils';
  * }
  *
  * @example
- * // ✅ Good - has initializer
+ * // ✅ Good - has initializer without !
  * class User {
  *   @IsString()
  *   name: string = 'default';
  * }
  *
  * @example
- * // ✅ Good - has undefined in type
+ * // ✅ Good - has undefined in type without !
  * class User {
  *   @IsString()
  *   name: string | undefined;
  * }
  *
  * @example
- * // ❌ Bad - missing definite assignment assertion
+ * // ❌ Bad - ! with optional property
  * class User {
+ *   @IsOptional()
  *   @IsString()
- *   name: string;
+ *   name?!: string;
+ * }
+ *
+ * @example
+ * // ❌ Bad - ! with initializer
+ * class User {
+ *   @IsString()
+ *   name!: string = 'default';
  * }
  *
  * @example
- * // ❌ Bad - null doesn't count, still needs !
+ * // ❌ Bad - ! with undefined in type
  * class User {
  *   @IsString()
- *   name: string | null;
+ *   name!: string | undefined;
  * }
  */
-declare const _default: ESLintUtils.RuleModule<"missingDefiniteAssignment", [], unknown, ESLintUtils.RuleListener>;
+declare const _default: ESLintUtils.RuleModule<"incorrectDefiniteAssignment", [], unknown, ESLintUtils.RuleListener>;
 export default _default;

package/dist/rules/definite-assignment-match.js

@@ -7,25 +7,30 @@ const type_helpers_util_1 = require("../utils/type-helpers.util");
  */
 const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/robertlinde/eslint-plugin-class-validator-type-match#${name}`);
 /**
- * ESLint rule to ensure properties with decorators use definite assignment assertion (!) when required.
+ * ESLint rule to ensure definite assignment assertion (!) is used correctly with decorators.
  *
  * This rule validates that:
- * - Properties with decorators that are not optional (no ?)
- * - Don't have an initializer (no = value)
- * - Don't have undefined in their type
- * - Use the definite assignment assertion (!)
- *
- * Note: Properties with | null still require ! unless they also have ?
+ * - Properties with ! should NOT have:
+ *   - Optional marker (?)
+ *   - An initializer (= value)
+ *   - undefined in their type
  *
  * @example
- * // ✅ Good - has definite assignment assertion
+ * // ✅ Good - ! without optional or initializer
  * class User {
  *   @IsString()
  *   name!: string;
  * }
  *
  * @example
- * // ✅ Good - optional property doesn't need !
+ * // ✅ Good - no ! is also fine for non-optional
+ * class User {
+ *   @IsString()
+ *   name: string;
+ * }
+ *
+ * @example
+ * // ✅ Good - optional property without !
  * class User {
  *   @IsOptional()
  *   @IsString()
@@ -33,31 +38,39 @@ const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com
  * }
  *
  * @example
- * // ✅ Good - has initializer
+ * // ✅ Good - has initializer without !
  * class User {
  *   @IsString()
  *   name: string = 'default';
  * }
  *
  * @example
- * // ✅ Good - has undefined in type
+ * // ✅ Good - has undefined in type without !
  * class User {
  *   @IsString()
  *   name: string | undefined;
  * }
  *
  * @example
- * // ❌ Bad - missing definite assignment assertion
+ * // ❌ Bad - ! with optional property
  * class User {
+ *   @IsOptional()
  *   @IsString()
- *   name: string;
+ *   name?!: string;
+ * }
+ *
+ * @example
+ * // ❌ Bad - ! with initializer
+ * class User {
+ *   @IsString()
+ *   name!: string = 'default';
  * }
  *
  * @example
- * // ❌ Bad - null doesn't count, still needs !
+ * // ❌ Bad - ! with undefined in type
  * class User {
  *   @IsString()
- *   name: string | null;
+ *   name!: string | undefined;
  * }
  */
 exports.default = createRule({
@@ -65,10 +78,10 @@ exports.default = createRule({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Ensure properties with decorators use definite assignment assertion (!) when they are not optional, not initialized, and do not have undefined in their type',
+            description: 'Ensure definite assignment assertion (!) is not used with optional properties, initializers, or undefined types',
         },
         messages: {
-            missingDefiniteAssignment: 'Property {{propertyName}} with type {{propertyType}} requires definite assignment assertion (!). Change to: {{propertyName}}!: {{propertyType}}',
+            incorrectDefiniteAssignment: 'Property {{propertyName}} should not use definite assignment assertion (!) because it {{reason}}. Remove the ! from: {{propertyName}}!',
         },
         schema: [],
         fixable: 'code',
@@ -105,37 +118,46 @@ exports.default = createRule({
                 if (!actualType)
                     return;
                 /**
-                 * Check for missing definite assignment assertion (!)
-                 * Properties with decorators that are:
-                 * - Not optional (no ?)
-                 * - Not initialized (no = value)
-                 * - Don't have undefined in their type
-                 * Should use the definite assignment assertion (!)
-                 * Note: Properties with | null still require ! unless they also have ?
+                 * Check for incorrect usage of definite assignment assertion (!)
+                 * Properties should NOT use ! if they:
+                 * - Are optional (have ?)
+                 * - Have an initializer (= value)
+                 * - Have undefined in their type
                  */
                 const isOptionalProperty = node.optional === true;
                 const hasInitializer = node.value !== undefined && node.value !== null;
                 const hasDefiniteAssignment = node.definite === true;
                 const hasUndefinedInType = typeAnnotation.type === 'TSUndefinedKeyword' ||
                     (typeAnnotation.type === 'TSUnionType' && typeAnnotation.types.some((t) => t.type === 'TSUndefinedKeyword'));
-                // If property is not optional, not initialized, doesn't have undefined in type,
-                // and doesn't have definite assignment, report an error
-                if (!isOptionalProperty && !hasInitializer && !hasUndefinedInType && !hasDefiniteAssignment) {
+                // If property has definite assignment (!), check if it's used incorrectly
+                if (hasDefiniteAssignment) {
                     const propertyName = node.key.type === 'Identifier' ? node.key.name : 'property';
-                    context.report({
-                        node,
-                        messageId: 'missingDefiniteAssignment',
-                        data: {
-                            propertyName,
-                            propertyType: actualType,
-                        },
-                        fix(fixer) {
-                            // Find position after property key (and after optional marker if present)
-                            // We need to insert ! before the : type annotation
-                            const keyEnd = node.key.range[1];
-                            return fixer.insertTextAfterRange([keyEnd, keyEnd], '!');
-                        },
-                    });
+                    let reason = null;
+                    if (isOptionalProperty) {
+                        reason = 'is optional (has ?)';
+                    }
+                    else if (hasInitializer) {
+                        reason = 'has an initializer';
+                    }
+                    else if (hasUndefinedInType) {
+                        reason = 'has undefined in its type';
+                    }
+                    if (reason) {
+                        context.report({
+                            node,
+                            messageId: 'incorrectDefiniteAssignment',
+                            data: {
+                                propertyName,
+                                reason,
+                            },
+                            fix(fixer) {
+                                // Remove the ! after the property key
+                                const keyEnd = node.key.range[1];
+                                // The ! is between the key and the optional marker or colon
+                                return fixer.removeRange([keyEnd, keyEnd + 1]);
+                            },
+                        });
+                    }
                 }
             },
         };

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

@@ -179,25 +179,30 @@ exports.default = createRule({
                     (0, type_helpers_util_1.isComplexType)(typeAnnotation, checker, esTreeNodeMap) &&
                     hasValidateNested &&
                     !hasTypeDecorator) {
-                    let typeToCheck = typeAnnotation;
-                    // Handle nullable complex types: Address | null | undefined
-                    const nullableCheck = (0, type_helpers_util_1.isNullableUnion)(typeAnnotation);
-                    if (nullableCheck.isNullable && nullableCheck.baseType) {
-                        typeToCheck = nullableCheck.baseType;
-                    }
-                    // Unwrap utility types to get the base class name
-                    const unwrappedType = (0, type_helpers_util_1.unwrapUtilityTypeForClassName)(typeToCheck);
-                    if (unwrappedType.type === 'TSTypeReference') {
-                        const className = (0, type_helpers_util_1.getTypeReferenceName)(unwrappedType.typeName);
-                        const displayType = (0, type_helpers_util_1.getTypeString)(typeToCheck, checker, esTreeNodeMap);
-                        context.report({
-                            node,
-                            messageId: 'missingTypeDecorator',
-                            data: {
-                                actualType: displayType || className,
-                                className,
-                            },
-                        });
+                    // Check if there's an @IsEnum decorator (single enum doesn't need each: true)
+                    // This indicates it's an enum and doesn't need @Type
+                    const hasIsEnum = decorators.includes('IsEnum');
+                    if (!hasIsEnum) {
+                        let typeToCheck = typeAnnotation;
+                        // Handle nullable complex types: Address | null | undefined
+                        const nullableCheck = (0, type_helpers_util_1.isNullableUnion)(typeAnnotation);
+                        if (nullableCheck.isNullable && nullableCheck.baseType) {
+                            typeToCheck = nullableCheck.baseType;
+                        }
+                        // Unwrap utility types to get the base class name
+                        const unwrappedType = (0, type_helpers_util_1.unwrapUtilityTypeForClassName)(typeToCheck);
+                        if (unwrappedType.type === 'TSTypeReference') {
+                            const className = (0, type_helpers_util_1.getTypeReferenceName)(unwrappedType.typeName);
+                            const displayType = (0, type_helpers_util_1.getTypeString)(typeToCheck, checker, esTreeNodeMap);
+                            context.report({
+                                node,
+                                messageId: 'missingTypeDecorator',
+                                data: {
+                                    actualType: displayType || className,
+                                    className,
+                                },
+                            });
+                        }
                     }
                 }
                 // Check if array of complex types with @ValidateNested also have @Type
@@ -205,7 +210,35 @@ exports.default = createRule({
                     const elementTypeNode = (0, type_helpers_util_1.getArrayElementTypeNode)(typeAnnotation);
                     if (elementTypeNode) {
                         const isElementComplex = (0, type_helpers_util_1.isComplexType)(elementTypeNode, checker, esTreeNodeMap);
-                        if (isElementComplex) {
+                        // Check if there's an @IsEnum decorator with { each: true }
+                        // This indicates the array elements are enums and don't need @Type
+                        const hasIsEnumWithEach = decorators.includes('IsEnum') &&
+                            node.decorators?.some((d) => {
+                                if (d.expression.type === 'CallExpression' &&
+                                    d.expression.callee.type === 'Identifier' &&
+                                    d.expression.callee.name === 'IsEnum') {
+                                    // Check if it has { each: true }
+                                    const args = d.expression.arguments;
+                                    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;
+                            });
+                        if (isElementComplex && !hasIsEnumWithEach) {
                             let elementTypeToCheck = elementTypeNode;
                             // Handle nullable element types: (Address | null)[]
                             const nullableCheck = (0, type_helpers_util_1.isNullableUnion)(elementTypeNode);

package/dist/rules/validate-nested-match.js

@@ -170,7 +170,39 @@ exports.default = createRule({
                     if (elementTypeNode) {
                         const elementTypeName = (0, type_helpers_util_1.getTypeString)(elementTypeNode, checker, esTreeNodeMap);
                         const isElementComplex = (0, type_helpers_util_1.isComplexType)(elementTypeNode, checker, esTreeNodeMap);
+                        // Check if there's an @IsEnum decorator with { each: true }
+                        // This indicates the array elements are enums and don't need @ValidateNested
+                        const hasIsEnumWithEach = decorators.includes('IsEnum') &&
+                            node.decorators?.some((d) => {
+                                if (d.expression.type === 'CallExpression' &&
+                                    d.expression.callee.type === 'Identifier' &&
+                                    d.expression.callee.name === 'IsEnum') {
+                                    // Check if it has { each: true }
+                                    const args = d.expression.arguments;
+                                    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;
+                            });
                         if (isElementComplex && elementTypeName) {
+                            // Skip validation if @IsEnum({ each: true }) is present - enums are handled by @IsEnum
+                            if (hasIsEnumWithEach) {
+                                return;
+                            }
                             // Complex element type - requires @ValidateNested({ each: true })
                             if (!hasValidateNested) {
                                 context.report({

package/dist/utils/type-helpers.util.js

@@ -537,6 +537,26 @@ function isComplexType(typeNode, checker = null, esTreeNodeMap = null) {
         if (nonValidatableTypes.includes(typeName)) {
             return false;
         }
+        // Check if it's an enum type by using the type checker
+        // Enums are type references but should not be treated as complex types
+        // They can be validated with @IsEnum instead of @ValidateNested
+        if (checker && esTreeNodeMap) {
+            const tsNode = esTreeNodeMap.get(unwrapped);
+            if (tsNode) {
+                try {
+                    const type = checker.getTypeAtLocation(tsNode);
+                    // Check if it's an enum type using TypeScript's type flags
+                    // ts.TypeFlags.Enum = 1 << 10 = 1024
+                    // ts.TypeFlags.EnumLiteral = 1 << 11 = 2048
+                    if (type.flags & 1024 || type.flags & 2048) {
+                        return false;
+                    }
+                }
+                catch {
+                    // If we can't determine, continue with other checks
+                }
+            }
+        }
         // Check for utility types - delegate to the underlying type
         const utilityTypeInfo = getUtilityTypeArgument(unwrapped);
         if (utilityTypeInfo) {

package/package.json

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

package/readme.md

@@ -148,7 +148,7 @@ class User {
 
 ### `definite-assignment-match`
 
-Ensures properties with decorators use definite assignment assertion (`!`) when required.
+Ensures definite assignment assertion (`!`) is used correctly with decorators.
 
 **Examples:**
 
@@ -157,20 +157,24 @@ import {IsString, IsOptional} from 'class-validator';
 
 class User {
   @IsString()
-  name!: string; // ✅ Correct - has definite assignment
+  name!: string; // ✅ Correct - ! can be used for non-optional
 
   @IsString()
-  email: string; // ❌ Error: Missing definite assignment assertion (!)
+  email: string; // ✅ Correct - ! is optional for non-optional properties
 
   @IsOptional()
   @IsString()
-  bio?: string; // ✅ Correct - optional property doesn't need !
+  bio?: string; // ✅ Correct - optional property without !
+
+  @IsOptional()
+  @IsString()
+  username?!: string; // ❌ Error: ! should not be used with optional (?)
 
   @IsString()
-  nickname: string = 'default'; // ✅ Correct - has initializer
+  nickname!: string = 'default'; // ❌ Error: ! should not be used with initializer
 
   @IsString()
-  description: string | undefined; // ✅ Correct - has undefined in type
+  description!: string | undefined; // ❌ Error: ! should not be used with undefined type
 }
 ```