eslint-plugin-class-validator-type-match 3.1.3 → 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/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.3",
+  "version": "3.1.4",
   "description": "ESLint plugin to ensure class-validator decorators match TypeScript type annotations",
   "keywords": [
     "eslint",