@futdevpro/dynamo-eslint 1.20.3 → 1.20.6

package/src/scripts/fix-return-types.ts

@@ -1,289 +0,0 @@
-#!/usr/bin/env node
-/**
- * @fileoverview TypeScript Type Annotation Fix Script
- * 
- * This script uses TypeScript's AST (Abstract Syntax Tree) to automatically add
- * type annotations to functions and arrow functions. It analyzes TypeScript files,
- * infers return types using the TypeScript compiler, and adds explicit type
- * annotations where missing.
- * 
- * @usage
- * ```bash
- * dynamo-fix-return-types
- * ```
- * 
- * @example
- * ```bash
- * # Fix type annotations in all TypeScript files
- * npx dynamo-fix-return-types
- * 
- * # Or run via npm script
- * npm run fix:types
- * ```
- * 
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-
-import * as ts from 'typescript';
-import * as fs from 'fs';
-import * as path from 'path';
-import fg from 'fast-glob';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-/**
- * Result of fixing type annotations in a single file
- */
-interface FixResult {
-  /** Path to the file that was processed */
-  file: string;
-  /** Whether the file was actually modified */
-  fixed: boolean;
-  /** Number of type annotations added to the file */
-  changes: number;
-}
-
-/**
- * Egy `checker.typeToString(...)`-bol jovo TIPUS-STRING-et valodi `ts.TypeNode`-da
- * alakit ugy, hogy egy eldobhato `type __T = <typeString>;` forrast parse-ol es
- * kiszedi belole a TypeNode-ot.
- *
- * MIERT: a regi megoldas `ts.factory.createTypeReferenceNode(typeString)`-et hivott,
- * ami CSAK bare identifier-t (entity-name-et) fogad el. Egy generic/union/stb.
- * tipus-string (pl. `Record<string, unknown>`) eseten ez tort node-ot epitett, amit
- * a printer csonka `Record`-kent (type-argumentumok nelkul) emittalt — ami EGYSZERRE
- * tsc-hiba ES uj lint-hiba, igy egyetlen fix-futas 0 → 1+ lint-szamot regresszalt.
- * A `typeToString` mindig syntactically valid TS tipus-syntaxot ad vissza, ezert a
- * `type __T = …;` parse-olas minden esetre korrekt TypeNode-ot allit elo.
- *
- * BAIL-OUT: ha a tipus nem alakithato biztonsagos node-da — pl. inline
- * `import("/abs/path").Foo` format tartalmaz, ami abszolut path-t szivarogtatna a
- * fajlba —, `undefined`-et adunk vissza. A hivo ilyenkor KIHAGYJA az annotaciot:
- * jobb annotalatlanul hagyni (marad a figyelmeztetes), mint tort kodot irni.
- */
-function buildTypeNodeFromString(typeString: string): ts.TypeNode | undefined {
-  // Inline `import(...)` tipus → projekt-specifikus abszolut/relativ path-t vinne a
-  // fajlba; sosem biztonsagos textualisan beilleszteni, ezert bail.
-  if (typeString.includes('import(')) {
-    return undefined;
-  }
-
-  const probe: ts.SourceFile = ts.createSourceFile(
-    '__dynamo_type_probe__.ts',
-    `type __T = ${typeString};`,
-    ts.ScriptTarget.Latest,
-    /* setParentNodes */ false,
-  );
-
-  const statement: ts.Statement | undefined = probe.statements[0];
-
-  if (!statement || !ts.isTypeAliasDeclaration(statement) || !statement.type) {
-    return undefined;
-  }
-
-  return statement.type;
-}
-
-/**
- * Adds type annotations to functions and arrow functions in a TypeScript file
- * 
- * Uses TypeScript's compiler API to analyze the file, infer return types,
- * and automatically add explicit type annotations where missing.
- * 
- * @param filePath - Path to the TypeScript file to process
- * @returns FixResult object containing statistics about the changes made
- * 
- * @example
- * ```typescript
- * const result = addTypesToFile('./src/utils.ts');
- * console.log(`Added ${result.changes} type annotations to ${result.file}`);
- * ```
- */
-function addTypesToFile(filePath: string): FixResult {
-  // Read and parse the source file
-  const sourceCode = fs.readFileSync(filePath, 'utf8');
-  const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
-  
-  // Create TypeScript program for type checking
-  const program = ts.createProgram([filePath], {
-    target: ts.ScriptTarget.Latest,
-    module: ts.ModuleKind.ESNext,
-    strict: true,
-    skipLibCheck: true,
-  });
-  
-  const checker = program.getTypeChecker();
-  let changes = 0;
-  let hasChanges = false;
-  
-  /**
-   * Recursively visits AST nodes and adds type annotations where needed
-   * 
-   * @param node - The current AST node being visited
-   * @returns The potentially modified AST node
-   */
-  function visit(node: ts.Node): ts.Node {
-    // Handle function declarations without return types
-    if (ts.isFunctionDeclaration(node) && !node.type) {
-      const signature = checker.getSignatureFromDeclaration(node);
-      
-      if (signature) {
-        const returnType = checker.getReturnTypeOfSignature(signature);
-        const typeString = checker.typeToString(returnType);
-        
-        // Add type annotation if it's not void or any
-        if (typeString !== 'void' && typeString !== 'any') {
-          const newType = buildTypeNodeFromString(typeString);
-
-          // newType === undefined → a tipus nem serializalhato biztonsagosan,
-          // kihagyjuk az annotaciot ahelyett hogy tort kodot irnank (B2 bail-out).
-          if (newType) {
-            const updatedNode = ts.factory.updateFunctionDeclaration(
-              node,
-              node.modifiers,
-              node.asteriskToken,
-              node.name,
-              node.typeParameters,
-              node.parameters,
-              newType,
-              node.body
-            );
-            changes++;
-            hasChanges = true;
-            return ts.visitEachChild(updatedNode, visit, {} as ts.TransformationContext);
-          }
-        }
-      }
-    }
-    
-    // Handle arrow functions without return types
-    if (ts.isArrowFunction(node) && !node.type) {
-      const signature = checker.getSignatureFromDeclaration(node);
-
-      if (signature) {
-        const returnType = checker.getReturnTypeOfSignature(signature);
-        const typeString = checker.typeToString(returnType);
-        
-        // Add type annotation if it's not void or any
-        if (typeString !== 'void' && typeString !== 'any') {
-          const newType = buildTypeNodeFromString(typeString);
-
-          // newType === undefined → a tipus nem serializalhato biztonsagosan,
-          // kihagyjuk az annotaciot ahelyett hogy tort kodot irnank (B2 bail-out).
-          if (newType) {
-            const updatedNode = ts.factory.updateArrowFunction(
-              node,
-              node.modifiers,
-              node.typeParameters,
-              node.parameters,
-              newType,
-              node.equalsGreaterThanToken,
-              node.body
-            );
-            changes++;
-            hasChanges = true;
-            return ts.visitEachChild(updatedNode, visit, {} as ts.TransformationContext);
-          }
-        }
-      }
-    }
-
-    // Note: Variable declarations, parameters, and class properties
-    // are handled by the existing @typescript-eslint/typedef rule
-    // and can be auto-fixed with eslint --fix
-    
-    return ts.visitEachChild(node, visit, {} as ts.TransformationContext);
-  }
-  
-  // Transform the AST and apply changes
-  const result = ts.visitEachChild(sourceFile, visit, {} as ts.TransformationContext);
-  
-  // Write the modified code back to the file if changes were made
-  if (hasChanges) {
-    const printer = ts.createPrinter();
-    const newSourceCode = printer.printFile(result);
-    fs.writeFileSync(filePath, newSourceCode);
-  }
-  
-  return {
-    file: filePath,
-    fixed: hasChanges,
-    changes,
-  };
-}
-
-
-/**
- * Main function that processes all TypeScript files and adds type annotations
- * 
- * Scans for all .ts and .tsx files in the project, processes each file to add
- * missing type annotations, and provides comprehensive reporting on the results.
- * 
- * @returns Promise that resolves when all files have been processed
- * 
- * @throws {Error} When file processing fails
- */
-async function main() {
-  // Find all TypeScript files, excluding common directories and test files
-  const files = await fg([ '**/*.{ts,tsx}' ], {
-    ignore: [
-      '**/node_modules/**',
-      '**/build/**',
-      '**/dist/**',
-      '**/*.spec.ts',
-      '**/*.test.ts',
-    ],
-  });
-  
-  DyFM_Log.log(`[fix-types] Processing ${files.length} files...`);
-  
-  const results: FixResult[] = [];
-  let totalFixed = 0;
-  let totalChanges = 0;
-  
-  // Process each file individually
-  for (const file of files) {
-    try {
-      const result = addTypesToFile(file);
-      results.push(result);
-      
-      // Track successful fixes
-      if (result.fixed) {
-        totalFixed++;
-        totalChanges += result.changes;
-        DyFM_Log.log(`✅ Fixed ${result.changes} type annotations in ${file}`);
-      }
-    } catch (error) {
-      DyFM_Log.error(`❌ Error processing ${file}:`, error);
-    }
-  }
-  
-  // Generate comprehensive summary report
-  DyFM_Log.log(`\n📊 Fix Summary:`);
-  DyFM_Log.log(`   Files processed: ${files.length}`);
-  DyFM_Log.log(`   Files fixed: ${totalFixed}`);
-  DyFM_Log.log(`   Total type annotations added: ${totalChanges}`);
-  
-  // Provide appropriate success/failure message
-  if (totalFixed > 0) {
-    DyFM_Log.log(`🎉 Successfully added type annotations to ${totalFixed} files!`);
-  } else {
-    DyFM_Log.log('✅ No files needed type annotation fixes!');
-  }
-}
-
-// Csak akkor futtatjuk a teljes fajl-scan-t, ha a scriptet KOZVETLENUL hivjak
-// (CLI bin / `npm run fix:return-types`). Import eseten (pl. spec a helper-ekhez)
-// NEM indul el a main(), igy a tiszta segedfuggvenyek unit-tesztelhetok.
-if (require.main === module) {
-  // Execute the main function and handle any errors
-  main().catch((err) => {
-    DyFM_Log.error('Fix script failed:', err);
-    process.exit(1);
-  });
-}
-
-export { buildTypeNodeFromString, addTypesToFile };
-
-

