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

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

@@ -73,7 +73,7 @@ exports.default = createRule({
         let checker = null;
         let esTreeNodeMap = null;
         try {
-            const parserServices = context.parserServices;
+            const parserServices = context.sourceCode.parserServices;
             if (parserServices?.program && parserServices?.esTreeNodeToTSNodeMap) {
                 checker = parserServices.program.getTypeChecker();
                 esTreeNodeMap = parserServices.esTreeNodeToTSNodeMap;
@@ -131,7 +131,9 @@ exports.default = createRule({
                         const enumArg = (0, type_helpers_util_1.getIsEnumArgument)(isEnumDecorator);
                         const typeName = (0, type_helpers_util_1.getTypeReferenceName)(typeAnnotation.typeName);
                         // For TypeScript enum references, the argument should match the type
-                        if (enumArg && enumArg !== typeName) {
+                        // Skip this check if the argument is an array of enum values (subset pattern)
+                        const isArraySubset = (0, type_helpers_util_1.isEnumArgumentArraySubset)(isEnumDecorator, checker, esTreeNodeMap);
+                        if (enumArg && enumArg !== typeName && !isArraySubset) {
                             context.report({
                                 node,
                                 messageId: 'enumMismatch',

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/dist/utils/type-helpers.util.d.ts

@@ -128,6 +128,20 @@ export declare function isUnionEnumType(typeNode: TSESTree.TypeNode): boolean;
  * Handles both simple identifiers (MyEnum) and member expressions (MyNamespace.MyEnum).
  */
 export declare function getIsEnumArgument(decorator: TSESTree.Decorator): string | null;
+/**
+ * Checks if the @IsEnum decorator argument is an array of enum values.
+ * This is a valid class-validator pattern for restricting validation to a subset of enum values.
+ *
+ * Example:
+ *   const WEIGHT_UNITS = [Unit.G, Unit.KG] as const;
+ *   @IsEnum(WEIGHT_UNITS)
+ *   unit?: Unit;
+ *
+ * Uses TypeScript type checker to determine if the argument resolves to an array/tuple type.
+ */
+export declare function isEnumArgumentArraySubset(decorator: TSESTree.Decorator, checker: ts.TypeChecker | null, esTreeNodeMap: {
+    get(key: TSESTree.Node): ts.Node | undefined;
+} | null): boolean;
 /**
  * Extracts the class name from @Type(() => ClassName) decorator.
  * Supports both arrow functions and function expressions.

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

@@ -18,6 +18,7 @@ exports.isArrayType = isArrayType;
 exports.isTupleType = isTupleType;
 exports.isUnionEnumType = isUnionEnumType;
 exports.getIsEnumArgument = getIsEnumArgument;
+exports.isEnumArgumentArraySubset = isEnumArgumentArraySubset;
 exports.getTypeDecoratorClassName = getTypeDecoratorClassName;
 exports.hasEachOption = hasEachOption;
 exports.hasValidateNestedEachOption = hasValidateNestedEachOption;
@@ -670,6 +671,46 @@ function getIsEnumArgument(decorator) {
     }
     return null;
 }
+/**
+ * Checks if the @IsEnum decorator argument is an array of enum values.
+ * This is a valid class-validator pattern for restricting validation to a subset of enum values.
+ *
+ * Example:
+ *   const WEIGHT_UNITS = [Unit.G, Unit.KG] as const;
+ *   @IsEnum(WEIGHT_UNITS)
+ *   unit?: Unit;
+ *
+ * Uses TypeScript type checker to determine if the argument resolves to an array/tuple type.
+ */
+function isEnumArgumentArraySubset(decorator, checker, esTreeNodeMap) {
+    if (!checker || !esTreeNodeMap) {
+        return false;
+    }
+    if (decorator.expression.type !== 'CallExpression' || decorator.expression.arguments.length === 0) {
+        return false;
+    }
+    const firstArg = decorator.expression.arguments[0];
+    // Get the TypeScript node for the argument
+    const tsNode = esTreeNodeMap.get(firstArg);
+    if (!tsNode) {
+        return false;
+    }
+    try {
+        const type = checker.getTypeAtLocation(tsNode);
+        // Check if it's an array type
+        if (checker.isArrayType(type)) {
+            return true;
+        }
+        // Check if it's a tuple type (for `as const` arrays)
+        if (checker.isTupleType(type)) {
+            return true;
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Extracts the class name from @Type(() => ClassName) decorator.
  * Supports both arrow functions and function expressions.

package/package.json

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