@dmitryrechkin/eslint-standard 1.5.7 → 1.5.8

package/README.md

@@ -62,6 +62,65 @@ export default config();
 - ✅ No console/debugging code
 - ✅ Enhanced type safety rules
 
+### Strict Mode
+Enterprise-grade architectural conventions for large-scale TypeScript monorepos. Enforces consistent project structure, naming conventions, and design patterns.
+
+```javascript
+import config from '@dmitryrechkin/eslint-standard';
+
+export default config({
+	strict: true,
+	tsconfigPath: './tsconfig.json'
+});
+```
+
+**Features:**
+- ✅ Enforced folder structure (services/, repositories/, helpers/, etc.)
+- ✅ Single Responsibility Principle for services and transformers
+- ✅ CQRS pattern enforcement for repositories
+- ✅ Static-only helpers, no static methods in other classes
+- ✅ Consistent interface naming conventions
+- ✅ One class per file
+
+#### Strict Mode Rules
+
+| Rule | Enforcement | Rationale |
+|------|-------------|-----------|
+| **Class Location** | `*Service` → `services/`, `*Repository` → `repositories/`, `*Helper` → `helpers/`, `*Factory` → `factories/`, `*Transformer` → `transformers/`, `*Registry` → `registries/`, `*Adapter` → `adapters/` | Predictable project structure enables faster navigation and onboarding |
+| **Service Single Method** | Services must have only one public method | Single Responsibility Principle - each service does one thing well |
+| **Transformer Single Method** | Transformers must have only one public method | Clear data transformation contracts |
+| **Helper Static Only** | Helper classes must contain only static methods | Helpers are utility collections, not stateful objects |
+| **No Static in Non-Helpers** | Non-helper/factory classes cannot have static methods | Prevents hidden global state, improves testability via dependency injection |
+| **Type Location** | `interface TypeXXX` must be in `types/` folder | Centralized type definitions for reusability |
+| **Interface Naming** | `TypeXXX` for data types, `XXXInterface` for class contracts | Clear distinction between data structures and behavioral contracts |
+| **One Class Per File** | Each file can contain only one class | Simplifies imports, improves code organization |
+| **Repository CQRS** | `CommandRepository` cannot have query methods (`get`, `find`, `list`), `QueryRepository` cannot have command methods (`create`, `update`, `delete`) | Command Query Responsibility Segregation for scalable data access |
+| **Folder CamelCase** | All folder names must be camelCase | Consistent naming across the codebase |
+| **Function Name Match Filename** | Top-level function name must match filename | Predictable imports and file discovery |
+
+#### Example Project Structure
+
+```
+src/
+├── services/
+│   ├── UserService.ts          # class UserService { execute() }
+│   └── PaymentService.ts       # class PaymentService { process() }
+├── repositories/
+│   ├── UserCommandRepository.ts # create(), update(), delete()
+│   └── UserQueryRepository.ts   # find(), getById(), list()
+├── helpers/
+│   └── ValidationHelper.ts      # static validate(), static sanitize()
+├── factories/
+│   └── UserFactory.ts           # static create()
+├── transformers/
+│   └── UserTransformer.ts       # transform()
+├── types/
+│   ├── TypeUser.ts              # interface TypeUser { id: string }
+│   └── TypePayment.ts           # interface TypePayment { amount: number }
+└── adapters/
+    └── StripeAdapter.ts         # class StripeAdapter
+```
+
 ## ⚙️ Configuration Options
 
 All configurations accept the same configuration options:
@@ -124,16 +183,22 @@ npx @dmitryrechkin/eslint-standard check-deps --install
 
 ## 📊 Preset Comparison
 
