@futdevpro/dynamo-eslint 1.12.1

package/src/plugin/rules/import-order.spec.ts

@@ -0,0 +1,197 @@
+import importOrderRule from './import-order';
+
+describe('| import-order', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(importOrderRule.meta?.type).toBe('suggestion');
+    expect(importOrderRule.meta?.docs?.description).toContain('import ordering');
+    expect(importOrderRule.meta?.fixable).toBe('code');
+  });
+
+  it('| should have create function that returns object with Program method', () => {
+    const mockContext = {
+      getSourceCode: () => ({ 
+        ast: {},
+        getLines: () => ['line1', 'line2', 'line3']
+      }),
+      getFilename: () => 'test.ts',
+      report: () => {},
+    } as any;
+
+    const result = importOrderRule.create(mockContext);
+    expect(typeof result).toBe('object');
+    expect(typeof result.Program).toBe('function');
+  });
+
+  it('| should detect forbidden NPM-packages imports', () => {
+    const mockContext = {
+      getSourceCode: () => ({ 
+        ast: {},
+        getLines: () => ['import { Something } from \'../../../NPM-packages/some-package\';']
+      }),
+      getFilename: () => 'test.ts',
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenNpmPackages');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'Program',
+      sourceType: 'module',
+      body: [
+        {
+          type: 'ImportDeclaration',
+          source: { value: '../../../NPM-packages/some-package' },
+          importKind: 'value',
+          loc: { start: { line: 1 }, end: { line: 1 } }
+        }
+      ]
+    } as any;
+
+    const rule = importOrderRule.create(mockContext);
+    rule.Program(mockNode);
+  });
+
+  it('| should detect forbidden .js extension imports', () => {
+    const mockContext = {
+      getSourceCode: () => ({ 
+        ast: {},
+        getLines: () => ['import { Something } from \'./some-file.js\';']
+      }),
+      getFilename: () => 'test.ts',
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenJsExtension');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'Program',
+      sourceType: 'module',
+      body: [
+        {
+          type: 'ImportDeclaration',
+          source: { value: './some-file.js' },
+          importKind: 'value',
+          loc: { start: { line: 1 }, end: { line: 1 } }
+        }
+      ]
+    } as any;
+
+    const rule = importOrderRule.create(mockContext);
+    rule.Program(mockNode);
+  });
+
+  it('| should detect forbidden import type usage', () => {
+    const mockContext = {
+      getSourceCode: () => ({ 
+        ast: {},
+        getLines: () => ['import type { SomeType } from \'./some-file\';']
+      }),
+      getFilename: () => 'test.ts',
+      report: (options: any) => {
+        expect(options.messageId).toBe('forbiddenImportType');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'Program',
+      sourceType: 'module',
+      body: [
+        {
+          type: 'ImportDeclaration',
+          source: { value: './some-file' },
+          importKind: 'type',
+          loc: { start: { line: 1 }, end: { line: 1 } }
+        }
+      ]
+    } as any;
+
+    const rule = importOrderRule.create(mockContext);
+    rule.Program(mockNode);
+  });
+
+  it('| should detect misordered imports', () => {
+    let reportCount = 0;
+    const mockContext = {
+      getSourceCode: () => ({ 
+        ast: {},
+        getLines: () => [
+          'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';',
+          'import { Component } from \'@angular/core\';'
+        ]
+      }),
+      getFilename: () => 'test.ts',
+      report: (options: any) => {
+        if (options.messageId === 'misordered') {
+          reportCount++;
+        }
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'Program',
+      sourceType: 'module',
+      body: [
+        {
+          type: 'ImportDeclaration',
+          source: { value: '@futdevpro/fsm-dynamo' },
+          importKind: 'value',
+          loc: { start: { line: 1 }, end: { line: 1 } }
+        },
+        {
+          type: 'ImportDeclaration',
+          source: { value: '@angular/core' },
+          importKind: 'value',
+          loc: { start: { line: 2 }, end: { line: 2 } }
+        }
+      ]
+    } as any;
+
+    const rule = importOrderRule.create(mockContext);
+    rule.Program(mockNode);
+    
+    expect(reportCount).toBeGreaterThan(0);
+  });
+
+  it('| should detect missing empty line between groups', () => {
+    let reportCount = 0;
+    const mockContext = {
+      getSourceCode: () => ({ 
+        ast: {},
+        getLines: () => [
+          'import { Component } from \'@angular/core\';',
+          'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';'
+        ]
+      }),
+      getFilename: () => 'test.ts',
+      report: (options: any) => {
+        if (options.messageId === 'missingEmptyLine') {
+          reportCount++;
+        }
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'Program',
+      sourceType: 'module',
+      body: [
+        {
+          type: 'ImportDeclaration',
+          source: { value: '@angular/core' },
+          importKind: 'value',
+          loc: { start: { line: 1 }, end: { line: 1 } }
+        },
+        {
+          type: 'ImportDeclaration',
+          source: { value: '@futdevpro/fsm-dynamo' },
+          importKind: 'value',
+          loc: { start: { line: 2 }, end: { line: 2 } }
+        }
+      ]
+    } as any;
+
+    const rule = importOrderRule.create(mockContext);
+    rule.Program(mockNode);
+    
+    expect(reportCount).toBeGreaterThan(0);
+  });
+});

package/src/plugin/rules/import-order.ts

@@ -0,0 +1,167 @@
+import type { Rule } from 'eslint';
+
+interface ImportGroup {
+  type: 'non-futdevpro' | 'futdevpro' | 'other-modules' | 'same-module';
+  imports: any[];
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Validate import ordering based on Dynamo conventions' },
+    schema: [],
+    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();
+
+    function getImportGroup(importNode: any): ImportGroup['type'] {
+      const source = importNode.source.value as string;
+      
+      // Check for forbidden patterns first
+      if (source.includes('/NPM-packages/')) {
+        return 'non-futdevpro'; // Will be flagged as error
+      }
+      
+      if (source.endsWith('.js')) {
+        return 'non-futdevpro'; // Will be flagged as error
+      }
+      
+      // FutDevPro packages
+      if (source.startsWith('@futdevpro/')) {
+        return 'futdevpro';
+      }
+      
+      // Same module (relative imports with specific patterns)
+      if (source.startsWith('./') || source.startsWith('../')) {
+        const pathParts = source.split('/');
+        const upLevels = pathParts.filter(part => part === '..').length;
+        
+        // Same module: up to 3 ".." and starts with "_", or less than 2 ".."
+        if (upLevels <= 2 || (upLevels <= 3 && pathParts.some(part => part.startsWith('_')))) {
+          return 'same-module';
+        }
+        
+        // Other modules
+        return 'other-modules';
+      }
+      
+      // Non-FutDevPro packages
+      return 'non-futdevpro';
+    }
+
+    function validateImportDeclaration(importNode: any) {
+      const source = importNode.source.value as string;
+      
+      // Check for forbidden patterns
+      if (source.includes('/NPM-packages/')) {
+        context.report({
+          node: importNode.source,
+          messageId: 'forbiddenNpmPackages',
+        });
+      }
+      
+      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[]) {
+      if (importNodes.length === 0) return;
+
+      // Group imports
+      const groups: ImportGroup[] = [
+        { type: 'non-futdevpro', imports: [] },
+        { type: 'futdevpro', imports: [] },
+        { type: 'other-modules', imports: [] },
+        { type: 'same-module', imports: [] },
+      ];
+
+      importNodes.forEach(importNode => {
+        const groupType = getImportGroup(importNode);
+        const group = groups.find(g => g.type === groupType);
+        if (group) {
+          group.imports.push(importNode);
+        }
+      });
+
+      // Remove empty groups
+      const nonEmptyGroups = groups.filter(group => group.imports.length > 0);
+
+      // 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);
+        const expectedGroup = nonEmptyGroups.find(g => g.type === expectedGroupType);
+        const expectedGroupIndex = nonEmptyGroups.findIndex(g => g.type === expectedGroupType);
+
+        if (expectedGroupIndex < currentGroupIndex) {
+          context.report({
+            node: importNode,
+            messageId: 'misordered',
+          });
+        }
+
+        currentGroupIndex = expectedGroupIndex;
+      }
+
+      // Check empty lines between groups
+      for (let i = 0; i < nonEmptyGroups.length - 1; i++) {
+        const currentGroup = nonEmptyGroups[i];
+        const nextGroup = nonEmptyGroups[i + 1];
+        const lastImportOfCurrentGroup = currentGroup.imports[currentGroup.imports.length - 1];
+        const firstImportOfNextGroup = nextGroup.imports[0];
+
+        const lines = sourceCode.getLines();
+        const lastImportLine = lastImportOfCurrentGroup.loc?.end.line || 0;
+        const firstImportLine = firstImportOfNextGroup.loc?.start.line || 0;
+
+        if (firstImportLine - lastImportLine < 2) {
+          context.report({
+            node: firstImportOfNextGroup,
+            messageId: 'missingEmptyLine',
+          });
+        }
+      }
+    }
+
+    return {
+      Program(node: any) {
+        const importNodes = node.body.filter(
+          (statement: any) => statement.type === 'ImportDeclaration'
+        );
+
+        // Validate individual import declarations
+        importNodes.forEach(validateImportDeclaration);
+
+        // Validate import ordering
+        validateImportOrdering(importNodes);
+      },
+    };
+  },
+};
+
+export default rule;
+
+

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

