@futdevpro/dynamo-eslint 1.14.3 → 1.14.6

package/src/configs/base.ts

@@ -15,16 +15,16 @@ module.exports = [
       'node_modules/**',
       'dist/**',
       'build/**',
-      '*.d.ts'
-    ]
+      '*.d.ts',
+    ],
   },
   {
-    files: ['**/*.ts', '**/*.tsx'],
+    files: [ '**/*.ts', '**/*.tsx' ],
     languageOptions: {
       parser: tsParser,
       parserOptions: { 
         ecmaVersion: 'latest',
-        sourceType: 'module'
+        sourceType: 'module',
       },
       globals: {
         // Browser globals
@@ -38,8 +38,8 @@ module.exports = [
         __filename: 'readonly',
         module: 'readonly',
         require: 'readonly',
-        exports: 'readonly'
-      }
+        exports: 'readonly',
+      },
     },
     plugins: {
       '@typescript-eslint': tsPlugin,
@@ -49,24 +49,35 @@ module.exports = [
     },
     rules: {
       // ESLint recommended rules
-      'no-warning-comments': ['warn', { terms: ['todo', 'fixme', 'removable', '??'], location: 'anywhere' }],
-      'indent': ['warn', 2, { SwitchCase: 1 }],
-      'max-len': ['warn', { code: 100, comments: 120 }],
-      'max-lines': ['warn', 1000],
+      'no-warning-comments': [ 'warn', { terms: [ 'todo', 'fixme', 'removable', '??' ], location: 'anywhere' }],
+      'indent': [ 'warn', 2, { SwitchCase: 1 }],
+      'max-len': [ 'warn', { code: 120, comments: 120 }],
+      'max-lines': [ 'warn', 1000 ],
       'linebreak-style': 'off',
-      'semi': ['warn', 'always'],
+      'semi': [ 'warn', 'always' ],
       'no-unused-vars': 'off',
       'no-prototype-builtins': 'off',
       'no-empty': 'warn',
-      'comma-dangle': ['warn', { arrays: 'always-multiline', objects: 'always-multiline', functions: 'only-multiline', imports: 'never', exports: 'never' }],
-      'brace-style': ['warn', '1tbs', { allowSingleLine: false }],
-      'object-curly-spacing': ['warn', 'always'],
-      'array-bracket-spacing': ['warn', 'always', { objectsInArrays: false, arraysInArrays: false }],
+      'comma-dangle': [ 
+        'warn', 
+        { 
+          arrays: 'always-multiline', 
+          objects: 'always-multiline', 
+          functions: 'only-multiline', 
+          imports: 'never', 
+          exports: 'never', 
+        },
+      ],
+      'brace-style': [ 'warn', '1tbs', { allowSingleLine: false }],
+      'object-curly-spacing': [ 'warn', 'always' ],
+      'array-bracket-spacing': [ 'warn', 'always', { objectsInArrays: false, arraysInArrays: false }],
       'padding-line-between-statements': [
         'warn',
-        { blankLine: 'always', prev: '*', next: ['return','throw','if','for','while','switch','default'] },
-        { blankLine: 'always', prev: ['const','let','var','break'], next: '*' },
-        { blankLine: 'any', prev: ['const','let','var'], next: ['const','let','var'] },
+        { blankLine: 'always', prev: '*', next: [ 'return','throw','if','for','while','switch','default' ] },
+        { blankLine: 'always', prev: [ 'const','let','var','break' ], next: '*' },
+        { blankLine: 'any', prev: [ 'const','let','var' ], next: [ 'const','let','var' ] },
+        { blankLine: 'any', prev: '*', next: 'import' },
+        { blankLine: 'any', prev: 'import', next: '*' },
       ],
       'prefer-const': 'warn',
       'no-case-declarations': 'off',
@@ -74,17 +85,18 @@ module.exports = [
       'keyword-spacing': 'warn',
       'no-else-return': 'warn',
       'no-duplicate-imports': 'warn',
-      'max-params': ['warn', 4],
-      'max-params-no-constructor/max-params-no-constructor': ['warn', 5],
-      'quotes': ['warn', 'single', { allowTemplateLiterals: true }],
+      'max-params': [ 'warn', 4 ],
+      'max-params-no-constructor/max-params-no-constructor': [ 'warn', 5 ],
+      'quotes': [ 'warn', 'single', { allowTemplateLiterals: true }],
       
       // TypeScript rules
       '@typescript-eslint/no-unused-vars': 'warn',
-      '@typescript-eslint/explicit-function-return-type': ['warn', { allowTypedFunctionExpressions: false }],
+      '@typescript-eslint/explicit-function-return-type': [ 'warn', { allowTypedFunctionExpressions: false }],
       '@typescript-eslint/no-explicit-any': 'warn',
       '@typescript-eslint/typedef': 'warn',
       
       // Dynamo custom rules
+      '@futdevpro/dynamo/explicit-types': 'warn',
       '@futdevpro/dynamo/import-order': 'warn',
       '@futdevpro/dynamo/naming-patterns': 'warn',
       '@futdevpro/dynamo/no-import-type': 'warn',

package/src/plugin/index.ts

@@ -1,3 +1,4 @@
+import explicitTypesRule from './rules/explicit-types';
 import importOrderRule from './rules/import/import-order';
 import namingPatternsRule from './rules/naming-patterns';
 import noImportTypeRule from './rules/import/no-import-type';
@@ -5,6 +6,7 @@ import noJsExtensionRule from './rules/import/no-js-import';
 
 export = {
   rules: {
+    'explicit-types': explicitTypesRule,
     'import-order': importOrderRule,
     'no-import-type': noImportTypeRule,
     'no-js-import': noJsExtensionRule,
@@ -14,6 +16,7 @@ export = {
   configs: {
     recommended: {
       rules: {
+        '@futdevpro/dynamo/explicit-types': 'warn',
         '@futdevpro/dynamo/import-order': 'warn',
         '@futdevpro/dynamo/no-import-type': 'warn',
         '@futdevpro/dynamo/no-js-import': 'warn',

package/src/plugin/rules/explicit-types.spec.ts

@@ -0,0 +1,190 @@
+import explicitTypesRule from './explicit-types';
+
+describe('| explicit-types', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(explicitTypesRule.meta?.type).toBe('suggestion');
+    expect(explicitTypesRule.meta?.docs?.description).toContain('explicit type annotations');
+  });
+
+  it('| should have create function that returns visitor object', () => {
+    const mockContext = {
+      report: () => {},
+    } as any;
+
+    const result = explicitTypesRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.FunctionDeclaration).toBe('function');
+    expect(typeof result.ArrowFunctionExpression).toBe('function');
+    expect(typeof result.VariableDeclarator).toBe('function');
+    expect(typeof result.PropertyDefinition).toBe('function');
+  });
+
+  it('| should report missing return types on function declarations', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingReturnType');
+        expect(options.data.name).toBe('testFunction');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'FunctionDeclaration' as const,
+      id: { name: 'testFunction' },
+      returnType: null,
+      params: [],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should not report when function has return type', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when function has return type');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'FunctionDeclaration' as const,
+      id: { name: 'testFunction' },
+      returnType: { type: 'TSTypeAnnotation' },
+      params: [],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should report missing return types on arrow functions', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingArrowReturnType');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'ArrowFunctionExpression' as const,
+      returnType: null,
+      params: [],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.ArrowFunctionExpression(mockNode);
+  });
+
+  it('| should report missing types on variable declarations', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingVariableType');
+        expect(options.data.name).toBe('testVar');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'VariableDeclarator' as const,
+      id: { name: 'testVar', typeAnnotation: null },
+      init: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.VariableDeclarator(mockNode);
+  });
+
+  it('| should not report when variable has type annotation', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when variable has type annotation');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'VariableDeclarator' as const,
+      id: { name: 'testVar', typeAnnotation: { type: 'TSTypeAnnotation' } },
+      init: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.VariableDeclarator(mockNode);
+  });
+
+  it('| should not report when variable has typed initializer', () => {
+    const mockContext = {
+      report: (options: any) => {
+        fail('Should not report when variable has typed initializer');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'VariableDeclarator' as const,
+      id: { name: 'testVar', typeAnnotation: null },
+      init: { type: 'CallExpression' },
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.VariableDeclarator(mockNode);
+  });
+
+  it('| should report missing parameter types', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingParameterType');
+        expect(options.data.name).toBe('param');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'FunctionDeclaration' as const,
+      id: { name: 'testFunction' },
+      returnType: { type: 'TSTypeAnnotation' },
+      params: [
+        { type: 'Identifier', name: 'param', typeAnnotation: null }
+      ],
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.FunctionDeclaration(mockNode);
+  });
+
+  it('| should report missing class property types', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingPropertyType');
+        expect(options.data.name).toBe('property');
+      },
+    } as any;
+
+    const mockNode = {
+      type: 'PropertyDefinition' as const,
+      key: { name: 'property' },
+      typeAnnotation: null,
+      value: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.PropertyDefinition(mockNode);
+  });
+
+  it('| should report missing destructuring types', () => {
+    const mockContext = {
+      report: (options: any) => {
+        expect(options.messageId).toBe('missingDestructuringType');
+      },
+    } as any;
+
+    const objectPatternNode = {
+      type: 'ObjectPattern' as const,
+      typeAnnotation: null,
+    } as any;
+
+    const arrayPatternNode = {
+      type: 'ArrayPattern' as const,
+      typeAnnotation: null,
+    } as any;
+
+    const rule = explicitTypesRule.create(mockContext);
+    rule.ObjectPattern(objectPatternNode);
+    rule.ArrayPattern(arrayPatternNode);
+  });
+});

