@dmitryrechkin/eslint-standard 1.5.8 → 1.5.9

package/README.md

@@ -97,6 +97,7 @@ export default config({
 | **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 |
+| **No Utils Folder** | `utils/` folder is forbidden | Use `helpers/` for stateless logic or domain objects for stateful logic |
 
 #### Example Project Structure
 

package/eslint.config.mjs

@@ -882,6 +882,17 @@ export default function ({
 					// Repository CQRS enforcement
 					'standard-conventions/repository-cqrs': 'error',
 
+					// Repository 'ById' naming enforcement
+					'standard-conventions/repository-by-id': 'error',
+
+					// No 'utils' folder enforcement
+					'standard-conventions/no-utils-folder': 'error',
+
+					// Enforce separation of schemas, types, and constants from class files
+					'standard-conventions/no-schemas-in-class-files': 'error',
+					'standard-conventions/no-types-in-class-files': 'error',
+					'standard-conventions/no-constants-in-class-files': 'error',
+
 					'unicorn/filename-case': ['error', {
 						cases: {
 							camelCase: true,

package/package.json

@@ -1,7 +1,8 @@
 {
 	"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.8",
+	"version": "1.5.9",
+	"type": "module",
 	"main": "eslint.config.mjs",
 	"exports": {
 		".": "./eslint.config.mjs"
@@ -32,7 +33,7 @@
 		"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:strict": "node tests/test-strict-conventions.mjs"
+		"test:strict": "node tests/test-strict-rules.mjs"
 	},
 	"keywords": [],
 	"author": "",

package/src/cli/check-deps.mjs

@@ -1,9 +1,8 @@
 #!/usr/bin/env node
 
-import { readFileSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join, resolve } from 'path';
-import { spawn } from 'child_process';
+import { readFileSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -17,18 +16,8 @@ const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
 const peerDeps = packageJson.peerDependencies || {};
 
 // Check if running from node_modules and find project root
-const isInNodeModules = __dirname.includes('node_modules');
-let projectRoot;
-
-if (isInNodeModules) {
-	// Handle different package manager structures
-	// pnpm: .pnpm/@org+pkg@version_deps/node_modules/@org/pkg
-	// npm/yarn: node_modules/@org/pkg
-	const parts = __dirname.split('node_modules');
-	projectRoot = parts[0].replace(/[\\/]$/, ''); // Remove trailing slash
-} else {
-	projectRoot = process.cwd();
-}
+// We primarily use process.cwd() as this is a CLI tool meant to run in the target project
+const projectRoot = process.cwd();
 
 // Read project's package.json
 let projectPackageJson;
@@ -36,6 +25,7 @@ try {
 	projectPackageJson = JSON.parse(readFileSync(join(projectRoot, 'package.json'), 'utf8'));
 } catch (error) {
 	console.error('❌ Could not read project package.json');
+	console.error(`Checked in: ${projectRoot}`);
 	process.exit(1);
 }
 
@@ -69,13 +59,13 @@ if (missingDeps.length === 0 && outdatedDeps.length === 0) {
 	if (missingDeps.length > 0) {
 		console.log(`\n❌ Missing ${missingDeps.length} dependencies:`);
 		missingDeps.forEach(dep => console.log(`  - ${dep}`));
-		
+
 		if (shouldInstall) {
 			console.log('\n🔧 Auto-installing missing dependencies...\n');
-			
+
 			// Import and run the install-deps script
 			try {
-				const installDepsModule = await import('./install-deps.mjs');
+				await import('./install-deps.mjs');
 				// The install-deps script will handle the installation
 			} catch (error) {
 				console.error('❌ Failed to auto-install dependencies:', error.message);
@@ -91,7 +81,7 @@ if (missingDeps.length === 0 && outdatedDeps.length === 0) {
 		console.log(`\n⚠️  ${outdatedDeps.length} dependencies may be outdated:`);
 		outdatedDeps.forEach(dep => console.log(`  - ${dep}`));
 	}
-	
+
 	if (!shouldInstall && missingDeps.length > 0) {
 		process.exit(1);
 	}
@@ -99,4 +89,4 @@ if (missingDeps.length === 0 && outdatedDeps.length === 0) {
 
 export default function checkDeps() {
 	// Export for programmatic use
-}
+}

package/src/cli/format.mjs

@@ -0,0 +1,22 @@
+
+import { spawn } from 'node:child_process';
+
+const args = process.argv.slice(3); // First 3 are node, script, command
+
+console.log('Running formatting...');
+
+// Determine eslint command (npx eslint or just eslint if in path)
+// We inject --fix to enable auto-fixing/formatting
+const eslint = spawn('npx', ['eslint', '--fix', ...args], {
+	stdio: 'inherit',
+	shell: true
+});
+
+eslint.on('close', (code) => {
+	if (code !== 0) {
+		console.log('\n\x1b[33m%s\x1b[0m', 'formatting completed with issues. please address remaining errors and warnings manually, make sure everything builds and all tests pass after modifying the code');
+		process.exit(code);
+	} else {
+		console.log('\n✅ Formatting passed');
+	}
+});

package/src/cli/index.mjs

@@ -9,6 +9,12 @@ switch (command) {
 	case 'check-deps':
 		await import('./check-deps.mjs');
 		break;
+	case 'lint':
+		await import('./lint.mjs');
+		break;
+	case 'format':
+		await import('./format.mjs');
+		break;
 	case 'help':
 	case '--help':
 	case '-h':
@@ -23,12 +29,16 @@ Commands:
   install-deps                  Install all peer dependencies
   check-deps                    Check if all peer dependencies are installed
   check-deps --install          Auto-install missing dependencies if any
+  lint                          Run eslint with custom error message
+  format                        Run eslint --fix with custom error message
   help                          Show this help message
 
 Examples:
   npx @dmitryrechkin/eslint-standard install-deps
   npx @dmitryrechkin/eslint-standard check-deps
   npx @dmitryrechkin/eslint-standard check-deps --install
+  npx @dmitryrechkin/eslint-standard lint .
+  npx @dmitryrechkin/eslint-standard format .
 		`);
 		break;
 	default:

package/src/cli/install-deps.mjs

@@ -1,49 +1,67 @@
 #!/usr/bin/env node
 
-import { execSync } from 'child_process';
-import { readFileSync, existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
+import { spawnSync } from 'node:child_process';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 
-// Detect package manager
-function detectPackageManager() {
-	if (existsSync('pnpm-lock.yaml')) return 'pnpm';
-	if (existsSync('yarn.lock')) return 'yarn';
-	if (existsSync('package-lock.json')) return 'npm';
-	if (existsSync('bun.lockb')) return 'bun';
-	return 'npm'; // default
+// Get peer dependencies from our package.json
+const packageJsonPath = join(__dirname, '../../package.json');
+let peerDeps = {};
+
+try {
+	const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+	peerDeps = packageJson.peerDependencies || {};
+} catch (error) {
+	console.error('❌ Could not read package.json:', error.message);
+	process.exit(1);
 }
 
-// Get peer dependencies from package.json
-const packageJsonPath = join(__dirname, '../../package.json');
-const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
-const peerDeps = packageJson.peerDependencies || {};
+const depsToInstall = Object.entries(peerDeps).map(([dep, version]) => `${dep}@${version}`);
+
+if (depsToInstall.length === 0) {
+	console.log('✅ No peer dependencies to install.');
+	process.exit(0);
+}
 
-// Build install command
-const packageManager = detectPackageManager();
-const deps = Object.entries(peerDeps).map(([name, version]) => `${name}@${version}`).join(' ');
+// Check for lockfiles to determine package manager
+const projectRoot = process.cwd();
+let packageManager = 'npm';
+let installArgs = ['install', '--save-dev'];
 
-const installCommands = {
-	npm: `npm install --save-dev ${deps}`,
-	pnpm: `pnpm add -D ${deps}`,
-	yarn: `yarn add -D ${deps}`,
-	bun: `bun add -d ${deps}`
-};
+if (existsSync(join(projectRoot, 'pnpm-lock.yaml'))) {
+	packageManager = 'pnpm';
+	installArgs = ['add', '-D'];
+} else if (existsSync(join(projectRoot, 'yarn.lock'))) {
+	packageManager = 'yarn';
+	installArgs = ['add', '-D'];
+} else if (existsSync(join(projectRoot, 'bun.lockb'))) {
+	packageManager = 'bun';
+	installArgs = ['add', '-D'];
+}
 
-const command = installCommands[packageManager];
+console.log(`📦 Installing peer dependencies using ${packageManager}...`);
+console.log(`   ${depsToInstall.join(' ')}\n`);
 
-console.log(`🔧 Installing ESLint Standard peer dependencies...`);
-console.log(`📦 Detected package manager: ${packageManager}`);
-console.log(`📋 Running: ${command}\n`);
+// Use shell: true on Windows compatibility or if packageManager is a .cmd/.bat file,
+// but generally spawnSync handles this better than execSync.
+// However, 'npm' often needs a shell on Windows or when run via npx.
+// Using shell: true is standard for cross-platform npm execution unless using .cmd explicitly on Windows.
+const result = spawnSync(packageManager, [...installArgs, ...depsToInstall], {
+	stdio: 'inherit',
+	shell: true
+});
 
-try {
-	execSync(command, { stdio: 'inherit' });
-	console.log('\n✅ All peer dependencies installed successfully!');
-} catch (error) {
-	console.error('\n❌ Failed to install dependencies. Please run manually:');
-	console.error(command);
-	process.exit(1);
-}
+if (result.status !== 0) {
+	console.error('❌ Installation failed');
+	process.exit(result.status || 1);
+}
+
+console.log('\n✅ Peer dependencies installed successfully!');
+
+export default function installDeps() {
+	// Export for programmatic use
+}

package/src/cli/lint.mjs

@@ -0,0 +1,21 @@
+
+import { spawn } from 'node:child_process';
+
+const args = process.argv.slice(3); // First 3 are node, script, command
+
+console.log('Running linting...');
+
+// Determine eslint command (npx eslint or just eslint if in path)
+const eslint = spawn('npx', ['eslint', ...args], {
+	stdio: 'inherit',
+	shell: true
+});
+
+eslint.on('close', (code) => {
+	if (code !== 0) {
+		console.log('\n\x1b[33m%s\x1b[0m', 'please address all the errors and warnings and re-run linting after, make sure everything builds and all tests pass after modifying the code');
+		process.exit(code);
+	} else {
+		console.log('\n✅ Linting passed');
+	}
+});

package/src/cli/postinstall-check.mjs

@@ -1,9 +1,9 @@
 #!/usr/bin/env node
 
-import { readFileSync, existsSync } from 'fs';
-import { fileURLToPath } from 'url';
-import { dirname, join } from 'path';
-import { execSync } from 'child_process';
+import { readFileSync, existsSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
+import { execSync } from 'node:child_process';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);

package/src/cli/postinstall.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
-import { fileURLToPath } from 'url';
-import { dirname } from 'path';
+import { fileURLToPath } from 'node:url';
+import { dirname, join } from 'node:path';
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
@@ -52,7 +52,7 @@ if (autoInstall) {
 	
 	try {
 		// Run check-deps with --install flag
-		const { execSync } = await import('child_process');
+		const { execSync } = await import('node:child_process');
 		execSync('node ' + join(__dirname, 'index.mjs') + ' check-deps --install', {
 			stdio: 'inherit',
 			cwd: process.cwd()

package/src/plugins/standard-conventions.mjs

@@ -45,6 +45,53 @@ const serviceSinglePublicMethodRule = {
 	}
 };
 
+/**
+/**
+ * Rule: Factories must have only one public method
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const factorySinglePublicMethodRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that factories have only one public method',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			ClassDeclaration(node) {
+				if (!node.id || !node.id.name.endsWith('Factory')) {
+					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: 'Factory {{ name }} has {{ count }} public methods. Factories 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}
@@ -226,8 +273,8 @@ const noStaticInNonHelpersRule = {
 
 				const className = node.id.name;
 
-				// Allow static methods in Helpers and Factories
-				if (className.endsWith('Helper') || className.endsWith('Factory')) {
+				// Allow static methods in Helpers, Factories, and Registries
+				if (className.endsWith('Helper') || className.endsWith('Factory') || className.endsWith('Registry')) {
 					return;
 				}
 
@@ -589,9 +636,503 @@ const repositoryCqrsRule = {
 	}
 };
 
+/**
+ * Rule: No Zod schemas in files with classes
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const noSchemasInClassFilesRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce separation of schemas from class files',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		let hasClass = false;
+		const schemas = [];
+
+		return {
+			ClassDeclaration() {
+				hasClass = true;
+			},
+			VariableDeclarator(node) {
+				if (node.id.type === 'Identifier') {
+					const name = node.id.name;
+					// Check for Schema suffix or z.object/z.string initialization
+					const isSchemaName = name.endsWith('Schema');
+					let isZodInit = false;
+
+					if (node.init && node.init.type === 'CallExpression' &&
+						node.init.callee.type === 'MemberExpression' &&
+						node.init.callee.object.type === 'Identifier' &&
+						node.init.callee.object.name === 'z') {
+						isZodInit = true;
+					}
+
+					if (isSchemaName || isZodInit) {
+						// Check if top-level
+						if (node.parent.parent.type === 'Program' ||
+							(node.parent.parent.type === 'ExportNamedDeclaration' && node.parent.parent.parent.type === 'Program')) {
+							schemas.push(node);
+						}
+					}
+				}
+			},
+			'Program:exit'() {
+				if (hasClass && schemas.length > 0) {
+					schemas.forEach(node => {
+						context.report({
+							node: node.id,
+							message: 'Schema definition "{{ name }}" should not be in a class file. Move it to a separate schemas file or folder.',
+							data: {
+								name: node.id.name
+							}
+						});
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: No types/interfaces in files with classes
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const noTypesInClassFilesRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce separation of types and interfaces from class files',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		let hasClass = false;
+		const types = [];
+
+		return {
+			ClassDeclaration() {
+				hasClass = true;
+			},
+			TSTypeAliasDeclaration(node) {
+				if (node.parent.type === 'Program' ||
+					(node.parent.type === 'ExportNamedDeclaration' && node.parent.parent.type === 'Program')) {
+					types.push(node);
+				}
+			},
+			TSInterfaceDeclaration(node) {
+				if (node.parent.type === 'Program' ||
+					(node.parent.type === 'ExportNamedDeclaration' && node.parent.parent.type === 'Program')) {
+					types.push(node);
+				}
+			},
+			'Program:exit'() {
+				if (hasClass && types.length > 0) {
+					types.forEach(node => {
+						context.report({
+							node: node.id,
+							message: 'Type/Interface definition "{{ name }}" should not be in a class file. Move it to a separate types file or folder.',
+							data: {
+								name: node.id.name
+							}
+						});
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: No top-level constants in files with classes
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const noConstantsInClassFilesRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce separation of constants from class files',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		let hasClass = false;
+		const constants = [];
+
+		return {
+			ClassDeclaration() {
+				hasClass = true;
+			},
+			VariableDeclaration(node) {
+				// Check if top-level const
+				if (node.kind === 'const' &&
+					(node.parent.type === 'Program' ||
+					(node.parent.type === 'ExportNamedDeclaration' && node.parent.parent.type === 'Program'))) {
+
+					node.declarations.forEach(decl => {
+						// Skip requires
+						if (decl.init && decl.init.type === 'CallExpression' && decl.init.callee.name === 'require') {
+							return;
+						}
+						// Skip Zod schemas (covered by other rule)
+						if (decl.id.name && decl.id.name.endsWith('Schema')) {
+							return;
+						}
+						if (decl.init && decl.init.type === 'CallExpression' &&
+							decl.init.callee.type === 'MemberExpression' &&
+							decl.init.callee.object.name === 'z') {
+							return;
+						}
+
+						constants.push(decl);
+					});
+				}
+			},
+			'Program:exit'() {
+				if (hasClass && constants.length > 0) {
+					constants.forEach(node => {
+						context.report({
+							node: node.id,
+							message: 'Constant "{{ name }}" should not be in a class file. Move it to a separate constants file or use a static readonly class property.',
+							data: {
+								name: node.id.name
+							}
+						});
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Interfaces must start with Type or end with Interface
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const interfaceNamingRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that interface names start with Type or end with Interface',
+			category: 'Naming Conventions',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			TSInterfaceDeclaration(node) {
+				if (!node.id) return;
+				const name = node.id.name;
+				if (!name.startsWith('Type') && !name.endsWith('Interface')) {
+					context.report({
+						node: node.id,
+						message: 'Interface "{{ name }}" should start with "Type" (for data) or end with "Interface" (for contracts).',
+						data: { name }
+					});
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Functions must have explicit return types
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const explicitReturnTypeRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce explicit return types for functions',
+			category: 'Type Safety',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		function checkFunction(node) {
+			if (!node.returnType) {
+				const name = node.id ? node.id.name : (node.key ? node.key.name : 'anonymous');
+				context.report({
+					node: node.id || node.key || node,
+					message: 'Function/Method "{{ name }}" is missing an explicit return type.',
+					data: { name }
+				});
+			}
+		}
+
+		return {
+			FunctionDeclaration: checkFunction,
+			MethodDefinition: (node) => {
+				if (node.kind === 'constructor' || node.kind === 'set') return;
+				checkFunction(node.value);
+			},
+			ArrowFunctionExpression: checkFunction,
+			FunctionExpression: (node) => {
+				if (node.parent.type === 'MethodDefinition') return;
+				checkFunction(node);
+			}
+		};
+	}
+};
+
+/**
+ * Rule: No direct instantiation of classes inside other classes (dependency injection)
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const noDirectInstantiationRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce dependency injection by banning direct instantiation',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		const allowedClasses = new Set([
+			'Date', 'Error', 'Promise', 'Map', 'Set', 'WeakMap', 'WeakSet',
+			'RegExp', 'URL', 'URLSearchParams', 'Buffer', 'Array', 'Object', 'String', 'Number', 'Boolean'
+		]);
+
+		let inClass = false;
+		let currentClassName = '';
+
+		return {
+			ClassDeclaration(node) {
+				inClass = true;
+				if (node.id) {
+					currentClassName = node.id.name;
+				}
+			},
+			'ClassDeclaration:exit'() {
+				inClass = false;
+				currentClassName = '';
+			},
+			NewExpression(node) {
+				if (!inClass) return;
+
+				// Allow factories to instantiate objects
+				if (currentClassName.endsWith('Factory')) {
+					return;
+				}
+
+				if (node.callee.type === 'Identifier') {
+					const className = node.callee.name;
+					if (!allowedClasses.has(className)) {
+						context.report({
+							node: node,
+							message: 'Avoid direct instantiation of "{{ name }}". Use dependency injection instead.',
+							data: { name: className }
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Prefer Enums over union types of string literals
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const preferEnumsRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer Enums over union types of string literals',
+			category: 'TypeScript',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			TSTypeAliasDeclaration(node) {
+				if (node.typeAnnotation.type === 'TSUnionType') {
+					const isAllLiterals = node.typeAnnotation.types.every(
+						t => t.type === 'TSLiteralType' && (typeof t.literal.value === 'string' || typeof t.literal.value === 'number')
+					);
+
+					if (isAllLiterals && node.typeAnnotation.types.length > 1) {
+						context.report({
+							node: node.id,
+							message: 'Avoid union types for "{{ name }}". Use an Enum instead.',
+							data: { name: node.id.name }
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Schemas must end with Schema or Table
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const schemaNamingRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that Zod schemas and Drizzle tables end with Schema or Table',
+			category: 'Naming Conventions',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			VariableDeclarator(node) {
+				if (node.init && node.init.type === 'CallExpression') {
+					let isZodOrDrizzle = false;
+
+					// Check for z.something()
+					if (node.init.callee.type === 'MemberExpression' &&
+						node.init.callee.object.type === 'Identifier' &&
+						node.init.callee.object.name === 'z') {
+						isZodOrDrizzle = true;
+					}
+
+					// Check for pgTable()
+					if (node.init.callee.type === 'Identifier' && node.init.callee.name === 'pgTable') {
+						isZodOrDrizzle = true;
+					}
+
+					if (isZodOrDrizzle && node.id.type === 'Identifier') {
+						const name = node.id.name;
+						if (!name.endsWith('Schema') && !name.endsWith('Table')) {
+							context.report({
+								node: node.id,
+								message: 'Schema/Table definition "{{ name }}" should end with "Schema" or "Table".',
+								data: { name }
+							});
+						}
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Repository methods accepting 'id' must end with 'ById'
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const repositoryByIdRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce "ById" suffix for repository methods that take an "id" parameter',
+			category: 'Naming Conventions',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			MethodDefinition(node) {
+				// Only check methods in Repository classes
+				const classNode = node.parent.parent;
+				if (!classNode || !classNode.id || !classNode.id.name.endsWith('Repository')) {
+					return;
+				}
+
+				// Skip constructors and static methods
+				if (node.kind === 'constructor' || node.static) {
+					return;
+				}
+
+				const methodParam = node.value.params[0];
+				if (!methodParam) {
+					return;
+				}
+
+				// Check if first parameter is named 'id'
+				let paramName = '';
+				if (methodParam.type === 'Identifier') {
+					paramName = methodParam.name;
+				}
+
+				if (paramName === 'id') {
+					const methodName = node.key.name;
+					if (!methodName.endsWith('ById')) {
+						context.report({
+							node: node.key,
+							message: 'Repository method "{{ methodName }}" accepts "id" parameter but does not end with "ById". Rename to "{{ methodName }}ById".',
+							data: { methodName }
+						});
+					}
+				}
+			}
+		};
+	}
+};
+
+/**
+ * Rule: Avoid using 'utils' folder, prefer 'helpers'
+ * @type {import('eslint').Rule.RuleModule}
+ */
+const noUtilsFolderRule = {
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce that "utils" folders are not used, preferring "helpers" instead',
+			category: 'Best Practices',
+			recommended: false
+		},
+		schema: []
+	},
+	create(context) {
+		return {
+			Program(node) {
+				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);
+
+				// Check if any folder is named 'utils' or 'util'
+				for (const folder of folders) {
+					if (folder.toLowerCase() === 'utils' || folder.toLowerCase() === 'util') {
+						context.report({
+							node: node,
+							loc: { line: 1, column: 0 },
+							message: 'Avoid using "{{ folder }}" folder. Use "helpers" for shared logic, or specific domain names (e.g. "services", "factories").',
+							data: { folder }
+						});
+						// Report only once per file
+						break;
+					}
+				}
+			}
+		};
+	}
+};
+
 export default {
 	rules: {
 		'service-single-public-method': serviceSinglePublicMethodRule,
+		'factory-single-public-method': factorySinglePublicMethodRule,
 		'function-name-match-filename': functionNameMatchFilenameRule,
 		'folder-camel-case': folderCamelCaseRule,
 		'helper-static-only': helperStaticOnlyRule,
@@ -600,6 +1141,16 @@ export default {
 		'type-location': typeLocationRule,
 		'transformer-single-public-method': transformerSinglePublicMethodRule,
 		'one-class-per-file': oneClassPerFileRule,
-		'repository-cqrs': repositoryCqrsRule
+		'repository-cqrs': repositoryCqrsRule,
+		'no-schemas-in-class-files': noSchemasInClassFilesRule,
+		'no-types-in-class-files': noTypesInClassFilesRule,
+		'no-constants-in-class-files': noConstantsInClassFilesRule,
+		'interface-naming': interfaceNamingRule,
+		'explicit-return-type': explicitReturnTypeRule,
+		'no-direct-instantiation': noDirectInstantiationRule,
+		'prefer-enums': preferEnumsRule,
+		'schema-naming': schemaNamingRule,
+		'repository-by-id': repositoryByIdRule,
+		'no-utils-folder': noUtilsFolderRule
 	}
 };

package/src/cli/setup-aggressive-cleanup.mjs

@@ -1,97 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * @file CLI Setup for Aggressive Unused Code Detection
- * 
- * This CLI tool helps set up aggressive unused code detection and cleanup
- * in your project with external tools and optimal configurations.
- * 
- * @author PageFast Team
- * @version 1.0.0
- */
-
-import { setupAggressiveCleanup } from '../configs/external-tools-setup.mjs';
-
-// Simple command line argument parsing (avoiding external dependencies)
-const args = process.argv.slice(2);
-const options = {
-	global: args.includes('--global') || args.includes('-g'),
-	packageManager: args.find((arg, i) => (args[i-1] === '--package-manager' || args[i-1] === '-p')) || 'npm',
-	dryRun: args.includes('--dry-run'),
-	help: args.includes('--help') || args.includes('-h')
-};
-
-/**
- * Main CLI program for setting up aggressive cleanup
- */
-async function main()
-{
-	try
-	{
-		if (options.help)
-		{
-			console.log(`
-@dmitryrechkin/eslint-standard - Aggressive Cleanup Setup
-
-Usage:
-  npx @dmitryrechkin/eslint-standard setup-aggressive-cleanup [options]
-
-Options:
-  -g, --global                 Install cleanup tools globally
-  -p, --package-manager <type> Package manager to use (npm, pnpm, yarn)
-  --dry-run                   Show what would be done without making changes
-  -h, --help                  Show this help message
-
-Examples:
-  npx @dmitryrechkin/eslint-standard setup-aggressive-cleanup
-  npx @dmitryrechkin/eslint-standard setup-aggressive-cleanup --global
-  npx @dmitryrechkin/eslint-standard setup-aggressive-cleanup -p pnpm
-  npx @dmitryrechkin/eslint-standard setup-aggressive-cleanup --dry-run
-			`);
-			return;
-		}
-
-		if (options.dryRun)
-		{
-			console.log('🔍 DRY RUN - Would perform the following actions:\n');
-			console.log('1. Install external cleanup tools:');
-			console.log('   - ts-prune (find unused exports)');
-			console.log('   - unimported (find unused files)'); 
-			console.log('   - knip (advanced dead code elimination)');
-			console.log('   - depcheck (find unused dependencies)');
-			console.log('   - ts-remove-unused (remove unused imports)');
-			console.log('\n2. Add cleanup scripts to package.json');
-			console.log('\n3. Create optimal tsconfig.json for unused code detection');
-			console.log('\n4. Create knip.json configuration');
-			console.log('\nRun without --dry-run to actually perform setup.');
-			return;
-		}
-
-		await setupAggressiveCleanup({
-			packageManager: options.packageManager,
-			globalTools: options.global
-		});
-
-		console.log('\n🎉 Setup complete! Next steps:');
-		console.log('\n1. Enable aggressive cleanup in your ESLint config:');
-		console.log('   ```javascript');
-		console.log('   import baseConfig from "@dmitryrechkin/eslint-standard";');
-		console.log('   export default baseConfig({');
-		console.log('     aggressiveCleanup: true // 🔥 Enable aggressive mode');
-		console.log('   });');
-		console.log('   ```');
-		console.log('\n2. Run cleanup check:');
-		console.log('   npm run cleanup:check');
-		console.log('\n3. Review and fix issues:');
-		console.log('   npm run cleanup:fix');
-
-	}
-	catch (error)
-	{
-		console.error('\n❌ Setup failed:', error.message);
-		process.exit(1);
-	}
-}
-
-// Run the main function
-main();