package/src/scripts/validate-imports.ts

@@ -1,292 +0,0 @@
-#!/usr/bin/env node
-/**
- * @fileoverview Import Validation Script
- * 
- * This script validates import ordering across all TypeScript files in the project
- * using the Dynamo import-order ESLint rule. It scans files, runs ESLint validation,
- * and reports any import ordering violations.
- * 
- * @usage
- * ```bash
- * dynamo-validate-imports
- * ```
- * 
- * @example
- * ```bash
- * # Validate import ordering in all TypeScript files
- * npx dynamo-validate-imports
- * 
- * # Or run via npm script
- * npm run validate:imports
- * ```
- * 
- * @author Future Development Program Ltd.
- * @version 1.14.3
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-import { ESLint, Linter } from 'eslint';
-import fg from 'fast-glob';
-
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import importOrderRule from '../plugin/rules/import/import-order';
-
-// 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;
-
-/**
- * Result of validating imports in a single file
- */
-interface ImportValidationResult {
-  /** Path to the file that was validated */
-  file: string;
-  /** Array of import validation errors found in the file */
-  errors: {
-    /** 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;
-  }[];
-}
-
-/** Identifies the informational diagnostic emitted when isolated validators intentionally ignore inline config. */
-function isIgnoredInlineConfigDiagnostic(message: Linter.LintMessage): boolean {
-  return !message.ruleId && message.message.includes("has no effect because you have 'noInlineConfig'");
-}
-
-/**
- * Validates import ordering in a single TypeScript file
- * 
- * Uses ESLint with the Dynamo import-order rule to check for import ordering
- * violations and returns detailed error information.
- * 
- * @param filePath - Path to the TypeScript file to validate
- * @returns Promise that resolves to an ImportValidationResult object
- * 
- * @example
- * ```typescript
- * const result = await validateImportsInFile('./src/components/Button.tsx');
- * if (result.errors.length > 0) {
- *   console.log(`Found ${result.errors.length} import violations`);
- * }
- * ```
- */
-async function validateImportsInFile(filePath: string): Promise<ImportValidationResult> {
-  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: {
-            'import-order': importOrderRule,
-          },
-        },
-      },
-      rules: {
-        '@futdevpro/dynamo/import-order': '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: Linter.LintMessage): boolean => !isIgnoredInlineConfigDiagnostic(message))
-      .map((message: Linter.LintMessage): ImportValidationResult['errors'][number] => ({
-        line: message.line,
-        column: message.column,
-        message: message.message,
-        ruleId: message.ruleId || 'unknown',
-      })),
-  };
-}
-
-/**
- * Main function that validates import ordering across all TypeScript files
- * 
- * Scans for all .ts and .tsx files in the project, validates import ordering
- * using the Dynamo import-order 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-imports] Scanning ${files.length} files...`);
-  
-  const results: ImportValidationResult[] = [];
-  let totalErrors = 0;
-  let processingFailures = 0;
-
-  // Process each file individually
-  for (const file of files) {
-    try {
-      const result: ImportValidationResult = await validateImportsInFile(file);
-
-      results.push(result);
-      totalErrors += result.errors.length;
-    } catch (error) {
-      DyFM_Log.error(`Error processing ${file}:`, error);
-      processingFailures++;
-    }
-  }
-
-  // BFR-PROTO-005: a feldolgozási hiba (pl. hiányzó runtime-modul) NEM nyelhető le zöldre —
-  // korábban minden fájl crash-elt, és a végén mégis "✅ passed" + exit 0 ment ki (fail-green).
-  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 import violations
-  const filesWithErrors: ImportValidationResult[] = results.filter(
-    (result: ImportValidationResult): boolean => result.errors.length > 0,
-  );
-
-  // Report success if no violations found
-  if (filesWithErrors.length === 0) {
-    DyFM_Log.log('✅ All import validations passed!');
-
-    return;
-  }
-
-  // Report detailed error information
-  DyFM_Log.warn(`\n❌ Found ${totalErrors} import validation errors in ${filesWithErrors.length} files:\n`);
-
-  filesWithErrors.forEach((result: ImportValidationResult): void => {
-    DyFM_Log.log(`📁 ${result.file}:`);
-    result.errors.forEach((error: ImportValidationResult['errors'][number]): 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);
-});
-
-