@futdevpro/dynamo-eslint 1.15.25 → 1.20.2

package/src/plugin/rules/no-getter-logic.ts

@@ -1,220 +1,220 @@
-import { Rule } from 'eslint';
-
-/**
- * Check if a node type is allowed in getter (simple property mapping only)
- */
-function isAllowedNodeType(nodeType: string): boolean {
-  const allowedTypes = [
-    'ReturnStatement',
-    'MemberExpression',
-    'Identifier',
-    'ThisExpression',
-    'Literal',
-    'BlockStatement',
-    'ExpressionStatement',
-  ];
-
-  return allowedTypes.includes(nodeType);
-}
-
-/**
- * Check if a node type is explicitly forbidden (logic, calculations, function calls,
- * block-level control flow, variable declarations).
- * CCAP "no-getter-logic"-megerősítés: tilos `if/for/while/switch/try` és helyi `const/let`.
- */
-function isForbiddenNodeType(nodeType: string): boolean {
-  const forbiddenTypes = [
-    'CallExpression',
-    'BinaryExpression',
-    'UnaryExpression',
-    'ConditionalExpression',
-    'LogicalExpression',
-    'AssignmentExpression',
-    'UpdateExpression',
-    'NewExpression',
-    'YieldExpression',
-    'AwaitExpression',
-    'TaggedTemplateExpression',
-    'TemplateLiteral',
-    'SequenceExpression',
-    'SpreadElement',
-    'RestElement',
-    // Block-level control flow — getter csak közvetlen property mapping lehet.
-    'IfStatement',
-    'ForStatement',
-    'ForInStatement',
-    'ForOfStatement',
-    'WhileStatement',
-    'DoWhileStatement',
-    'SwitchStatement',
-    'TryStatement',
-    'ThrowStatement',
-    // Lokális változó deklaráció — több-utasításos getter tilos.
-    'VariableDeclaration',
-  ];
-
-  return forbiddenTypes.includes(nodeType);
-}
-
-/**
- * Recursively check if a node contains only allowed patterns
- * Returns true if forbidden node is found
- */
-function containsForbiddenNode(node: any): boolean {
-  if (!node || typeof node !== 'object') {
-    return false;
-  }
-
-  // Check current node type
-  if (node.type && isForbiddenNodeType(node.type)) {
-    return true;
-  }
-
-  // Special handling for MemberExpression - allow property access but check nested calls
-  if (node.type === 'MemberExpression') {
-    // Check if this is a function call disguised as property access
-    // This will be caught by parent CallExpression, so we just check children
-    if (node.object && containsForbiddenNode(node.object)) {
-      return true;
-    }
-
-    if (node.property && containsForbiddenNode(node.property)) {
-      return true;
-    }
-
-    // Allow computed property access like [index] but check the index expression
-    if (node.computed && node.property && containsForbiddenNode(node.property)) {
-      return true;
-    }
-
-    return false;
-  }
-
-  // Special handling for ReturnStatement - check the argument
-  if (node.type === 'ReturnStatement') {
-    if (node.argument && containsForbiddenNode(node.argument)) {
-      return true;
-    }
-
-    return false;
-  }
-
-  // Special handling for BlockStatement - check all statements.
-  // CCAP-megerősítés: 1-nél több statement (az utolsó return-en kívül) tilos.
-  if (node.type === 'BlockStatement') {
-    if (node.body && Array.isArray(node.body)) {
-      // Több mint egy statement → többszörös utasítás → tilos.
-      if (node.body.length > 1) {
-        return true;
-      }
-      for (const statement of node.body) {
-        if (containsForbiddenNode(statement)) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  // Special handling for ExpressionStatement - check the expression
-  if (node.type === 'ExpressionStatement') {
-    if (node.expression && containsForbiddenNode(node.expression)) {
-      return true;
-    }
-
-    return false;
-  }
-
-  // For other node types, recursively check all properties
-  for (const key in node) {
-    if (key === 'parent' || key === 'range' || key === 'loc') {
-      continue; // Skip parent references and location data
-    }
-
-    const value = node[key];
-
-    if (Array.isArray(value)) {
-      for (const item of value) {
-        if (containsForbiddenNode(item)) {
-          return true;
-        }
-      }
-    } else if (value && typeof value === 'object') {
-      if (containsForbiddenNode(value)) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-/**
- * Get getter name for error message
- */
-function getGetterName(node: any): string {
-  try {
-    if (node.key && node.key.name) {
-      return node.key.name;
-    }
-
-    if (node.key && node.key.type === 'Identifier') {
-      return node.key.name || 'unknown';
-    }
-
-    return 'unknown';
-  } catch (error) {
-    console.error('[no-getter-logic] Error in getGetterName:', error);
-
-    return 'unknown';
-  }
-}
-
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Getters should only contain simple property mappings, no logic, calculations, or function calls',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noLogic: 'Getter "{{name}}" should only contain simple property mappings, no logic, calculations, or function calls.',
-    },
-  },
-  create(context) {
-    return {
-      MethodDefinition(node: any, _context?: any, _sourceCode?: any): void {
-        try {
-          // Only check getters
-          if (node.kind !== 'get') {
-            return;
-          }
-
-          // Check if getter has a body
-          if (!node.value || !node.value.body) {
-            return;
-          }
-
-          const body = node.value.body;
-
-          // Check for forbidden nodes in the getter body
-          if (containsForbiddenNode(body)) {
-            const getterName = getGetterName(node);
-
-            context.report({
-              node: body,
-              messageId: 'noLogic',
-              data: { name: getterName },
-            });
-          }
-        } catch (error) {
-          console.error('[no-getter-logic] Error in MethodDefinition visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;
+import { Rule } from 'eslint';
+
+/**
+ * Check if a node type is allowed in getter (simple property mapping only)
+ */
+function isAllowedNodeType(nodeType: string): boolean {
+  const allowedTypes = [
+    'ReturnStatement',
+    'MemberExpression',
+    'Identifier',
+    'ThisExpression',
+    'Literal',
+    'BlockStatement',
+    'ExpressionStatement',
+  ];
+
+  return allowedTypes.includes(nodeType);
+}
+
+/**
+ * Check if a node type is explicitly forbidden (logic, calculations, function calls,
+ * block-level control flow, variable declarations).
+ * CCAP "no-getter-logic"-megerősítés: tilos `if/for/while/switch/try` és helyi `const/let`.
+ */
+function isForbiddenNodeType(nodeType: string): boolean {
+  const forbiddenTypes = [
+    'CallExpression',
+    'BinaryExpression',
+    'UnaryExpression',
+    'ConditionalExpression',
+    'LogicalExpression',
+    'AssignmentExpression',
+    'UpdateExpression',
+    'NewExpression',
+    'YieldExpression',
+    'AwaitExpression',
+    'TaggedTemplateExpression',
+    'TemplateLiteral',
+    'SequenceExpression',
+    'SpreadElement',
+    'RestElement',
+    // Block-level control flow — getter csak közvetlen property mapping lehet.
+    'IfStatement',
+    'ForStatement',
+    'ForInStatement',
+    'ForOfStatement',
+    'WhileStatement',
+    'DoWhileStatement',
+    'SwitchStatement',
+    'TryStatement',
+    'ThrowStatement',
+    // Lokális változó deklaráció — több-utasításos getter tilos.
+    'VariableDeclaration',
+  ];
+
+  return forbiddenTypes.includes(nodeType);
+}
+
+/**
+ * Recursively check if a node contains only allowed patterns
+ * Returns true if forbidden node is found
+ */
+function containsForbiddenNode(node: any): boolean {
+  if (!node || typeof node !== 'object') {
+    return false;
+  }
+
+  // Check current node type
+  if (node.type && isForbiddenNodeType(node.type)) {
+    return true;
+  }
+
+  // Special handling for MemberExpression - allow property access but check nested calls
+  if (node.type === 'MemberExpression') {
+    // Check if this is a function call disguised as property access
+    // This will be caught by parent CallExpression, so we just check children
+    if (node.object && containsForbiddenNode(node.object)) {
+      return true;
+    }
+
+    if (node.property && containsForbiddenNode(node.property)) {
+      return true;
+    }
+
+    // Allow computed property access like [index] but check the index expression
+    if (node.computed && node.property && containsForbiddenNode(node.property)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // Special handling for ReturnStatement - check the argument
+  if (node.type === 'ReturnStatement') {
+    if (node.argument && containsForbiddenNode(node.argument)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // Special handling for BlockStatement - check all statements.
+  // CCAP-megerősítés: 1-nél több statement (az utolsó return-en kívül) tilos.
+  if (node.type === 'BlockStatement') {
+    if (node.body && Array.isArray(node.body)) {
+      // Több mint egy statement → többszörös utasítás → tilos.
+      if (node.body.length > 1) {
+        return true;
+      }
+      for (const statement of node.body) {
+        if (containsForbiddenNode(statement)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  // Special handling for ExpressionStatement - check the expression
+  if (node.type === 'ExpressionStatement') {
+    if (node.expression && containsForbiddenNode(node.expression)) {
+      return true;
+    }
+
+    return false;
+  }
+
+  // For other node types, recursively check all properties
+  for (const key in node) {
+    if (key === 'parent' || key === 'range' || key === 'loc') {
+      continue; // Skip parent references and location data
+    }
+
+    const value = node[key];
+
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        if (containsForbiddenNode(item)) {
+          return true;
+        }
+      }
+    } else if (value && typeof value === 'object') {
+      if (containsForbiddenNode(value)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+/**
+ * Get getter name for error message
+ */
+function getGetterName(node: any): string {
+  try {
+    if (node.key && node.key.name) {
+      return node.key.name;
+    }
+
+    if (node.key && node.key.type === 'Identifier') {
+      return node.key.name || 'unknown';
+    }
+
+    return 'unknown';
+  } catch (error) {
+    console.error('[no-getter-logic] Error in getGetterName:', error);
+
+    return 'unknown';
+  }
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Getters should only contain simple property mappings, no logic, calculations, or function calls',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      noLogic: 'Getter "{{name}}" should only contain simple property mappings, no logic, calculations, or function calls.',
+    },
+  },
+  create(context) {
+    return {
+      MethodDefinition(node: any): void {
+        try {
+          // Only check getters
+          if (node.kind !== 'get') {
+            return;
+          }
+
+          // Check if getter has a body
+          if (!node.value || !node.value.body) {
+            return;
+          }
+
+          const body = node.value.body;
+
+          // Check for forbidden nodes in the getter body
+          if (containsForbiddenNode(body)) {
+            const getterName = getGetterName(node);
+
+            context.report({
+              node: body,
+              messageId: 'noLogic',
+              data: { name: getterName },
+            });
+          }
+        } catch (error) {
+          console.error('[no-getter-logic] Error in MethodDefinition visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;