@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,220 +0,0 @@
-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;