@futdevpro/dynamo-eslint 1.12.1 → 1.14.3

package/src/plugin/rules/{import-order.ts → import/import-order.ts}

@@ -1,4 +1,4 @@
-import type { Rule } from 'eslint';
+import { Rule } from 'eslint';
 
 interface ImportGroup {
   type: 'non-futdevpro' | 'futdevpro' | 'other-modules' | 'same-module';
@@ -13,16 +13,14 @@ const rule: Rule.RuleModule = {
     messages: {
       misordered: 'Import statements should be grouped and ordered by convention.',
       forbiddenNpmPackages: 'Import from "*/../NPM-packages/*" is forbidden. Use "@futdevpro/*" instead.',
-      forbiddenJsExtension: 'Import with ".js" extension is forbidden. Use ".ts" or no extension.',
-      forbiddenImportType: 'Use of "import type" is forbidden.',
       missingEmptyLine: 'Missing empty line between import groups.',
       extraEmptyLine: 'Extra empty line detected.',
     },
     fixable: 'code',
   },
   create(context) {
-    const sourceCode = context.getSourceCode();
-    const filename = context.getFilename();
+    const sourceCode = context.sourceCode;
+    const filename = context.filename;
 
     function getImportGroup(importNode: any): ImportGroup['type'] {
       const source = importNode.source.value as string;
@@ -67,23 +65,16 @@ const rule: Rule.RuleModule = {
         context.report({
           node: importNode.source,
           messageId: 'forbiddenNpmPackages',
+          fix(fixer) {
+            // Replace NPM-packages path with @futdevpro equivalent
+            const newSource = source.replace(/.*\/NPM-packages\/([^\/]+)/, '@futdevpro/$1');
+
+            return fixer.replaceText(importNode.source, `'${newSource}'`);
+          },
         });
       }
       
-      if (source.endsWith('.js')) {
-        context.report({
-          node: importNode.source,
-          messageId: 'forbiddenJsExtension',
-        });
-      }
       
-      // Check for import type usage
-      if (importNode.importKind === 'type') {
-        context.report({
-          node: importNode,
-          messageId: 'forbiddenImportType',
-        });
-      }
     }
 
     function validateImportOrdering(importNodes: any[]) {
@@ -100,6 +91,7 @@ const rule: Rule.RuleModule = {
       importNodes.forEach(importNode => {
         const groupType = getImportGroup(importNode);
         const group = groups.find(g => g.type === groupType);
+
         if (group) {
           group.imports.push(importNode);
         }
@@ -110,6 +102,7 @@ const rule: Rule.RuleModule = {
 
       // Check if imports are in correct order
       let currentGroupIndex = 0;
+
       for (let i = 0; i < importNodes.length; i++) {
         const importNode = importNodes[i];
         const expectedGroupType = getImportGroup(importNode);
@@ -120,6 +113,11 @@ const rule: Rule.RuleModule = {
           context.report({
             node: importNode,
             messageId: 'misordered',
+            fix(fixer) {
+              // This is complex to fix automatically, so we'll just report for now
+              // Future enhancement: reorder imports automatically
+              return null;
+            },
           });
         }
 
@@ -141,6 +139,10 @@ const rule: Rule.RuleModule = {
           context.report({
             node: firstImportOfNextGroup,
             messageId: 'missingEmptyLine',
+            fix(fixer) {
+              // Add empty line before the first import of next group
+              return fixer.insertTextBefore(firstImportOfNextGroup, '\n');
+            },
           });
         }
       }

package/src/plugin/rules/import/no-import-type.spec.ts

@@ -0,0 +1,69 @@
+import noImportTypeRule from './no-import-type';
+
+describe('| no-import-type', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noImportTypeRule.meta?.type).toBe('suggestion');
+    expect(noImportTypeRule.meta?.docs?.description).toContain('import type');
+    expect(noImportTypeRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns object with ImportDeclaration method', () => {
+    const mockContext = {
+      sourceCode: { 
+        getText: (node: any) => 'import type { SomeType } from \'./some-file\';',
+      },
+      report: () => {},
+    } as any;
+
+    const result = noImportTypeRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.ImportDeclaration).toBe('function');
+  });
+
+  it('| should detect forbidden import type usage', () => {
+    const mockContext = {
+      sourceCode: { 
+        getText: (node: any) => 'import type { SomeType } from \'./some-file\';',
+      },
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenImportType');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      importKind: 'type',
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noImportTypeRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+  });
+
+  it('| should not report errors for regular imports', () => {
+    const mockContext = {
+      sourceCode: { 
+        getText: (node: any) => 'import { SomeType } from \'./some-file\';',
+      },
+      report: (options: any) => {
+        // Should not be called for regular imports
+        fail('Should not report errors for regular imports');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      importKind: 'value',
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noImportTypeRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+    
+    // If we get here without the report function being called, the test passes
+    expect(true).toBe(true);
+  });
+});

package/src/plugin/rules/import/no-import-type.ts

@@ -0,0 +1,37 @@
+import { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Forbid use of "import type" syntax' },
+    schema: [],
+    messages: {
+      forbiddenImportType: 'Use of "import type" is forbidden.',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      ImportDeclaration(node: any) {
+        // Check for import type usage
+        if (node.importKind === 'type') {
+          context.report({
+            node,
+            messageId: 'forbiddenImportType',
+            fix(fixer) {
+              // Remove 'type' keyword
+              const importText = sourceCode.getText(node);
+              const newImportText = importText.replace(/import\s+type\s+/, 'import ');
+
+              return fixer.replaceText(node, newImportText);
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/import/no-js-import.spec.ts

@@ -0,0 +1,82 @@
+import noJsExtensionRule from './no-js-import';
+
+describe('| no-js-import', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noJsExtensionRule.meta?.type).toBe('suggestion');
+    expect(noJsExtensionRule.meta?.docs?.description).toContain('.js');
+    expect(noJsExtensionRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns object with ImportDeclaration method', () => {
+    const mockContext = {
+      report: () => {},
+    } as any;
+
+    const result = noJsExtensionRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.ImportDeclaration).toBe('function');
+  });
+
+  it('| should detect forbidden .js extension imports', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenJsExtension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      source: { value: './some-file.js' },
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noJsExtensionRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+  });
+
+  it('| should not report errors for imports without .js extension', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not be called for imports without .js extension
+        fail('Should not report errors for imports without .js extension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      source: { value: './some-file' },
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noJsExtensionRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+    
+    // If we get here without the report function being called, the test passes
+    expect(true).toBe(true);
+  });
+
+  it('| should not report errors for imports with .ts extension', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not be called for imports with .ts extension
+        fail('Should not report errors for imports with .ts extension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ImportDeclaration',
+      source: { value: './some-file.ts' },
+      loc: { start: { line: 1 }, end: { line: 1 } },
+    } as any;
+
+    const rule = noJsExtensionRule.create(mockContext);
+
+    rule.ImportDeclaration(mockNode);
+    
+    // If we get here without the report function being called, the test passes
+    expect(true).toBe(true);
+  });
+});

package/src/plugin/rules/import/no-js-import.ts

@@ -0,0 +1,35 @@
+import { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Forbid imports with ".js" extension' },
+    schema: [],
+    messages: {
+      forbiddenJsExtension: 'Import with ".js" extension is forbidden. Use ".ts" or no extension.',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    return {
+      ImportDeclaration(node: any) {
+        const source = node.source.value as string;
+        
+        if (source.endsWith('.js')) {
+          context.report({
+            node: node.source,
+            messageId: 'forbiddenJsExtension',
+            fix(fixer) {
+              // Remove .js extension
+              const newSource = source.replace(/\.js$/, '');
+
+              return fixer.replaceText(node.source, `'${newSource}'`);
+            },
+          });
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/naming-patterns.spec.ts

@@ -12,6 +12,7 @@ describe('| naming-patterns', () => {
     } as any;
 
     const result = namingPatternsRule.create(mockContext);
+
     expect(typeof result).toBe('object');
     expect(typeof result.Identifier).toBe('function');
   });
@@ -27,10 +28,11 @@ describe('| naming-patterns', () => {
     const mockNode = {
       type: 'Identifier' as const,
       name: 'validVariableName',
-      loc: { start: { line: 1 }, end: { line: 1 } }
+      loc: { start: { line: 1 }, end: { line: 1 } },
     } as any;
 
     const rule = namingPatternsRule.create(mockContext);
+
     rule.Identifier(mockNode);
     
     // If we get here without the report function being called, the test passes

package/src/plugin/rules/naming-patterns.ts

@@ -1,4 +1,4 @@
-import type { Rule } from 'eslint';
+import { Rule } from 'eslint';
 // import * as dyfmUtils from '@futdevpro/fsm-dynamo';
 
 const rule: Rule.RuleModule = {

package/src/scripts/dynamo-fix.ts

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import fg from 'fast-glob';
+import { ESLint } from 'eslint';
+import { writeFileSync } from 'fs';
+
+interface FixResult {
+  file: string;
+  fixed: boolean;
+  errors: number;
+  warnings: number;
+  fixes: number;
+}
+
+async function fixFile(filePath: string): Promise<FixResult> {
+  const eslint = new ESLint({
+    baseConfig: [
+      { ignores: [ 'build/**', 'dist/**', 'node_modules/**' ] },
+      {
+        files: [ '**/*.{ts,tsx}' ],
+        languageOptions: {
+          parser: require('@typescript-eslint/parser'),
+          parserOptions: { ecmaVersion: 2020, sourceType: 'module' },
+        },
+        plugins: {
+          '@futdevpro/dynamo': {
+            rules: {
+              'import-order': require('../plugin/rules/import-order').default,
+              'naming-patterns': require('../plugin/rules/naming-patterns').default,
+            },
+          },
+        },
+        rules: {
+          '@futdevpro/dynamo/import-order': 'error',
+          '@futdevpro/dynamo/naming-patterns': 'warn',
+        },
+      },
+    ],
+    fix: true, // Enable auto-fixing
+  });
+
+  const results = await eslint.lintFiles([ filePath ]);
+  const result = results[0];
+
+  if (result && result.output) {
+    // Write the fixed content back to the file
+    writeFileSync(filePath, result.output);
+  }
+
+  return {
+    file: filePath,
+    fixed: result && result.output !== undefined,
+    errors: result.messages.filter(msg => msg.severity === 2).length,
+    warnings: result.messages.filter(msg => msg.severity === 1).length,
+    fixes: result.fixableErrorCount + result.fixableWarningCount,
+  };
+}
+
+async function main() {
+  const files = await fg([ '**/*.{ts,tsx}' ], { 
+    ignore: [ '**/node_modules/**', '**/build/**', '**/dist/**', '**/*.spec.ts', '**/*.test.ts' ], 
+  });
+  
+  console.log(`[dynamo-fix] Fixing ${files.length} files...`);
+  
+  const results: FixResult[] = [];
+  let totalFixed = 0;
+  let totalErrors = 0;
+  let totalWarnings = 0;
+  let totalFixes = 0;
+
+  for (const file of files) {
+    try {
+      const result = await fixFile(file);
+
+      results.push(result);
+      
+      if (result.fixed) {
+        totalFixed++;
+        console.log(`✅ Fixed: ${result.file}`);
+      }
+      
+      totalErrors += result.errors;
+      totalWarnings += result.warnings;
+      totalFixes += result.fixes;
+    } catch (error) {
+      console.error(`❌ Error processing ${file}:`, error);
+    }
+  }
+
+  // Report results
+  console.log(`\n📊 Fix Summary:`);
+  console.log(`   Files processed: ${files.length}`);
+  console.log(`   Files fixed: ${totalFixed}`);
+  console.log(`   Total errors: ${totalErrors}`);
+  console.log(`   Total warnings: ${totalWarnings}`);
+  console.log(`   Total fixes applied: ${totalFixes}`);
+
+  if (totalFixed === 0) {
+    console.log('✅ No files needed fixing!');
+  } else {
+    console.log(`\n🎉 Successfully fixed ${totalFixed} files!`);
+  }
+}
+
+main().catch((err) => {
+  console.error('Fix failed:', err);
+  process.exit(1);
+});

package/src/scripts/eslintrc-audit.ts

@@ -7,6 +7,7 @@ type AnyJson = any;
 function safeParse(jsonPath: string): AnyJson | null {
   try {
     const content = readFileSync(jsonPath, 'utf8');
+
     return JSON.parse(content);
   } catch {
     return null;
@@ -14,21 +15,24 @@ function safeParse(jsonPath: string): AnyJson | null {
 }
 
 async function main() {
-  const files = await fg(['**/.eslintrc.json'], { ignore: ['**/node_modules/**'] });
+  const files = await fg([ '**/.eslintrc.json' ], { ignore: [ '**/node_modules/**' ] });
   const ruleCounts: Record<string, number> = {};
   const total = files.length;
 
   for (const p of files) {
     const cfg = safeParse(p);
+
     if (!cfg?.rules) continue;
+
     for (const key of Object.keys(cfg.rules)) {
       ruleCounts[key] = (ruleCounts[key] ?? 0) + 1;
     }
   }
 
   const entries = Object.entries(ruleCounts).sort((a, b) => b[1] - a[1]);
+
   console.log(`[dynamo-eslintrc-audit] analyzed ${total} files`);
-  console.table(entries.slice(0, 50).map(([rule, count]) => ({ rule, count })));
+  console.table(entries.slice(0, 50).map(([ rule, count ]) => ({ rule, count })));
 }
 
 main().catch((err) => {

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

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+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';
+
+interface FixResult {
+  file: string;
+  fixed: boolean;
+  changes: number;
+}
+
+function addReturnTypesToFile(filePath: string): FixResult {
+  const sourceCode = fs.readFileSync(filePath, 'utf8');
+  const sourceFile = ts.createSourceFile(filePath, sourceCode, ts.ScriptTarget.Latest, true);
+  
+  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;
+  
+  function visit(node: ts.Node): ts.Node {
+    // Handle function declarations
+    if (ts.isFunctionDeclaration(node) && !node.type) {
+      const signature = checker.getSignatureFromDeclaration(node);
+      
+      if (signature) {
+        const returnType = checker.getReturnTypeOfSignature(signature);
+        const typeString = checker.typeToString(returnType);
+        
+        if (typeString !== 'void' && typeString !== 'any') {
+          const newType = ts.factory.createTypeReferenceNode(typeString);
+          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
+    if (ts.isArrowFunction(node) && !node.type) {
+      const signature = checker.getSignatureFromDeclaration(node);
+
+      if (signature) {
+        const returnType = checker.getReturnTypeOfSignature(signature);
+        const typeString = checker.typeToString(returnType);
+        
+        if (typeString !== 'void' && typeString !== 'any') {
+          const newType = ts.factory.createTypeReferenceNode(typeString);
+          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);
+        }
+      }
+    }
+    
+    return ts.visitEachChild(node, visit, {} as ts.TransformationContext);
+  }
+  
+  const result = ts.visitEachChild(sourceFile, visit, {} as ts.TransformationContext);
+  
+  if (hasChanges) {
+    const printer = ts.createPrinter();
+    const newSourceCode = printer.printFile(result);
+    fs.writeFileSync(filePath, newSourceCode);
+  }
+  
+  return {
+    file: filePath,
+    fixed: hasChanges,
+    changes,
+  };
+}
+
+async function main() {
+  const files = await fg([ '**/*.{ts,tsx}' ], {
+    ignore: [
+      '**/node_modules/**',
+      '**/build/**',
+      '**/dist/**',
+      '**/*.spec.ts',
+      '**/*.test.ts',
+    ],
+  });
+  
+  DyFM_Log.log(`[fix-return-types] Processing ${files.length} files...`);
+  
+  const results: FixResult[] = [];
+  let totalFixed = 0;
+  let totalChanges = 0;
+  
+  for (const file of files) {
+    try {
+      const result = addReturnTypesToFile(file);
+      results.push(result);
+      
+      if (result.fixed) {
+        totalFixed++;
+        totalChanges += result.changes;
+        DyFM_Log.log(`✅ Fixed ${result.changes} return types in ${file}`);
+      }
+    } catch (error) {
+      DyFM_Log.error(`❌ Error processing ${file}:`, error);
+    }
+  }
+  
+  DyFM_Log.log(`\n📊 Fix Summary:`);
+  DyFM_Log.log(`   Files processed: ${files.length}`);
+  DyFM_Log.log(`   Files fixed: ${totalFixed}`);
+  DyFM_Log.log(`   Total return types added: ${totalChanges}`);
+  
+  if (totalFixed > 0) {
+    DyFM_Log.log(`🎉 Successfully added return types to ${totalFixed} files!`);
+  } else {
+    DyFM_Log.log('✅ No files needed return type fixes!');
+  }
+}
+
+main().catch((err) => {
+  DyFM_Log.error('Fix script failed:', err);
+  process.exit(1);
+});