-| Feature | Standard | Aggressive | Library |
-|---------|----------|------------|---------|
-| Unused imports cleanup | ✅ | ✅ | ✅ |
-| Unused variables detection | Basic | Enhanced | Enhanced |
-| Dead code detection | Basic | ✅ | ✅ |
-| Unused exports check | ❌ | ✅ | Very Strict |
-| JSDoc requirements | Basic | Basic | Strict |
-| Console statements | Warning | Warning | Error |
-| Return type hints | Error | Error | Explicit |
-| Type safety | High | High | Very High |
+| Feature | Standard | Aggressive | Library | Strict Mode |
+|---------|----------|------------|---------|-------------|
+| Unused imports cleanup | ✅ | ✅ | ✅ | ✅ |
+| Unused variables detection | Basic | Enhanced | Enhanced | Basic |
+| Dead code detection | Basic | ✅ | ✅ | Basic |
+| Unused exports check | ❌ | ✅ | Very Strict | ❌ |
+| JSDoc requirements | Basic | Basic | Strict | Basic |
+| Console statements | Warning | Warning | Error | Warning |
+| Return type hints | Error | Error | Explicit | Error |
+| Type safety | High | High | Very High | High |
+| Folder structure enforcement | ❌ | ❌ | ❌ | ✅ |
+| Single Responsibility (Services) | ❌ | ❌ | ❌ | ✅ |
+| CQRS Repository pattern | ❌ | ❌ | ❌ | ✅ |
+| Interface naming conventions | ❌ | ❌ | ❌ | ✅ |
+| One class per file | ❌ | ❌ | ❌ | ✅ |
+| Static method restrictions | ❌ | ❌ | ❌ | ✅ |
 
 ## 📈 Industry Standards Comparison
 
@@ -198,6 +263,9 @@ Use **Library** preset - ensures clean public APIs and comprehensive documentati
 ### For Maximum Code Quality
 Use **Aggressive** preset - comprehensive unused code detection.
 
+### For Enterprise Monorepos
+Use **Strict Mode** - enforces architectural conventions, folder structure, and design patterns for large teams.
+
 ## 🔍 Example Projects
 
 ### React Application
