eslint-plugin-class-validator-type-match 0.1.1

package/LICENCE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Robert Linde
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+declare const _default: {
+    rules: {
+        'decorator-type-match': import("@typescript-eslint/utils/dist/ts-eslint").RuleModule<"mismatch", [], unknown, import("@typescript-eslint/utils/dist/ts-eslint").RuleListener>;
+    };
+    configs: {
+        recommended: {
+            plugins: string[];
+            rules: {
+                'class-validator-type-match/decorator-type-match': string;
+            };
+        };
+    };
+};
+export = _default;

package/dist/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const decorator_type_match_1 = __importDefault(require("./rules/decorator-type-match"));
+module.exports = {
+    rules: {
+        'decorator-type-match': decorator_type_match_1.default,
+    },
+    configs: {
+        recommended: {
+            plugins: ['class-validator-type-match'],
+            rules: {
+                'class-validator-type-match/decorator-type-match': 'error',
+            },
+        },
+    },
+};

package/dist/rules/decorator-type-match.d.ts

@@ -0,0 +1,23 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+/**
+ * ESLint rule to ensure class-validator decorators match TypeScript type annotations.
+ *
+ * This rule prevents common mistakes where the decorator type (e.g., @IsString)
+ * doesn't match the actual TypeScript type annotation (e.g., number).
+ *
+ * @example
+ * // ❌ Bad - will trigger error
+ * class User {
+ *   @IsString()
+ *   name!: number;
+ * }
+ *
+ * @example
+ * // ✅ Good - types match
+ * class User {
+ *   @IsString()
+ *   name!: string;
+ * }
+ */
+declare const _default: ESLintUtils.RuleModule<"mismatch", [], unknown, ESLintUtils.RuleListener>;
+export default _default;

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

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("@typescript-eslint/utils");
+/**
+ * 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}`);
+/**
+ * Mapping of class-validator decorators to their expected TypeScript types.
+ * Empty arrays indicate decorators that can accept any type.
+ *
+ * @example
+ * IsString: ["string"] - expects string type
+ * IsOptional: [] - accepts any type
+ */
+const decoratorTypeMap = {
+    // String validators
+    IsString: ['string'],
+    IsNotEmpty: [], // Can be any type
+    // Number validators
+    IsNumber: ['number'],
+    IsInt: ['number'],
+    IsPositive: ['number'],
+    IsNegative: ['number'],
+    Min: ['number'],
+    Max: ['number'],
+    // Boolean validators
+    IsBoolean: ['boolean'],
+    // Date validators
+    IsDate: ['Date'],
+    MinDate: ['Date'],
+    MaxDate: ['Date'],
+    // Array validators
+    IsArray: ['array', 'Array'],
+    ArrayMinSize: ['array', 'Array'],
+    ArrayMaxSize: ['array', 'Array'],
+    // Object validators
+    IsObject: ['object'],
+    // Enum validators
+    IsEnum: ['enum'],
+    // Type-agnostic validators (no type checking)
+    IsOptional: [],
+    ValidateNested: [],
+    IsDefined: [],
+    IsEmpty: [],
+    Equals: [],
+    NotEquals: [],
+    IsIn: [],
+    IsNotIn: [],
+};
+/**
+ * ESLint rule to ensure class-validator decorators match TypeScript type annotations.
+ *
+ * This rule prevents common mistakes where the decorator type (e.g., @IsString)
+ * doesn't match the actual TypeScript type annotation (e.g., number).
+ *
+ * @example
+ * // ❌ Bad - will trigger error
+ * class User {
+ *   @IsString()
+ *   name!: number;
+ * }
+ *
+ * @example
+ * // ✅ Good - types match
+ * class User {
+ *   @IsString()
+ *   name!: string;
+ * }
+ */
+exports.default = createRule({
+    name: 'decorator-type-match',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Ensure class-validator decorators match TypeScript type annotations',
+        },
+        messages: {
+            mismatch: 'Decorator @{{decorator}} does not match type annotation {{actualType}}. Expected: {{expectedTypes}}',
+        },
+        schema: [],
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            /**
+             * Analyzes class property definitions to check if decorators match type annotations
+             * @param node - The PropertyDefinition AST node to analyze
+             */
+            PropertyDefinition(node) {
+                // Skip if no decorators present
+                if (!node.decorators || node.decorators.length === 0)
+                    return;
+                // Skip if no type annotation
+                if (!node.typeAnnotation)
+                    return;
+                /**
+                 * Extract decorator names from the property.
+                 * Handles both @Decorator and @Decorator() syntax for maximum compatibility.
+                 */
+                const decorators = node.decorators
+                    .filter((d) => d.expression.type === 'CallExpression' || d.expression.type === 'Identifier')
+                    .map((d) => {
+                    if (d.expression.type === 'CallExpression' && d.expression.callee.type === 'Identifier') {
+                        return d.expression.callee.name;
+                    }
+                    if (d.expression.type === 'Identifier') {
+                        return d.expression.name;
+                    }
+                    return null;
+                })
+                    .filter((name) => name !== null);
+                const { typeAnnotation } = node.typeAnnotation;
+                let actualType = null;
+                /**
+                 * Determine the actual TypeScript type from the annotation.
+                 * Supports primitive types, arrays, and type references.
+                 */
+                switch (typeAnnotation.type) {
+                    case 'TSStringKeyword': {
+                        actualType = 'string';
+                        break;
+                    }
+                    case 'TSNumberKeyword': {
+                        actualType = 'number';
+                        break;
+                    }
+                    case 'TSBooleanKeyword': {
+                        actualType = 'boolean';
+                        break;
+                    }
+                    case 'TSArrayType': {
+                        actualType = 'array';
+                        break;
+                    }
+                    case 'TSTypeReference': {
+                        if (typeAnnotation.typeName.type === 'Identifier') {
+                            actualType = typeAnnotation.typeName.name;
+                        }
+                        break;
+                    }
+                    // No default
+                }
+                // Skip if we couldn't determine the type
+                if (!actualType)
+                    return;
+                /**
+                 * Check each decorator against the actual type.
+                 * Report an error if there's a mismatch.
+                 */
+                for (const decorator of decorators) {
+                    const expectedTypes = decoratorTypeMap[decorator];
+                    // Skip decorators not in our map
+                    if (!expectedTypes)
+                        continue;
+                    // Skip type-agnostic decorators (empty array)
+                    if (expectedTypes.length === 0)
+                        continue;
+                    /**
+                     * Check if the actual type matches any of the expected types.
+                     * Handles both 'array' and 'Array' as equivalent.
+                     */
+                    const matches = expectedTypes.some((expected) => {
+                        if (expected === 'array' && actualType === 'Array')
+                            return true;
+                        if (expected === 'Array' && actualType === 'array')
+                            return true;
+                        return expected === actualType;
+                    });
+                    // Report mismatch
+                    if (!matches) {
+                        context.report({
+                            node,
+                            messageId: 'mismatch',
+                            data: {
+                                decorator,
+                                actualType,
+                                expectedTypes: expectedTypes.join(' or '),
+                            },
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "eslint-plugin-class-validator-type-match",
+  "version": "0.1.1",
+  "description": "ESLint plugin to ensure class-validator decorators match TypeScript type annotations",
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "class-validator",
+    "typescript",
+    "decorators"
+  ],
+  "author": "Robert Linde",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/robertlinde/eslint-plugin-class-validator-type-match"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "lint": "eslint \"src/**/*.ts\"",
+    "lint:fix": "eslint \"src/**/*.ts\" --fix",
+    "format": "prettier --write \"**/*.{ts,md}\"",
+    "prepare": "husky"
+  },
+  "peerDependencies": {
+    "@typescript-eslint/parser": "^6.0.0 || ^7.0.0 || ^8.0.0",
+    "eslint": "^8.0.0 || ^9.0.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "20.1.0",
+    "@commitlint/config-conventional": "20.0.0",
+    "@eslint/js": "9.37.0",
+    "@typescript-eslint/parser": "8.46.0",
+    "eslint": "9.37.0",
+    "globals": "16.4.0",
+    "husky": "9.1.7",
+    "lint-staged": "16.2.4",
+    "prettier": "3.6.2",
+    "typescript": "^5.6.0",
+    "typescript-eslint": "8.46.0"
+  },
+  "engines": {
+    "node": ">=16.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,75 @@
+# eslint-plugin-class-validator-type-match
+
+ESLint plugin to ensure class-validator decorators match TypeScript type annotations.
+
+## Installation
+
+**npm**
+
+```bash
+npm install --save-dev eslint-plugin-class-validator-type-match
+```
+
+**yarn**
+
+```bash
+yarn add -D eslint-plugin-class-validator-type-match
+```
+
+## Usage
+
+// .eslintrc.js
+
+```javascript
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  plugins: ['class-validator-type-match'],
+  rules: {
+    'class-validator-type-match/decorator-type-match': 'error',
+  },
+};
+```
+
+Or use the recommended config:
+
+```javascript
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  extends: ['plugin:class-validator-type-match/recommended'],
+};
+```
+
+## Example
+
+```javascript
+module.exports = {
+  parser: '@typescript-eslint/parser',
+  extends: ['plugin:class-validator-type-match/recommended'],
+};
+```
+
+## Example
+
+```typescript
+import {IsString, IsNumber} from 'class-validator';
+
+class User {
+  @IsString()
+  name!: number; // ❌ Error: Decorator @IsString does not match type annotation number
+
+  @IsNumber()
+  age!: string; // ❌ Error: Decorator @IsNumber does not match type annotation string
+
+  @IsString()
+  email!: string; // ✅ Correct
+}
+```
+
+## Supported Decorators
+
+- `@IsString` → string
+- `@IsNumber` / `@IsInt` → number
+- `@IsBoolean` → boolean
+- `@IsArray` → array or Array<T>
+- `@IsDate` → Date
+- `@IsObject` → object