package/src/plugin/rules/explicit-types.ts

@@ -0,0 +1,186 @@
+import { Rule } from 'eslint';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { 
+      description: 'Enforce explicit type annotations on all TypeScript declarations',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      missingReturnType: 'Function "{{name}}" must have an explicit return type annotation.',
+      missingArrowReturnType: 'Arrow function must have an explicit return type annotation.',
+      missingVariableType: 'Variable "{{name}}" must have an explicit type annotation.',
+      missingParameterType: 'Parameter "{{name}}" must have an explicit type annotation.',
+      missingPropertyType: 'Class property "{{name}}" must have an explicit type annotation.',
+      missingDestructuringType: 'Destructuring assignment must have explicit type annotations.',
+    },
+  },
+  create(context) {
+    return {
+      // Function declarations
+      FunctionDeclaration(node: any) {
+        try {
+          // Check return type
+          if (!node.returnType) {
+            context.report({
+              node,
+              messageId: 'missingReturnType',
+              data: { name: node.id?.name || 'anonymous' },
+            });
+          }
+
+          // Check function parameters with defensive checks
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              try {
+                if (param && param.type === 'Identifier' && !param.typeAnnotation) {
+                  context.report({
+                    node: param,
+                    messageId: 'missingParameterType',
+                    data: { name: param.name || 'unknown' },
+                  });
+                }
+              } catch (paramError) {
+                console.error('[explicit-types] Error processing function parameter:', paramError);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in FunctionDeclaration visitor:', error);
+        }
+      },
+
+      // Arrow functions
+      ArrowFunctionExpression(node: any) {
+        try {
+          // Check return type
+          if (!node.returnType) {
+            context.report({
+              node,
+              messageId: 'missingArrowReturnType',
+            });
+          }
+
+          // Check arrow function parameters with defensive checks
+          if (node.params && Array.isArray(node.params)) {
+            node.params.forEach((param: any) => {
+              try {
+                if (param && param.type === 'Identifier' && !param.typeAnnotation) {
+                  context.report({
+                    node: param,
+                    messageId: 'missingParameterType',
+                    data: { name: param.name || 'unknown' },
+                  });
+                }
+              } catch (paramError) {
+                console.error('[explicit-types] Error processing arrow function parameter:', paramError);
+              }
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in ArrowFunctionExpression visitor:', error);
+        }
+      },
+
+      // Variable declarations
+      VariableDeclarator(node: any) {
+        try {
+          // Defensive check for node.id
+          if (!node.id) {
+            return;
+          }
+
+          if (!node.id.typeAnnotation) {
+            // Check if this variable is declared in a for loop
+            let isInForLoop = false;
+            let parent = node.parent;
+
+            while (parent) {
+              if (parent.type === 'ForStatement' || parent.type === 'ForInStatement' || parent.type === 'ForOfStatement') {
+                isInForLoop = true;
+                break;
+              }
+              parent = parent.parent;
+            }
+
+            // Skip if variable is in a for loop
+            if (isInForLoop) {
+              return;
+            }
+
+            // Skip if variable is initialized with a typed value that can be inferred
+            const hasTypedInitializer = node.init && (
+              node.init.type === 'CallExpression' ||
+              node.init.type === 'NewExpression' ||
+              node.init.type === 'ArrayExpression' ||
+              node.init.type === 'ObjectExpression' ||
+              node.init.type === 'Literal'
+            );
+
+            if (!hasTypedInitializer) {
+              context.report({
+                node: node.id,
+                messageId: 'missingVariableType',
+                data: { name: (node.id as any)?.name || 'destructured' },
+              });
+            }
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in VariableDeclarator visitor:', error);
+        }
+      },
+
+      // Class properties
+      PropertyDefinition(node: any) {
+        try {
+          // Defensive check for node.key
+          if (!node.key) {
+            return;
+          }
+
+          if (!node.typeAnnotation && !node.value) {
+            context.report({
+              node: node.key,
+              messageId: 'missingPropertyType',
+              data: { name: (node.key as any)?.name || 'computed' },
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in PropertyDefinition visitor:', error);
+        }
+      },
+
+      // Object destructuring
+      ObjectPattern(node: any) {
+        try {
+          if (!node.typeAnnotation) {
+            context.report({
+              node,
+              messageId: 'missingDestructuringType',
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in ObjectPattern visitor:', error);
+        }
+      },
+
+      // Array destructuring
+      ArrayPattern(node: any) {
+        try {
+          if (!node.typeAnnotation) {
+            context.report({
+              node,
+              messageId: 'missingDestructuringType',
+            });
+          }
+        } catch (error) {
+          console.error('[explicit-types] Error in ArrayPattern visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

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

@@ -113,11 +113,6 @@ 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;
-            },
           });
         }
 
@@ -139,10 +134,6 @@ 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.ts

@@ -15,19 +15,28 @@ const rule: Rule.RuleModule = {
 
     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 ');
+        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);
-            },
-          });
+                  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);
         }
       },
     };

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

@@ -10,22 +10,32 @@ const rule: Rule.RuleModule = {
     },
     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$/, '');
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    // List of allowed packages that can use .js extension
+    const allowedJsPackages = [
+      'discord.js',
+    ];
 
-              return fixer.replaceText(node.source, `'${newSource}'`);
-            },
-          });
+    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);
         }
       },
     };

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

@@ -13,8 +13,12 @@ const rule: Rule.RuleModule = {
   create(context) {
     return {
       Identifier(node) {
-        // Future: use dyfmUtils naming patterns to validate identifiers
-        void node;
+        try {
+          // Future: use dyfmUtils naming patterns to validate identifiers
+          void node;
+        } catch (error) {
+          console.error('[naming-patterns] Error in Identifier visitor:', error);
+        }
       },
     };
   },