eslint-plugin-class-validator-type-match 4.1.7 → 4.1.9

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

@@ -220,6 +220,20 @@ exports.default = createRule({
                 return false;
             });
         };
+        /**
+         * Helper: Check if property has @ValidateIf decorator
+         */
+        const hasValidateIfDecorator = (node) => {
+            if (!node.decorators || node.decorators.length === 0)
+                return false;
+            return node.decorators.some((decorator) => {
+                const expr = decorator.expression;
+                if (expr.type === 'CallExpression' && expr.callee.type === 'Identifier') {
+                    return expr.callee.name === 'ValidateIf';
+                }
+                return false;
+            });
+        };
         /**
          * Helper: Create fixer to add ? to property
          */
@@ -362,7 +376,7 @@ exports.default = createRule({
                 /**
                  * Priority 5: Property is optional (?) but missing @IsOptional() decorator
                  */
-                if (isOptionalProperty && !hasDecorator) {
+                if (isOptionalProperty && !hasDecorator && !hasValidateIfDecorator(node)) {
                     issues.push({
                         messageId: 'missingOptionalDecorator',
                     });
@@ -371,7 +385,7 @@ exports.default = createRule({
                  * Priority 6: Type includes undefined but missing @IsOptional() and not optional
                  * Only check if strictNullChecks is enabled
                  */
-                if (strictNullChecks && hasUndefined && !hasDecorator && !isOptionalProperty) {
+                if (strictNullChecks && hasUndefined && !hasDecorator && !isOptionalProperty && !hasValidateIfDecorator(node)) {
                     issues.push({
                         messageId: 'undefinedUnionWithoutDecorator',
                     });

package/dist/utils/type-helpers.util.d.ts

@@ -163,6 +163,13 @@ export declare function hasEachOption(decorator: TSESTree.Decorator): boolean;
  * Returns false for decorators without parentheses or without the each option.
  */
 export declare function hasValidateNestedEachOption(decorator: TSESTree.Decorator): boolean;
+/**
+ * Checks if a type is an object-producing utility type or Record.
+ * These types always produce object types and should be valid with @IsObject.
+ *
+ * Includes: Record, Partial, Required, Pick, Omit, Readonly
+ */
+export declare function isObjectUtilityType(typeNode: TSESTree.TypeNode): boolean;
 /**
  * Validates if a decorator matches the TypeScript type annotation.
  * Handles special cases like @IsEnum validation, nullable unions, and utility types.

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

@@ -22,6 +22,7 @@ exports.isEnumArgumentArraySubset = isEnumArgumentArraySubset;
 exports.getTypeDecoratorClassName = getTypeDecoratorClassName;
 exports.hasEachOption = hasEachOption;
 exports.hasValidateNestedEachOption = hasValidateNestedEachOption;
+exports.isObjectUtilityType = isObjectUtilityType;
 exports.checkTypeMatch = checkTypeMatch;
 /**
  * Decorators that don't enforce specific types and can work with any type.
@@ -780,6 +781,21 @@ function hasEachOption(decorator) {
 function hasValidateNestedEachOption(decorator) {
     return hasEachOption(decorator);
 }
+/**
+ * Checks if a type is an object-producing utility type or Record.
+ * These types always produce object types and should be valid with @IsObject.
+ *
+ * Includes: Record, Partial, Required, Pick, Omit, Readonly
+ */
+function isObjectUtilityType(typeNode) {
+    const unwrapped = unwrapReadonlyOperator(typeNode);
+    if (unwrapped.type !== 'TSTypeReference') {
+        return false;
+    }
+    const typeName = getTypeReferenceName(unwrapped.typeName);
+    const objectUtilityTypes = ['Record', 'Partial', 'Required', 'Pick', 'Omit', 'Readonly'];
+    return objectUtilityTypes.includes(typeName);
+}
 /**
  * Validates if a decorator matches the TypeScript type annotation.
  * Handles special cases like @IsEnum validation, nullable unions, and utility types.
@@ -790,6 +806,10 @@ function checkTypeMatch(decorator, typeAnnotation, actualType, checker, esTreeNo
     if (!expectedTypes || expectedTypes.length === 0) {
         return true;
     }
+    // Special handling for @IsObject and @IsNotEmptyObject - utility types that produce objects
+    if ((decorator === 'IsObject' || decorator === 'IsNotEmptyObject') && isObjectUtilityType(typeAnnotation)) {
+        return true;
+    }
     // Special handling for @IsEnum
     if (decorator === 'IsEnum') {
         // @IsEnum should work with:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-class-validator-type-match",
-  "version": "4.1.7",
+  "version": "4.1.9",
   "description": "ESLint plugin to ensure class-validator decorators match TypeScript type annotations",
   "keywords": [
     "eslint",
@@ -37,25 +37,25 @@
     "eslint": "^9.0.0"
   },
   "dependencies": {
-    "@typescript-eslint/utils": "8.53.0"
+    "@typescript-eslint/utils": "8.56.1"
   },
   "devDependencies": {
-    "@commitlint/cli": "20.3.1",
-    "@commitlint/config-conventional": "20.3.1",
-    "@eslint/js": "9.39.2",
-    "@typescript-eslint/parser": "8.53.0",
-    "@typescript-eslint/rule-tester": "8.53.0",
-    "@vitest/coverage-v8": "4.0.17",
-    "eslint": "9.39.2",
-    "globals": "17.0.0",
+    "@commitlint/cli": "20.4.2",
+    "@commitlint/config-conventional": "20.4.2",
+    "@eslint/js": "9.39.3",
+    "@typescript-eslint/parser": "8.56.1",
+    "@typescript-eslint/rule-tester": "8.56.1",
+    "@vitest/coverage-v8": "4.0.18",
+    "eslint": "9.39.3",
+    "globals": "17.4.0",
     "husky": "9.1.7",
-    "lint-staged": "16.2.7",
-    "prettier": "3.8.0",
+    "lint-staged": "16.3.1",
+    "prettier": "3.8.1",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.53.0",
-    "vitest": "4.0.17"
+    "typescript-eslint": "8.56.1",
+    "vitest": "4.0.18"
   },
   "engines": {
-    "node": "v25.3.0"
+    "node": "25.7.0"
   }
 }