@@ -0,0 +1,39 @@
+import namingPatternsRule from './naming-patterns';
+
+describe('| naming-patterns', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(namingPatternsRule.meta?.type).toBe('suggestion');
+    expect(namingPatternsRule.meta?.docs?.description).toContain('naming conventions');
+  });
+
+  it('| should have create function that returns object with Identifier method', () => {
+    const mockContext = {
+      report: () => {},
+    } as any;
+
+    const result = namingPatternsRule.create(mockContext);
+    expect(typeof result).toBe('object');
+    expect(typeof result.Identifier).toBe('function');
+  });
+
+  it('| should handle valid identifiers without errors', () => {
+    const mockContext = {
+      report: (options: any) => {
+        // Should not be called for valid identifiers
+        fail('Should not report errors for valid identifiers');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'Identifier' as const,
+      name: 'validVariableName',
+      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
+    expect(true).toBe(true);
+  });
+});

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

@@ -0,0 +1,25 @@
+import type { Rule } from 'eslint';
+// import * as dyfmUtils from '@futdevpro/fsm-dynamo';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { description: 'Enforce naming conventions using DyFM patterns' },
+    schema: [],
+    messages: {
+      invalidName: 'Identifier "{{name}}" does not match required naming pattern.',
+    },
+  },
+  create(context) {
+    return {
+      Identifier(node) {
+        // Future: use dyfmUtils naming patterns to validate identifiers
+        void node;
+      },
+    };
+  },
+};
+
+export default rule;
+
+

