@futdevpro/dynamo-eslint 1.14.4 → 1.14.7

package/src/plugin/rules/prefer-interface-over-duplicate-types.ts

@@ -0,0 +1,276 @@
+import { Rule } from 'eslint';
+
+interface TypeUsage {
+  node: any;
+  signature: string;
+  interfaceName?: string;
+}
+
+interface RuleOptions {
+  threshold?: number;
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: { 
+      description: 'Suggest creating interfaces for object types used more than the threshold number of times',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          threshold: {
+            type: 'number',
+            minimum: 2,
+            default: 3,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+    messages: {
+      preferInterface: 'Object type used {{count}} times. Consider creating interface "{{interfaceName}}"}}',
+    },
+    fixable: 'code',
+  },
+  create(context) {
+    const options: RuleOptions = context.options[0] || {};
+    const threshold = options.threshold || 3;
+    const sourceCode = context.sourceCode;
+    
+    // Map to track type signatures and their usages
+    const typeUsages = new Map<string, TypeUsage[]>();
+    const allTypeLiterals: any[] = [];
+
+    /**
+     * Normalize object type to a signature string for comparison
+     */
+    function normalizeObjectType(node: any): string {
+      if (!node || node.type !== 'TSTypeLiteral') {
+        return '';
+      }
+
+      if (!node.members || !Array.isArray(node.members)) {
+        return '';
+      }
+
+      // Extract and sort properties
+      const properties = node.members
+        .filter((member: any) => member.type === 'TSPropertySignature')
+        .map((member: any) => {
+          const key = member.key?.name || member.key?.value || 'unknown';
+          const type = getTypeString(member.typeAnnotation);
+          const optional = member.optional ? '?' : '';
+          const readonly = member.readonly ? 'readonly ' : '';
+
+          return `${readonly}${key}${optional}:${type}`;
+        })
+        .sort(); // Sort alphabetically
+
+      return properties.join(';');
+    }
+
+    /**
+     * Get string representation of a type annotation
+     */
+    function getTypeString(typeAnnotation: any): string {
+      if (!typeAnnotation || !typeAnnotation.typeAnnotation) {
+        return 'any';
+      }
+
+      const type = typeAnnotation.typeAnnotation;
+      
+      switch (type.type) {
+        case 'TSStringKeyword':
+          return 'string';
+        case 'TSNumberKeyword':
+          return 'number';
+        case 'TSBooleanKeyword':
+          return 'boolean';
+        case 'TSVoidKeyword':
+          return 'void';
+        case 'TSNullKeyword':
+          return 'null';
+        case 'TSUndefinedKeyword':
+          return 'undefined';
+        case 'TSAnyKeyword':
+          return 'any';
+        case 'TSUnknownKeyword':
+          return 'unknown';
+        case 'TSNeverKeyword':
+          return 'never';
+        case 'TSObjectKeyword':
+          return 'object';
+        case 'TSLiteralType':
+          return type.literal?.value?.toString() || 'literal';
+        case 'TSArrayType':
+          return `${getTypeString({ typeAnnotation: type.elementType })}[]`;
+        case 'TSTypeReference':
+          return type.typeName?.name || 'reference';
+        case 'TSTypeLiteral':
+          return normalizeObjectType(type);
+        case 'TSUnionType':
+          return type.types?.map((t: any) => getTypeString({ typeAnnotation: t })).join('|') || 'union';
+        case 'TSIntersectionType':
+          return type.types?.map((t: any) => getTypeString({ typeAnnotation: t })).join('&') || 'intersection';
+
+        default:
+          return 'complex';
+      }
+    }
+
+    /**
+     * Generate interface name based on context
+     */
+    function generateInterfaceName(signature: string, usageCount: number): string {
+      // Try to extract meaningful name from signature
+      const properties = signature.split(';');
+
+      if (properties.length === 1) {
+        const prop = properties[0].split(':')[0].replace('readonly ', '').replace('?', '');
+
+        if (prop && prop !== 'unknown') {
+          return `${prop.charAt(0).toUpperCase() + prop.slice(1)}Interface`;
+        }
+      }
+      
+      // Fallback to generic name
+      return `GeneratedInterface${usageCount}`;
+    }
+
+    /**
+     * Check if interface name conflicts with existing identifiers
+     */
+    function isNameConflict(name: string): boolean {
+      try {
+        const scope = context.sourceCode.getScope(context.sourceCode.ast);
+
+        return scope.variables.some(variable => variable.name === name);
+      } catch {
+        return false;
+      }
+    }
+
+    /**
+     * Generate unique interface name
+     */
+    function generateUniqueInterfaceName(baseName: string): string {
+      let name = baseName;
+      let counter = 1;
+      
+      while (isNameConflict(name)) {
+        name = `${baseName}${counter}`;
+        counter++;
+      }
+      
+      return name;
+    }
+
+    return {
+      TSTypeLiteral(node: any) {
+        try {
+          const signature = normalizeObjectType(node);
+          
+          if (!signature) {
+            return;
+          }
+
+          allTypeLiterals.push(node);
+
+          if (!typeUsages.has(signature)) {
+            typeUsages.set(signature, []);
+          }
+
+          typeUsages.get(signature)!.push({
+            node,
+            signature,
+          });
+        } catch (error) {
+          console.error('[prefer-interface-over-duplicate-types] Error in TSTypeLiteral visitor:', error);
+        }
+      },
+
+      'Program:exit'(node: any) {
+        try {
+          // Process all collected type usages
+          for (const [ signature, usages ] of typeUsages) {
+            if (usages.length >= threshold) {
+              const interfaceName = generateUniqueInterfaceName(
+                generateInterfaceName(signature, usages.length)
+              );
+
+              // Report on each usage
+              for (const usage of usages) {
+                context.report({
+                  node: usage.node,
+                  messageId: 'preferInterface',
+                  data: {
+                    count: usages.length.toString(),
+                    interfaceName,
+                  },
+                  fix(fixer) {
+                    try {
+                      // Generate interface declaration
+                      const properties = signature.split(';').map(prop => {
+                        const [ key, type ] = prop.split(':');
+
+                        return `  ${key}: ${type};`;
+                      }).join('\n');
+
+                      const interfaceDeclaration = `interface ${interfaceName} {\n${properties}\n}`;
+
+                      // Find insertion point (after imports, before other code)
+                      const firstNode = sourceCode.ast.body[0];
+                      let insertPosition = 0;
+
+                      if (firstNode && firstNode.type === 'ImportDeclaration') {
+                        // Find last import
+                        let lastImport = firstNode;
+
+                        for (const node of sourceCode.ast.body) {
+                          if (node.type === 'ImportDeclaration') {
+                            lastImport = node;
+                          } else {
+                            break;
+                          }
+                        }
+                        insertPosition = lastImport.range![1];
+                      }
+
+                      // Add interface declaration
+                      const fixes = [
+                        fixer.insertTextAfterRange([ insertPosition, insertPosition ], `\n\n${interfaceDeclaration}\n`),
+                      ];
+
+                      // Replace all usages with interface reference
+                      for (const usage of usages) {
+                        const nodeText = sourceCode.getText(usage.node);
+                        const replacement = interfaceName;
+
+                        fixes.push(
+                          fixer.replaceText(usage.node, replacement)
+                        );
+                      }
+
+                      return fixes;
+                    } catch (fixError) {
+                      console.error('[prefer-interface-over-duplicate-types] Error in fix function:', fixError);
+
+                      return null;
+                    }
+                  },
+                });
+              }
+            }
+          }
+        } catch (error) {
+          console.error('[prefer-interface-over-duplicate-types] Error in Program:exit visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;