@futdevpro/dynamo-eslint 1.15.25 → 1.15.28

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

@@ -1,314 +1,314 @@
-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, _context?: any, _sourceCode?: 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, _context?: any, _sourceCode?: 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;
+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, _context?: any, _sourceCode?: 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, _context?: any, _sourceCode?: 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;