@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/scripts/validate-naming.ts

@@ -1,187 +1,213 @@
-#!/usr/bin/env node
-/**
- * @fileoverview Naming Convention Validation Script
- * 
- * This script validates naming conventions across all TypeScript files in the project
- * using the Dynamo naming-patterns ESLint rule. It scans files, runs ESLint validation,
- * and reports any naming convention violations.
- * 
- * @usage
- * ```bash
- * dynamo-validate-naming
- * ```
- * 
- * @example
- * ```bash
- * # Validate naming conventions in all TypeScript files
- * npx dynamo-validate-naming
- * 
- * # Or run via npm script
- * npm run validate:naming
- * ```
- * 
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-
-import fg from 'fast-glob';
-import { ESLint } from 'eslint';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-/**
- * Result of validating naming conventions in a single file
- */
+#!/usr/bin/env node
+/**
+ * @fileoverview Naming Convention Validation Script
+ * 
+ * This script validates naming conventions across all TypeScript files in the project
+ * using the Dynamo naming-patterns ESLint rule. It scans files, runs ESLint validation,
+ * and reports any naming convention violations.
+ * 
+ * @usage
+ * ```bash
+ * dynamo-validate-naming
+ * ```
+ * 
+ * @example
+ * ```bash
+ * # Validate naming conventions in all TypeScript files
+ * npx dynamo-validate-naming
+ * 
+ * # Or run via npm script
+ * npm run validate:naming
+ * ```
+ * 
+ * @author Future Development Program Ltd.
+ * @version 1.14.3
+ */
+
+import { ESLint } from 'eslint';
+import fg from 'fast-glob';
+
+import { DyFM_Log } from '@futdevpro/fsm-dynamo';
+
+import namingPatternsRule from '../plugin/rules/naming-patterns';
+
+// The parser is provided by the unified typescript-eslint consumer peer.
+// eslint-disable-next-line @futdevpro/dynamo/no-dynamic-imports, @typescript-eslint/no-require-imports
+const tsParser = require('typescript-eslint').parser;
+
+interface LineColumnMessage_Interface {
+  line: number;
+  column: number;
+  message: string;
+  ruleId: string;
+}
+
+
+/**
+ * Result of validating naming conventions in a single file
+ */
 interface NamingValidationResult {
-  /** Path to the file that was validated */
-  file: string;
-  /** Array of naming validation errors found in the file */
-  errors: Array<{
-    /** Line number where the error occurred */
-    line: number;
-    /** Column number where the error occurred */
-    column: number;
-    /** Error message describing the violation */
-    message: string;
-    /** ID of the ESLint rule that was violated */
-    ruleId: string;
-  }>;
+  /** Path to the file that was validated */
+  file: string;
+  /** Array of naming validation errors found in the file */
+  errors: LineColumnMessage_Interface[];
 }
 