package/src/scripts/eslintrc-audit.ts

@@ -0,0 +1,39 @@
+#!/usr/bin/env node
+import fg from 'fast-glob';
+import { readFileSync } from 'fs';
+
+type AnyJson = any;
+
+function safeParse(jsonPath: string): AnyJson | null {
+  try {
+    const content = readFileSync(jsonPath, 'utf8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+async function main() {
+  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 })));
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});
+
+

package/src/scripts/validate-imports.ts

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import fg from 'fast-glob';
+import { readFileSync } from 'fs';
+import { ESLint } from 'eslint';
+import path from 'path';
+
+interface ImportValidationResult {
+  file: string;
+  errors: Array<{
+    line: number;
+    column: number;
+    message: string;
+    ruleId: string;
+  }>;
+}
+
+async function validateImportsInFile(filePath: string): Promise<ImportValidationResult> {
+  const eslint = new ESLint({
+    baseConfig: {
+      parser: '@typescript-eslint/parser',
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+      },
+      rules: {
+        '@futdevpro/dynamo/import-order': 'error',
+      },
+      plugins: {
+        '@futdevpro/dynamo': {
+          rules: {
+            'import-order': require('../plugin/rules/import-order').default,
+          },
+        },
+      },
+    } as any,
+  });
+
+  const results = await eslint.lintFiles([filePath]);
+  const result = results[0];
+
+  return {
+    file: filePath,
+    errors: result.messages.map(msg => ({
+      line: msg.line,
+      column: msg.column,
+      message: msg.message,
+      ruleId: msg.ruleId || 'unknown',
+    })),
+  };
+}
+
+async function main() {
+  const files = await fg(['**/*.{ts,tsx}'], { 
+    ignore: ['**/node_modules/**', '**/build/**', '**/dist/**', '**/*.spec.ts', '**/*.test.ts'] 
+  });
+  
+  console.log(`[dynamo-validate-imports] Scanning ${files.length} files...`);
+  
+  const results: ImportValidationResult[] = [];
+  let totalErrors = 0;
+
+  for (const file of files) {
+    try {
+      const result = await validateImportsInFile(file);
+      results.push(result);
+      totalErrors += result.errors.length;
+    } catch (error) {
+      console.error(`Error processing ${file}:`, error);
+    }
+  }
+
+  // Report results
+  const filesWithErrors = results.filter(r => r.errors.length > 0);
+  
+  if (filesWithErrors.length === 0) {
+    console.log('✅ All import validations passed!');
+    return;
+  }
+
+  console.log(`\n❌ Found ${totalErrors} import validation errors in ${filesWithErrors.length} files:\n`);
+
+  filesWithErrors.forEach(result => {
+    console.log(`📁 ${result.file}:`);
+    result.errors.forEach(error => {
+      console.log(`  ${error.line}:${error.column} - ${error.message}`);
+    });
+    console.log('');
+  });
+
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error('Validation failed:', err);
+  process.exit(1);
+});
+
+

