@futdevpro/dynamo-eslint 1.14.2 → 1.14.4

package/src/configs/nts-package.ts

@@ -1,18 +1,20 @@
-import nts = require('./nts');
+const ntsConfig = require('./nts');
 
 /**
  * Rulesets For Dynamo Based Systems
  * NTS-PACKAGE: Node TypeScript Package
+ * ESLint v9 Flat Config Format
  */
-const config = {
-  ...nts,
-  rules: {
-    ...nts.rules,
-    '@typescript-eslint/ban-types': 'off',
-    '@typescript-eslint/no-explicit-any': 'off',
+module.exports = [
+  ...ntsConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    rules: {
+      ...ntsConfig[1].rules,
+      '@typescript-eslint/ban-types': 'off',
+      '@typescript-eslint/no-explicit-any': 'off',
+    },
   },
-};
-
-export = config;
+];
 
 

package/src/configs/nts.ts

@@ -1,19 +1,34 @@
-import base = require('./base');
+const ntsBaseConfig = require('./base');
 
 /**
  * Rulesets For Dynamo Based Systems
  * NTS: Node TypeScript
+ * ESLint v9 Flat Config Format
  */
-const config = {
-  ...base,
-  env: { node: true, es2021: true },
-  parserOptions: { ...base.parserOptions, sourceType: 'module' },
-  rules: {
-    ...base.rules,
-    'max-lines': [ 'warn', 1500 ],
+module.exports = [
+  ...ntsBaseConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      ...ntsBaseConfig[1].languageOptions,
+      globals: {
+        // Node.js globals
+        process: 'readonly',
+        Buffer: 'readonly',
+        global: 'readonly',
+        __dirname: 'readonly',
+        __filename: 'readonly',
+        module: 'readonly',
+        require: 'readonly',
+        exports: 'readonly',
+        console: 'readonly'
+      }
+    },
+    rules: {
+      ...ntsBaseConfig[1].rules,
+      'max-lines': ['warn', 1500],
+    },
   },
-};
-
-export = config;
+];
 
 

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,169 @@
+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) {
+            // 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/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

@@ -13,19 +13,27 @@ const rule: Rule.RuleModule = {
   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}'`);
-            },
-          });
+        try {
+          const source = node.source?.value as string;
+          
+          if (source && source.endsWith('.js')) {
+            context.report({
+              node: node.source,
+              messageId: 'forbiddenJsExtension',
+              fix(fixer) {
+                try {
+                  // Remove .js extension
+                  const newSource = source.replace(/\.js$/, '');
+                  return fixer.replaceText(node.source, `'${newSource}'`);
+                } catch (fixError) {
+                  console.error('[no-js-import] Error in fix function:', fixError);
+                  return null;
+                }
+              },
+            });
+          }
+        } 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);
+        }
       },
     };
   },