eslint-plugin-class-validator-type-match 3.1.1 → 3.1.3

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/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

@@ -6,6 +6,15 @@ const type_helpers_util_1 = require("../utils/type-helpers.util");
  * Creates an ESLint rule with proper documentation URL
  */
 const createRule = utils_1.ESLintUtils.RuleCreator((name) => `https://github.com/robertlinde/eslint-plugin-class-validator-type-match#${name}`);
+/**
+ * Maps JavaScript wrapper class names to their corresponding primitive type names.
+ * Used to validate @Type(() => Number) with `number` type, etc.
+ */
+const PRIMITIVE_WRAPPER_MAP = {
+    Number: 'number',
+    String: 'string',
+    Boolean: 'boolean',
+};
 /**
  * ESLint rule to ensure @Type(() => ClassName) decorator matches TypeScript type annotations.
  *
@@ -129,15 +138,18 @@ exports.default = createRule({
                             }
                         }
                         else {
-                            // @Type is used with a primitive type
-                            context.report({
-                                node,
-                                messageId: 'typeMismatch',
-                                data: {
-                                    typeDecoratorClass: typeClassName,
-                                    actualType,
-                                },
-                            });
+                            // @Type is used with a primitive type - check if it's a valid wrapper class match
+                            const expectedPrimitive = PRIMITIVE_WRAPPER_MAP[typeClassName];
+                            if (!expectedPrimitive || expectedPrimitive !== actualType) {
+                                context.report({
+                                    node,
+                                    messageId: 'typeMismatch',
+                                    data: {
+                                        typeDecoratorClass: typeClassName,
+                                        actualType,
+                                    },
+                                });
+                            }
                         }
                     }
                     // For array types, check if @Type matches the array element type
@@ -158,17 +170,20 @@ exports.default = createRule({
                                 }
                             }
                             else {
-                                // @Type is used with an array of primitives
+                                // @Type is used with an array of primitives - check if it's a valid wrapper class match
                                 const elementType = (0, type_helpers_util_1.getTypeString)(elementTypeNode, checker, esTreeNodeMap);
                                 if (elementType) {
-                                    context.report({
-                                        node,
-                                        messageId: 'typeMismatch',
-                                        data: {
-                                            typeDecoratorClass: typeClassName,
-                                            actualType: `${elementType}[]`,
-                                        },
-                                    });
+                                    const expectedPrimitive = PRIMITIVE_WRAPPER_MAP[typeClassName];
+                                    if (!expectedPrimitive || expectedPrimitive !== elementType) {
+                                        context.report({
+                                            node,
+                                            messageId: 'typeMismatch',
+                                            data: {
+                                                typeDecoratorClass: typeClassName,
+                                                actualType: `${elementType}[]`,
+                                            },
+                                        });
+                                    }
                                 }
                             }
                         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-class-validator-type-match",
-  "version": "3.1.1",
+  "version": "3.1.3",
   "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
 }
 ```