@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,314 +0,0 @@
-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}}"}}',
-    },
-    // BFR-ADVENTOR-009 (2. lépcső): a fixer forrás-szöveg-megőrzőre átírva (`sourceCode.getText` per property)
-    // → a komplex/union/qualified/function típusok EXAKT megőrződnek, a generált interface ÉRVÉNYES TS. Ezért
-    // az auto-fix (`fixable:'code'`) VISSZA — a bulk `eslint --fix` biztonságosan futtathatja (nem generál
-    // többé `reference`/`complex` literál-hibát). (1. lépcső: suggestion-degrade, most feloldva.)
-    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;
-    }
-
-    /**
-     * BFR-ADVENTOR-009 (2. lépcső): az interface-törzs a FORRÁS-SZÖVEGBŐL épül (sourceCode.getText per
-     * member), NEM a lossy normalizált signature-ből → a komplex/union/qualified/function típusok EXAKT
-     * megőrződnek (a korábbi `reference`/`complex`/`union` literál-hibák megszűnnek). A `getText` az eredeti
-     * property-szöveget adja (pl. `onError: (e: Error) => void`); a záró `;`/`,`-t normalizáljuk.
-     */
-    function buildInterfaceBody(node: any): string {
-      const members: any[] = Array.isArray(node?.members) ? node.members : [];
-
-      return members
-        .map((member: any): string => {
-          const text: string = sourceCode.getText(member).trim().replace(/[;,]\s*$/, '');
-          return `  ${text};`;
-        })
-        .join('\n');
-    }
-
-    /**
-     * Beszédes interface-név a property-kulcsokból (BFR-ADVENTOR-009): a nem-beszédes, ütköző
-     * `GeneratedInterfaceN` helyett az első 1-3 kulcsból PascalCase + `Params_Interface` (a projekt-konvenció).
-     */
-    function deriveInterfaceName(node: any): string {
-      const members: any[] = Array.isArray(node?.members) ? node.members : [];
-      const keys: string[] = members
-        .filter((m: any): boolean => m.type === 'TSPropertySignature')
-        .map((m: any): string => String(m.key?.name ?? m.key?.value ?? ''))
-        .filter((k: string): boolean => !!k)
-        .slice(0, 3);
-
-      if (!keys.length) {
-        return 'Generated_Interface';
-      }
-
-      const pascal: string = keys
-        .map((k: string): string => k.charAt(0).toUpperCase() + k.slice(1))
-        .join('');
-
-      return `${pascal}_Interface`;
-    }
-
-    return {
-      TSTypeLiteral(node: any): void {
-        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): void {
-        try {
-          // Process all collected type usages
-          for (const [ signature, usages ] of typeUsages) {
-            if (usages.length >= threshold) {
-              // beszédes név a property-kulcsokból (ütközés-mentesre pontosítva)
-              const interfaceName = generateUniqueInterfaceName(
-                deriveInterfaceName(usages[0].node)
-              );
-
-              // a törzs a FORRÁS-SZÖVEGBŐL (getText) — a komplex/union/qualified típusok EXAKT megőrződnek
-              const interfaceBody: string = buildInterfaceBody(usages[0].node);
-
-              // 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 {
-                      const interfaceDeclaration = `interface ${interfaceName} {\n${interfaceBody}\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) {
-                        fixes.push(
-                          fixer.replaceText(usage.node, interfaceName)
-                        );
-                      }
-
-                      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;