@@ -235,6 +303,18 @@ export default config({
 });
 ```
 
+### Enterprise Monorepo
+```javascript
+// eslint.config.mjs
+import config from '@dmitryrechkin/eslint-standard';
+
+export default config({
+	strict: true,
+	tsconfigPath: './tsconfig.json',
+	ignores: ['dist/**', 'node_modules/**']
+});
+```
+
 ## 🤝 Contributing
 
 Issues and pull requests are welcome on [GitHub](https://github.com/dmitryrechkin/eslint-standard).

package/eslint.config.mjs

@@ -27,16 +27,19 @@ import unicornPlugin from 'eslint-plugin-unicorn';
 import noSecretsPlugin from 'eslint-plugin-no-secrets';
 import regexpPlugin from 'eslint-plugin-regexp';
 import functionalPlugin from 'eslint-plugin-functional';
+import standardConventionsPlugin from './src/plugins/standard-conventions.mjs';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import prettierConfig from 'eslint-config-prettier';
 // eslint-disable-next-line import/no-extraneous-dependencies
 import prettierPlugin from 'eslint-plugin-prettier';
+
 export default function ({
 	tsconfigPath = './tsconfig.json',
 	ignores = [],
 	files = [],
 	plugins = {},
 	rules = {},
+	strict = false,
 	prettierPlugin: externalPrettierPlugin = undefined
 } = {}) {
 	// Use external prettier plugin if provided, otherwise fallback to bundled one
@@ -77,6 +80,7 @@ export default function ({
 				'no-secrets': noSecretsPlugin,
 				'regexp': regexpPlugin,
 				'functional': functionalPlugin,
+				'standard-conventions': standardConventionsPlugin,
 				'prettier': activePrettierPlugin,
 				...plugins,
 			},
@@ -99,6 +103,7 @@ export default function ({
 				
 				// Original @dmitryrechkin/eslint-standard rules
 				'@typescript-eslint/explicit-function-return-type': 'error',
+				'@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
 				'@typescript-eslint/no-explicit-any': 'error', // Ban 'any' type for type safety
 
 				// Original coding guidelines - formatting rules disabled in favor of prettier
@@ -843,6 +848,81 @@ export default function ({
 				'unicorn/prefer-query-selector': 'off', // Allow different DOM query methods
 				'unicorn/prevent-abbreviations': 'off', // Allow abbreviations for domain-specific terms
 				
+				...(strict ? {
+					// Standard conventions for services, transformers, and function naming
+					'standard-conventions/service-single-public-method': 'error',
+					'standard-conventions/transformer-single-public-method': 'error',
+					'standard-conventions/function-name-match-filename': 'error',
+					'standard-conventions/folder-camel-case': 'error',
+
+					// Helper static-only rule: Helpers MUST have only static methods
+					'standard-conventions/helper-static-only': 'error',
+					// Non-helper classes should NOT have static methods (except Factories)
+					'standard-conventions/no-static-in-non-helpers': 'error',
+
+					// Class location rules: enforce proper folder structure
+					'standard-conventions/class-location': ['error', {
+						mappings: {
+							Service: 'services',
+							Repository: 'repositories',
+							Helper: 'helpers',
+							Factory: 'factories',
+							Transformer: 'transformers',
+							Registry: 'registries',
+							Adapter: 'adapters'
+						}
+					}],
+
+					// Type location rule: Types must be in types folder
+					'standard-conventions/type-location': 'error',
+
+					// One class per file rule
+					'standard-conventions/one-class-per-file': 'error',
+
+					// Repository CQRS enforcement
+					'standard-conventions/repository-cqrs': 'error',
+
+					'unicorn/filename-case': ['error', {
+						cases: {
+							camelCase: true,
+							pascalCase: true
+						}
+					}],
+					// Enforce Type prefix OR Interface suffix strictly
+					// TypeXXX for data types, XXXInterface for class contracts
+					'@typescript-eslint/naming-convention': [
+						'error',
+						{
+							selector: 'interface',
+							format: ['PascalCase'],
+							custom: {
+								regex: '(^Type[A-Z]|Interface$)',
+								match: true
+							}
+						},
+						{
+							selector: 'typeAlias',
+							format: ['PascalCase'],
+							custom: {
+								regex: '^Type[A-Z]',
+								match: true
+							}
+						},
+						{
+							selector: 'class',
+							format: ['PascalCase']
+						},
+						{
+							selector: 'enum',
+							format: ['PascalCase'],
+							custom: {
+								regex: '^Enum[A-Z]',
+								match: true
+							}
+						}
+					]
+				} : {}),
+
 				// Allow custom rules to be added
 				...rules
 			},

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@dmitryrechkin/eslint-standard",
 	"description": "This package provides a shared ESLint configuration which includes TypeScript support and a set of specific linting rules designed to ensure high-quality and consistent code style across projects.",
-	"version": "1.5.7",
+	"version": "1.5.8",
 	"main": "eslint.config.mjs",
 	"exports": {
 		".": "./eslint.config.mjs"
@@ -31,7 +31,8 @@
 		"test:spacing": "node tests/test-spacing-rules.mjs",
 		"test:switch-case": "node tests/test-switch-case-simple.mjs",
 		"test:cli": "node tests/test-cli.mjs",
-		"test:install": "node tests/test-install-simulation.mjs"
+		"test:install": "node tests/test-install-simulation.mjs",
+		"test:strict": "node tests/test-strict-conventions.mjs"
 	},
 	"keywords": [],
 	"author": "",
@@ -65,4 +66,4 @@
 		"prettier": "^3.0.0",
 		"typescript": "^5.0.0"
 	}
-}
+}

package/src/plugins/standard-conventions.mjs

@@ -0,0 +1,605 @@
+import path from 'node:path';
+
+/**
+ * Rule: Services must have only one public method
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const serviceSinglePublicMethodRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that services have only one public method',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (!node.id || !node.id.name.endsWith('Service')) {
+					return;
+				}
+
+				const publicMethods = node.body.body.filter(member => {
+					return (
+						member.type === 'MethodDefinition' &&
+						member.kind === 'method' &&
+						(member.accessibility === 'public' || !member.accessibility) &&
+						!member.static
+					);
+				});
+
+				if (publicMethods.length > 1) {
+					context.report({
+						node: node.id,
+						message: 'Service {{ name }} has {{ count }} public methods. Services should have only one public method.',
+						data: {
+							name: node.id.name,
+							count: publicMethods.length
+						}
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Top-level function name must match filename
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const functionNameMatchFilenameRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that top-level function name matches filename',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		const filename = path.basename(context.getFilename(), path.extname(context.getFilename()));
+
+		return {
+			FunctionDeclaration(node) {
+				// Only check top-level functions or functions inside exports
+				const isTopLevel = node.parent.type === 'Program' ||
+					(node.parent.type === 'ExportNamedDeclaration' && node.parent.parent.type === 'Program') ||
+					(node.parent.type === 'ExportDefaultDeclaration' && node.parent.parent.type === 'Program');
+
+				if (!isTopLevel) {
+					return;
+				}
+
+				if (node.id && node.id.name !== filename) {
+					// Special case: ignore if filename is 'index'
+					if (filename === 'index') {
+						return;
+					}
+
+					context.report({
+						node: node.id,
+						message: 'Function name "{{ name }}" does not match filename "{{ filename }}".',
+						data: {
+							name: node.id.name,
+							filename: filename
+						}
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Folder names must be camelCase
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const folderCamelCaseRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that folder names are camelCase',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			Program() {
+				const fullPath = context.getFilename();
+
+				if (fullPath === '<input>' || fullPath === '<text>') {
+					return;
+				}
+
+				const dirPath = path.dirname(fullPath);
+				const relativePath = path.relative(process.cwd(), dirPath);
+
+				if (!relativePath || relativePath === '.') {
+					return;
+				}
+
+				const folders = relativePath.split(path.sep);
+				const camelCaseRegex = /^[a-z][a-zA-Z0-9]*$/;
+
+				for (const folder of folders) {
+					// Skip node_modules, dist, tests, and hidden folders
+					if (folder === 'node_modules' || folder === 'dist' || folder === 'tests' || folder.startsWith('.')) {
+						continue;
+					}
+
+					// Skip common top-level folders that might not be camelCase (optional, but good for compatibility)
+					if (['src', 'apps', 'packages', 'tools', 'docs', 'config'].includes(folder)) {
+						continue;
+					}
+
+					if (!camelCaseRegex.test(folder)) {
+						context.report({
+							loc: { line: 1, column: 0 },
+							message: 'Folder name "{{ folder }}" should be camelCase.',
+							data: { folder }
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Helpers must have only static methods
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const helperStaticOnlyRule = {
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce that Helper classes only contain static methods',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (!node.id || !node.id.name.endsWith('Helper')) {
+					return;
+				}
+
+				const nonStaticMembers = node.body.body.filter(member => {
+					// Skip constructors
+					if (member.type === 'MethodDefinition' && member.kind === 'constructor') {
+						return false;
+					}
+
+					// Check for non-static methods and properties
+					return (
+						(member.type === 'MethodDefinition' || member.type === 'PropertyDefinition') &&
+						!member.static
+					);
+				});
+
+				if (nonStaticMembers.length > 0) {
+					for (const member of nonStaticMembers) {
+						const memberName = member.key?.name || 'unknown';
+
+						context.report({
+							node: member,
+							message: 'Helper class "{{ className }}" should only have static members. Member "{{ memberName }}" is not static.',
+							data: {
+								className: node.id.name,
+								memberName
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Non-helper classes should not have static methods (except factories)
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const noStaticInNonHelpersRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that non-Helper/Factory classes do not have static methods',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (!node.id) {
+					return;
+				}
+
+				const className = node.id.name;
+
+				// Allow static methods in Helpers and Factories
+				if (className.endsWith('Helper') || className.endsWith('Factory')) {
+					return;
+				}
+
+				const staticMembers = node.body.body.filter(member => {
+					return (
+						(member.type === 'MethodDefinition' || member.type === 'PropertyDefinition') &&
+						member.static
+					);
+				});
+
+				if (staticMembers.length > 0) {
+					for (const member of staticMembers) {
+						const memberName = member.key?.name || 'unknown';
+
+						context.report({
+							node: member,
+							message: 'Class "{{ className }}" should not have static members. Use a Helper class for static methods. Static member: "{{ memberName }}".',
+							data: {
+								className,
+								memberName
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Classes must be in appropriate folders based on their suffix
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const classLocationRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that classes are located in appropriate folders based on their suffix',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: [
+			{
+				type: 'object',
+				properties: {
+					mappings: {
+						type: 'object',
+						additionalProperties: {
+							type: 'string'
+						}
+					}
+				},
+				additionalProperties: false
+			}
+		]
+	},
+	create(context) {
+		const options = context.options[0] || {};
+		const defaultMappings = {
+			Service: 'services',
+			Repository: 'repositories',
+			Helper: 'helpers',
+			Factory: 'factories',
+			Transformer: 'transformers',
+			Registry: 'registries',
+			Adapter: 'adapters'
+		};
+		const mappings = { ...defaultMappings, ...options.mappings };
+
+		return {
+			ClassDeclaration(node) {
+				if (!node.id) {
+					return;
+				}
+
+				const className = node.id.name;
+				const fullPath = context.getFilename();
+
+				if (fullPath === '<input>' || fullPath === '<text>') {
+					return;
+				}
+
+				const dirPath = path.dirname(fullPath);
+
+				for (const [suffix, expectedFolder] of Object.entries(mappings)) {
+					if (className.endsWith(suffix)) {
+						// Check if the file is in the expected folder or a subfolder
+						const pathParts = dirPath.split(path.sep);
+
+						if (!pathParts.includes(expectedFolder)) {
+							context.report({
+								node: node.id,
+								message: 'Class "{{ className }}" with suffix "{{ suffix }}" should be in a "{{ expectedFolder }}" folder.',
+								data: {
+									className,
+									suffix,
+									expectedFolder
+								}
+							});
+						}
+
+						break; // Only check first matching suffix
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Interface files with TypeXXX must be in types folder
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const typeLocationRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that Type interfaces are located in types folder',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			TSInterfaceDeclaration(node) {
+				if (!node.id) {
+					return;
+				}
+
+				const interfaceName = node.id.name;
+
+				// Check if it's a Type interface (starts with Type)
+				if (!interfaceName.startsWith('Type')) {
+					return;
+				}
+
+				const fullPath = context.getFilename();
+
+				if (fullPath === '<input>' || fullPath === '<text>') {
+					return;
+				}
+
+				const dirPath = path.dirname(fullPath);
+				const pathParts = dirPath.split(path.sep);
+
+				if (!pathParts.includes('types')) {
+					context.report({
+						node: node.id,
+						message: 'Type interface "{{ interfaceName }}" should be in a "types" folder.',
+						data: { interfaceName }
+					});
+				}
+			},
+			TSTypeAliasDeclaration(node) {
+				if (!node.id) {
+					return;
+				}
+
+				const typeName = node.id.name;
+
+				// Check if it's a Type alias (starts with Type)
+				if (!typeName.startsWith('Type')) {
+					return;
+				}
+
+				const fullPath = context.getFilename();
+
+				if (fullPath === '<input>' || fullPath === '<text>') {
+					return;
+				}
+
+				const dirPath = path.dirname(fullPath);
+				const pathParts = dirPath.split(path.sep);
+
+				if (!pathParts.includes('types')) {
+					context.report({
+						node: node.id,
+						message: 'Type alias "{{ typeName }}" should be in a "types" folder.',
+						data: { typeName }
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Transformers must have single public method
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const transformerSinglePublicMethodRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that transformers have only one public method',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (!node.id || !node.id.name.endsWith('Transformer')) {
+					return;
+				}
+
+				const publicMethods = node.body.body.filter(member => {
+					return (
+						member.type === 'MethodDefinition' &&
+						member.kind === 'method' &&
+						(member.accessibility === 'public' || !member.accessibility) &&
+						!member.static
+					);
+				});
+
+				if (publicMethods.length > 1) {
+					context.report({
+						node: node.id,
+						message: 'Transformer {{ name }} has {{ count }} public methods. Transformers should have only one public method.',
+						data: {
+							name: node.id.name,
+							count: publicMethods.length
+						}
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Only one class per file
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const oneClassPerFileRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that each file contains only one class',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		const classes = [];
+
+		return {
+			ClassDeclaration(node) {
+				if (node.id) {
+					classes.push(node);
+				}
+			},
+			'Program:exit'() {
+				if (classes.length > 1) {
+					// Report on all classes except the first one
+					for (let idx = 1; idx < classes.length; idx++) {
+						context.report({
+							node: classes[idx].id,
+							message: 'File contains multiple classes. Each class should be in its own file. Found {{ count }} classes.',
+							data: {
+								count: classes.length
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Repository CQRS method naming
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const repositoryCqrsRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce CQRS naming for repository classes (CommandRepository vs QueryRepository)',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		const commandMethods = ['create', 'update', 'delete', 'save', 'insert', 'remove', 'add', 'set'];
+		const queryMethods = ['get', 'find', 'fetch', 'list', 'search', 'query', 'read', 'load', 'retrieve'];
+
+		return {
+			ClassDeclaration(node) {
+				if (!node.id) {
+					return;
+				}
+
+				const className = node.id.name;
+
+				// Only check Repository classes
+				if (!className.endsWith('Repository')) {
+					return;
+				}
+
+				const isCommandRepository = className.includes('Command');
+				const isQueryRepository = className.includes('Query');
+
+				// If not explicitly typed, skip this check (backward compatibility)
+				if (!isCommandRepository && !isQueryRepository) {
+					return;
+				}
+
+				const publicMethods = node.body.body.filter(member => {
+					return (
+						member.type === 'MethodDefinition' &&
+						member.kind === 'method' &&
+						(member.accessibility === 'public' || !member.accessibility) &&
+						!member.static &&
+						member.key?.name
+					);
+				});
+
+				for (const method of publicMethods) {
+					const methodName = method.key.name.toLowerCase();
+
+					if (isCommandRepository) {
+						// Command repositories should not have query methods
+						const hasQueryMethod = queryMethods.some(queryMethod => methodName.startsWith(queryMethod));
+
+						if (hasQueryMethod) {
+							context.report({
+								node: method.key,
+								message: 'CommandRepository "{{ className }}" should not have query method "{{ methodName }}". Use a QueryRepository for read operations.',
+								data: {
+									className,
+									methodName: method.key.name
+								}
+							});
+						}
+					}
+					else if (isQueryRepository) {
+						// Query repositories should not have command methods
+						const hasCommandMethod = commandMethods.some(cmdMethod => methodName.startsWith(cmdMethod));
+
+						if (hasCommandMethod) {
+							context.report({
+								node: method.key,
+								message: 'QueryRepository "{{ className }}" should not have command method "{{ methodName }}". Use a CommandRepository for write operations.',
+								data: {
+									className,
+									methodName: method.key.name
+								}
+							});
+						}
+					}
+				}
+			}
+		};
+	}
+};
+
+export default {
+	rules: {
+		'service-single-public-method': serviceSinglePublicMethodRule,
+		'function-name-match-filename': functionNameMatchFilenameRule,
+		'folder-camel-case': folderCamelCaseRule,
+		'helper-static-only': helperStaticOnlyRule,
+		'no-static-in-non-helpers': noStaticInNonHelpersRule,
+		'class-location': classLocationRule,
+		'type-location': typeLocationRule,
+		'transformer-single-public-method': transformerSinglePublicMethodRule,
+		'one-class-per-file': oneClassPerFileRule,
+		'repository-cqrs': repositoryCqrsRule
+	}
+};