@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,219 +0,0 @@
-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 = {
-      sourceCode: { 
-        ast: {},
-        getLines: () => [ 'import { Something } from \'../../../NPM-packages/some-package\';' ],
-      },
-      filename: '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 = {
-      sourceCode: { 
-        ast: {},
-        getLines: () => [ 'import { Something } from \'./some-file.js\';' ],
-      },
-      filename: '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 = {
-      sourceCode: { 
-        ast: {},
-        getLines: () => [ 'import type { SomeType } from \'./some-file\';' ],
-      },
-      filename: '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 = {
-      sourceCode: { 
-        ast: {},
-        getLines: () => [
-          'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';',
-          'import { Component } from \'@angular/core\';',
-        ],
-      },
-      filename: '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;
-    let hasFix = false;
-    const mockContext = {
-      sourceCode: { 
-        ast: {},
-        getLines: () => [
-          'import { Component } from \'@angular/core\';',
-          'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';',
-        ],
-        getText: (node: any) => {
-          if (node.source?.value === '@angular/core') {
-            return 'import { Component } from \'@angular/core\';';
-          }
-          if (node.source?.value === '@futdevpro/fsm-dynamo') {
-            return 'import { DyFM_Error } from \'@futdevpro/fsm-dynamo\';';
-          }
-          return '';
-        },
-      },
-      filename: 'test.ts',
-      report: (options: any) => {
-        if (options.messageId === 'misordered') {
-          reportCount++;
-        }
-        if (options.fix) {
-          hasFix = true;
-        }
-      },
-    } as any;
-
-    const mockNode = {
-      type: 'Program',
-      sourceType: 'module',
-      body: [
-        {
-          type: 'ImportDeclaration',
-          source: { value: '@angular/core' },
-          importKind: 'value',
-          loc: { start: { line: 1 }, end: { line: 1 } },
-          range: [0, 40],
-        },
-        {
-          type: 'ImportDeclaration',
-          source: { value: '@futdevpro/fsm-dynamo' },
-          importKind: 'value',
-          loc: { start: { line: 2 }, end: { line: 2 } },
-          range: [41, 85],
-        },
-      ],
-    } as any;
-
-    const rule = importOrderRule.create(mockContext);
-
-    rule.Program(mockNode);
-    
-    expect(reportCount).toBeGreaterThan(0);
-    expect(hasFix).toBe(true);
-  });
-});

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

@@ -1,197 +0,0 @@
-import { 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.',
-      missingEmptyLine: 'Missing empty line between import groups.',
-      extraEmptyLine: 'Extra empty line detected.',
-    },
-    fixable: 'code',
-  },
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const filename = context.filename;
-
-    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',
-          fix(fixer) {
-            // Replace NPM-packages path with @futdevpro equivalent
-            const newSource = source.replace(/.*\/NPM-packages\/([^\/]+)/, '@futdevpro/$1');
-
-            return fixer.replaceText(importNode.source, `'${newSource}'`);
-          },
-        });
-      }
-      
-      
-    }
-
-    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 and detect violations
-      let needsReordering = false;
-      let currentGroupIndex = 0;
-
-      for (let i = 0; i < importNodes.length; i++) {
-        const importNode = importNodes[i];
-        const expectedGroupType = getImportGroup(importNode);
-        const expectedGroupIndex = nonEmptyGroups.findIndex(g => g.type === expectedGroupType);
-
-        if (expectedGroupIndex < currentGroupIndex) {
-          needsReordering = true;
-        }
-
-        currentGroupIndex = expectedGroupIndex;
-      }
-
-      // Check empty lines between groups
-      let needsEmptyLineFix = false;
-      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) {
-          needsEmptyLineFix = true;
-        }
-      }
-
-      // If any violations are detected, provide a comprehensive fix
-      if (needsReordering || needsEmptyLineFix) {
-        context.report({
-          node: importNodes[0],
-          messageId: 'misordered',
-          fix(fixer) {
-            // Sort imports within each group alphabetically
-            nonEmptyGroups.forEach(group => {
-              group.imports.sort((a, b) => {
-                const aSource = a.source.value as string;
-                const bSource = b.source.value as string;
-                return aSource.localeCompare(bSource);
-              });
-            });
-
-            // Build the corrected import section
-            const correctedImports: string[] = [];
-            
-            nonEmptyGroups.forEach((group, groupIndex) => {
-              group.imports.forEach(importNode => {
-                const importText = sourceCode.getText(importNode);
-                correctedImports.push(importText);
-              });
-              
-              // Add empty line between groups (except after the last group)
-              if (groupIndex < nonEmptyGroups.length - 1) {
-                correctedImports.push('');
-              }
-            });
-
-            // Calculate the range to replace (from first import to last import)
-            const firstImport = importNodes[0];
-            const lastImport = importNodes[importNodes.length - 1];
-            const startRange = firstImport.range![0];
-            const endRange = lastImport.range![1];
-
-            // Replace the entire import section
-            return fixer.replaceTextRange([startRange, endRange], correctedImports.join('\n'));
-          },
-        });
-      }
-    }
-
-    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/import/no-import-type.spec.ts

@@ -1,69 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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) {
-        try {
-          // Check for import type usage
-          if (node.importKind === 'type') {
-            context.report({
-              node,
-              messageId: 'forbiddenImportType',
-              fix(fixer) {
-                try {
-                  // Remove 'type' keyword
-                  const importText = sourceCode.getText(node);
-                  const newImportText = importText.replace(/import\s+type\s+/, 'import ');
-
-                  return fixer.replaceText(node, newImportText);
-                } catch (fixError) {
-                  console.error('[no-import-type] Error in fix function:', fixError);
-                  return null;
-                }
-              },
-            });
-          }
-        } catch (error) {
-          console.error('[no-import-type] Error in ImportDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

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

@@ -1,82 +0,0 @@
-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

@@ -1,45 +0,0 @@
-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: Rule.RuleContext): Rule.RuleListener {
-    // List of allowed packages that can use .js extension
-    const allowedJsPackages = [
-      'discord.js',
-    ];
-
-    return {
-      ImportDeclaration(node): void {
-        try {
-          const source: string = node.source?.value as string;
-          
-          if (source && source.endsWith('.js')) {
-            // Check if the import is from an allowed package
-            const isAllowedPackage = allowedJsPackages.some((pkg: string): boolean => 
-              source.includes(pkg) || source.startsWith(pkg)
-            );
-            
-            if (!isAllowedPackage) {
-              context.report({
-                node: node.source,
-                messageId: 'forbiddenJsExtension',
-              });
-            }
-          }
-        } catch (error) {
-          console.error('[no-js-import] Error in ImportDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;