package/src/scripts/validate-naming.ts

@@ -0,0 +1,97 @@
+#!/usr/bin/env node
+import fg from 'fast-glob';
+import { readFileSync } from 'fs';
+import { ESLint } from 'eslint';
+
+interface NamingValidationResult {
+  file: string;
+  errors: Array<{
+    line: number;
+    column: number;
+    message: string;
+    ruleId: string;
+  }>;
+}
+
+async function validateNamingInFile(filePath: string): Promise<NamingValidationResult> {
+  const eslint = new ESLint({
+    baseConfig: {
+      parser: '@typescript-eslint/parser',
+      parserOptions: {
+        ecmaVersion: 2020,
+        sourceType: 'module',
+      },
+      rules: {
+        '@futdevpro/dynamo/naming-patterns': 'error',
+      },
+      plugins: {
+        '@futdevpro/dynamo': {
+          rules: {
+            'naming-patterns': require('../plugin/rules/naming-patterns').default,
+          },
+        },
+      },
+    } as any,
+  });
+
+  const results = await eslint.lintFiles([filePath]);
+  const result = results[0];
+
+  return {
+    file: filePath,
+    errors: result.messages.map(msg => ({
+      line: msg.line,
+      column: msg.column,
+      message: msg.message,
+      ruleId: msg.ruleId || 'unknown',
+    })),
+  };
+}
+
+async function main() {
+  const files = await fg(['**/*.{ts,tsx}'], { 
+    ignore: ['**/node_modules/**', '**/build/**', '**/dist/**', '**/*.spec.ts', '**/*.test.ts'] 
+  });
+  
+  console.log(`[dynamo-validate-naming] Scanning ${files.length} files...`);
+  
+  const results: NamingValidationResult[] = [];
+  let totalErrors = 0;
+
+  for (const file of files) {
+    try {
+      const result = await validateNamingInFile(file);
+      results.push(result);
+      totalErrors += result.errors.length;
+    } catch (error) {
+      console.error(`Error processing ${file}:`, error);
+    }
+  }
+
+  // Report results
+  const filesWithErrors = results.filter(r => r.errors.length > 0);
+  
+  if (filesWithErrors.length === 0) {
+    console.log('✅ All naming validations passed!');
+    return;
+  }
+
+  console.log(`\n❌ Found ${totalErrors} naming validation errors in ${filesWithErrors.length} files:\n`);
+
+  filesWithErrors.forEach(result => {
+    console.log(`📁 ${result.file}:`);
+    result.errors.forEach(error => {
+      console.log(`  ${error.line}:${error.column} - ${error.message}`);
+    });
+    console.log('');
+  });
+
+  process.exit(1);
+}
+
+main().catch((err) => {
+  console.error('Validation failed:', err);
+  process.exit(1);
+});
+
+

package/tsconfig.json

@@ -0,0 +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/*"  
+  ]
+}