-/**
- * Validates naming conventions in a single TypeScript file
- * 
- * Uses ESLint with the Dynamo naming-patterns rule to check for naming convention
- * violations and returns detailed error information.
- * 
- * @param filePath - Path to the TypeScript file to validate
- * @returns Promise that resolves to a NamingValidationResult object
- * 
- * @example
- * ```typescript
- * const result = await validateNamingInFile('./src/components/Button.tsx');
- * if (result.errors.length > 0) {
- *   console.log(`Found ${result.errors.length} naming violations`);
- * }
- * ```
- */
-async function validateNamingInFile(filePath: string): Promise<NamingValidationResult> {
-  // Configure ESLint using the main Dynamo configuration
-  const eslint = new ESLint({
-    // Use the main config object from flat config array
-    baseConfig: require('../../eslint.config.js')[1],
-  });
-
-  // Run ESLint on the file
-  const results: ESLint.LintResult[] = await eslint.lintFiles([ filePath ]);
-  const result: ESLint.LintResult = results[0];
-
-  // Transform ESLint messages into our result format
-  return {
-    file: filePath,
-    errors: result.messages.map((msg: {
-      line: number;
-      column: number;
-      message: string;
-      ruleId?: string;
-    }): {
-      line: number;
-      column: number;
-      message: string;
-      ruleId: string;
-    } => ({
-      line: msg.line,
-      column: msg.column,
-      message: msg.message,
-      ruleId: msg.ruleId || 'unknown',
-    })),
-  };
+/** Identifies the informational diagnostic emitted when isolated validators intentionally ignore inline config. */
+function isIgnoredInlineConfigDiagnostic(message: ESLint.LintResult['messages'][number]): boolean {
+  return !message.ruleId && message.message.includes("has no effect because you have 'noInlineConfig'");
 }
-
-/**
- * Main function that validates naming conventions across all TypeScript files
- * 
- * Scans for all .ts and .tsx files in the project, validates naming conventions
- * using the Dynamo naming-patterns rule, and provides detailed reporting on any
- * violations found.
- * 
- * @returns Promise that resolves when all files have been validated
- * 
- * @throws {Error} When validation fails and process exits with code 1
- */
-async function main(): Promise<void> {
-  // Find all TypeScript files, excluding common directories and test files
-  const files: string[] = await fg([ '**/*.{ts,tsx}' ], { 
-    ignore: [ '**/node_modules/**', '**/build/**', '**/dist/**', '**/*.spec.ts', '**/*.test.ts' ], 
-  });
-  
-  DyFM_Log.log(`[dynamo-validate-naming] Scanning ${files.length} files...`);
-  
-  const results: NamingValidationResult[] = [];
-  let totalErrors = 0;
-  let processingFailures = 0;
-
-  // Process each file individually
-  for (let i = 0; i < files.length; i++) {
-    const filePath: string = files[i];
-
-    try {
-      const result: NamingValidationResult = await validateNamingInFile(filePath);
-
-      results.push(result);
-      totalErrors += result.errors.length;
-    } catch (error) {
-      DyFM_Log.error(`Error processing ${filePath}:`, error);
-      processingFailures++;
-    }
-  }
-
-  // BFR-PROTO-005: feldolgozási hiba (pl. hiányzó runtime-modul) NEM nyelhető le zöldre — fail-hard.
-  if (processingFailures > 0) {
-    DyFM_Log.error(
-      `❌ ${processingFailures}/${files.length} file(s) FAILED to process (runtime/module error above) — ` +
-      'validation result is NOT trustworthy, failing hard.'
-    );
-    process.exit(1);
-  }
-
-  // Filter files that have naming violations
-  const filesWithErrors: NamingValidationResult[] = results.filter(
-    (r: NamingValidationResult): boolean => r.errors.length > 0
-  );
-
-  // Report success if no violations found
-  if (filesWithErrors.length === 0) {
-    DyFM_Log.log('✅ All naming validations passed!');
-
-    return;
-  }
-
-  // Report detailed error information
-  DyFM_Log.warn(
-    `\n❌ Found ${totalErrors} naming validation errors in ${filesWithErrors.length} files:\n`
-  );
-
-  filesWithErrors.forEach((result: NamingValidationResult): void => {
-    DyFM_Log.log(`📁 ${result.file}:`);
-    result.errors.forEach((error: {
-      line: number;
-      column: number;
-      message: string;
-      ruleId: string;
-    }): void => {
-      DyFM_Log.log(`  ${error.line}:${error.column} - ${error.message}`);
-    });
-    DyFM_Log.log('');
-  });
-
-  // Exit with error code to indicate validation failure
-  process.exit(1);
-}
-
-// Execute the main function and handle any errors
-main().catch((err: Error): void => {
-  DyFM_Log.error('Validation failed:', err);
-  process.exit(1);
-});
-
+
+/**
+ * Validates naming conventions in a single TypeScript file
+ * 
+ * Uses ESLint with the Dynamo naming-patterns rule to check for naming convention
+ * violations and returns detailed error information.
+ * 
+ * @param filePath - Path to the TypeScript file to validate
+ * @returns Promise that resolves to a NamingValidationResult object
+ * 
+ * @example
+ * ```typescript
+ * const result = await validateNamingInFile('./src/components/Button.tsx');
+ * if (result.errors.length > 0) {
+ *   console.log(`Found ${result.errors.length} naming violations`);
+ * }
+ * ```
+ */
+async function validateNamingInFile(filePath: string): Promise<NamingValidationResult> {
+  const eslint = new ESLint({
+    overrideConfigFile: true,
+    overrideConfig: [{
+      files: [ '**/*.{ts,tsx}' ],
+      linterOptions: {
+        noInlineConfig: true,
+        reportUnusedDisableDirectives: 'off',
+      },
+      languageOptions: {
+        parser: tsParser,
+        parserOptions: {
+          ecmaVersion: 'latest',
+          sourceType: 'module',
+        },
+      },
+      plugins: {
+        '@futdevpro/dynamo': {
+          rules: {
+            'naming-patterns': namingPatternsRule,
+          },
+        },
+      },
+      rules: {
+        '@futdevpro/dynamo/naming-patterns': 'error',
+      },
+    }],
+  });
+
+  // Run ESLint on the file
+  const results: ESLint.LintResult[] = await eslint.lintFiles([ filePath ]);
+  const result: ESLint.LintResult = results[0];
+
+  // Transform ESLint messages into our result format
+  return {
+    file: filePath,
+    errors: result.messages
+      .filter((message: ESLint.LintResult['messages'][number]): boolean => !isIgnoredInlineConfigDiagnostic(message))
+      .map((message: ESLint.LintResult['messages'][number]): LineColumnMessage_Interface => ({
+        line: message.line,
+        column: message.column,
+        message: message.message,
+        ruleId: message.ruleId || 'unknown',
+      })),
+  };
+}
+
+/**
+ * Main function that validates naming conventions across all TypeScript files
+ * 
+ * Scans for all .ts and .tsx files in the project, validates naming conventions
+ * using the Dynamo naming-patterns rule, and provides detailed reporting on any
+ * violations found.
+ * 
+ * @returns Promise that resolves when all files have been validated
+ * 
+ * @throws {Error} When validation fails and process exits with code 1
+ */
+async function main(): Promise<void> {
+  // Find all TypeScript files, excluding common directories and test files
+  const files: string[] = await fg([ '**/*.{ts,tsx}' ], { 
+    ignore: [
+      '**/node_modules/**',
+      '**/build/**',
+      '**/dist/**',
+      '**/samples/**',
+      '**/*.spec.ts',
+      '**/*.test.ts',
+    ],
+  });
+  
+  DyFM_Log.log(`[dynamo-validate-naming] Scanning ${files.length} files...`);
+  
+  const results: NamingValidationResult[] = [];
+  let totalErrors = 0;
+  let processingFailures = 0;
+
+  // Process each file individually
+  for (let i = 0; i < files.length; i++) {
+    const filePath: string = files[i];
+
+    try {
+      const result: NamingValidationResult = await validateNamingInFile(filePath);
+
+      results.push(result);
+      totalErrors += result.errors.length;
+    } catch (error) {
+      DyFM_Log.error(`Error processing ${filePath}:`, error);
+      processingFailures++;
+    }
+  }
+
+  // BFR-PROTO-005: feldolgozási hiba (pl. hiányzó runtime-modul) NEM nyelhető le zöldre — fail-hard.
+  if (processingFailures > 0) {
+    DyFM_Log.error(
+      `❌ ${processingFailures}/${files.length} file(s) FAILED to process (runtime/module error above) — ` +
+      'validation result is NOT trustworthy, failing hard.'
+    );
+    process.exit(1);
+  }
+
+  // Filter files that have naming violations
+  const filesWithErrors: NamingValidationResult[] = results.filter(
+    (r: NamingValidationResult): boolean => r.errors.length > 0
+  );
+
+  // Report success if no violations found
+  if (filesWithErrors.length === 0) {
+    DyFM_Log.log('✅ All naming validations passed!');
+
+    return;
+  }
+
+  // Report detailed error information
+  DyFM_Log.warn(
+    `\n❌ Found ${totalErrors} naming validation errors in ${filesWithErrors.length} files:\n`
+  );
+
+  filesWithErrors.forEach((result: NamingValidationResult): void => {
+    DyFM_Log.log(`📁 ${result.file}:`);
+    result.errors.forEach((error: LineColumnMessage_Interface): void => {
+      DyFM_Log.log(`  ${error.line}:${error.column} - ${error.message}`);
+    });
+    DyFM_Log.log('');
+  });
+
+  // Exit with error code to indicate validation failure
+  process.exit(1);
+}
+
+// Execute the main function and handle any errors
+main().catch((err: Error): void => {
+  DyFM_Log.error('Validation failed:', err);
+  process.exit(1);
+});
+

package/src/scripts/validator-cli.integration.spec.ts

@@ -0,0 +1,99 @@
+import { mkdtempSync, rmSync, writeFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { spawnSync, SpawnSyncReturns } from 'child_process';
+
+/** Result returned by a validator CLI integration invocation. */
+interface DyESL_ValidatorResult_Interface {
+  status: number | null;
+  output: string;
+}
+
+describe('| Dynamo validator CLI flat-config integration', (): void => {
+  const fixtureDirectories: string[] = [];
+
+  afterEach((): void => {
+    fixtureDirectories.forEach((fixtureDirectory: string): void => {
+      rmSync(fixtureDirectory, { recursive: true, force: true });
+    });
+    fixtureDirectories.length = 0;
+  });
+
+  /** Executes one built validator CLI against an isolated TypeScript fixture. */
+  function runValidator(
+    cliFileName: string,
+    fixtureFileName: string,
+    source: string,
+  ): DyESL_ValidatorResult_Interface {
+    const fixtureDirectory: string = mkdtempSync(join(tmpdir(), 'dynamo-eslint-validator-'));
+
+    fixtureDirectories.push(fixtureDirectory);
+    writeFileSync(join(fixtureDirectory, fixtureFileName), source, 'utf8');
+
+    const cliPath: string = join(__dirname, cliFileName);
+    const result: SpawnSyncReturns<string> = spawnSync(process.execPath, [ cliPath ], {
+      cwd: fixtureDirectory,
+      encoding: 'utf8',
+    });
+
+    return {
+      status: result.status,
+      output: `${result.stdout}${result.stderr}`,
+    };
+  }
+
+  it('| runs the import validator with an ESLint 9 flat config', (): void => {
+    const result: DyESL_ValidatorResult_Interface = runValidator(
+      'validate-imports.js',
+      'clean.ts',
+      '/* eslint-disable @consumer-only/plugin-rule */\n'
+        + 'import { join } from \'path\';\n\n'
+        + 'export const value: string = join(\'a\', \'b\');\n',
+    );
+
+    expect(result.status).toBe(0);
+    expect(result.output).toContain('All import validations passed');
+    expect(result.output).not.toContain('ConfigError');
+    expect(result.output).not.toContain('Definition for rule');
+  });
+
+  it('| fails only for an import-order violation', (): void => {
+    const result: DyESL_ValidatorResult_Interface = runValidator(
+      'validate-imports.js',
+      'violation.ts',
+      'import { DyFM_Log } from \'@futdevpro/fsm-dynamo\';\n'
+        + 'import { join } from \'path\';\n'
+        + 'DyFM_Log.log(join(\'a\'));\n',
+    );
+
+    expect(result.status).toBe(1);
+    expect(result.output).toContain('import');
+    expect(result.output).not.toContain('ConfigError');
+  });
+
+  it('| runs the naming validator without unrelated formatting rules', (): void => {
+    const result: DyESL_ValidatorResult_Interface = runValidator(
+      'validate-naming.js',
+      'clean.control-service.ts',
+      '/* eslint-disable @consumer-only/plugin-rule */\n'
+        + 'export class DyESL_Clean_ControlService { public value: string = "ok"; }\n',
+    );
+
+    expect(result.status).toBe(0);
+    expect(result.output).toContain('All naming validations passed');
+    expect(result.output).not.toContain('JSDoc');
+    expect(result.output).not.toContain('Definition for rule');
+  });
+
+  it('| fails for a naming-pattern violation', (): void => {
+    const result: DyESL_ValidatorResult_Interface = runValidator(
+      'validate-naming.js',
+      'broken.control-service.ts',
+      'export class Broken { public value: string = "bad"; }\n',
+    );
+
+    expect(result.status).toBe(1);
+    expect(result.output).toContain('_ControlService');
+    expect(result.output).not.toContain('ConfigError');
+  });
+});

package/tsconfig.json

@@ -1,32 +1,32 @@
-{
-  "compilerOptions": {
-    "incremental": false,                  
-    "module": "commonjs",                 
-    "target": "es2022",                      
-    "lib": [
-      "es6",
-      "es2018",
-      "es2022",
-      "dom"
-    ],     
-    "strict": false,
-    "allowJs": true,
-    "declaration": true, 
-    "declarationMap": true,  
-    "sourceMap": true,
-    "outDir": "./build",
-    "rootDir": "./src",
-    "importHelpers": true,  
-    "moduleResolution": "node", 
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "noImplicitOverride": true,
-    "allowSyntheticDefaultImports": true,
-    "forceConsistentCasingInFileNames": true,
-    "resolveJsonModule": true 
-  },
-  "include": [
-    "src",
-    "src/**/assets/*"  
-  ]
+{
+  "compilerOptions": {
+    "incremental": false,                  
+    "module": "commonjs",                 
+    "target": "es2022",                      
+    "lib": [
+      "es6",
+      "es2018",
+      "es2022",
+      "dom"
+    ],     
+    "strict": false,
+    "allowJs": true,
+    "declaration": true, 
+    "declarationMap": true,  
+    "sourceMap": true,
+    "outDir": "./build",
+    "rootDir": "./src",
+    "importHelpers": true,  
+    "moduleResolution": "node", 
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "noImplicitOverride": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "resolveJsonModule": true 
+  },
+  "include": [
+    "src",
+    "src/**/assets/*"  
+  ]
 }