@futdevpro/dynamo-eslint 1.14.24 → 1.14.26

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

@@ -0,0 +1,520 @@
+import noGetterLogicRule from './no-getter-logic';
+
+describe('| no-getter-logic', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(noGetterLogicRule.meta?.type).toBe('suggestion');
+    expect(noGetterLogicRule.meta?.docs?.description).toContain('Getters should only contain simple property mappings');
+  });
+
+  it('| should have create function that returns visitor object', () => {
+    const mockContext = {
+      report: () => {},
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const result = noGetterLogicRule.create(mockContext);
+
+    expect(typeof result).toBe('object');
+    expect(typeof result.MethodDefinition).toBe('function');
+  });
+
+  it('| should not report for simple property access getter', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'selectedTokenPackage' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'MemberExpression',
+                  object: { type: 'ThisExpression' },
+                  property: { type: 'Identifier', name: 'tokenPackages_CS' },
+                },
+                property: {
+                  type: 'MemberExpression',
+                  object: { type: 'Identifier', name: 'tokenPackageByType' },
+                  property: {
+                    type: 'MemberExpression',
+                    object: { type: 'ThisExpression' },
+                    property: { type: 'Identifier', name: 'selectedPackageType' },
+                  },
+                  computed: true,
+                },
+                computed: true,
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report for simple length property access', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'runningProgressCount' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'MemberExpression',
+                  object: { type: 'ThisExpression' },
+                  property: { type: 'Identifier', name: '_runningProgresses' },
+                },
+                property: { type: 'Identifier', name: 'length' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report for simple signal property access', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'myChannels_$' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'MemberExpression',
+                  object: { type: 'ThisExpression' },
+                  property: { type: 'Identifier', name: 'myChannels_DH' },
+                },
+                property: { type: 'Identifier', name: 'dataList_$' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report for binary expression (multiplication)', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+        expect(options.data.name).toBe('shownHUNVat');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'shownHUNVat' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'BinaryExpression',
+                operator: '*',
+                left: { type: 'Identifier', name: 'HU_vat' },
+                right: { type: 'Literal', value: 100 },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for function call', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+        expect(options.data.name).toBe('selectedPackageType');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'selectedPackageType' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'MemberExpression',
+                object: {
+                  type: 'CallExpression',
+                  callee: {
+                    type: 'MemberExpression',
+                    object: { type: 'ThisExpression' },
+                    property: { type: 'Identifier', name: 'completedPurchaseData$' },
+                  },
+                  arguments: [],
+                },
+                property: { type: 'Identifier', name: 'selectedPackageType' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for unary expression', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'negatedValue' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'UnaryExpression',
+                operator: '!',
+                argument: { type: 'Identifier', name: 'someValue' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for conditional expression (ternary)', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'conditionalValue' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'ConditionalExpression',
+                test: { type: 'Identifier', name: 'condition' },
+                consequent: { type: 'Literal', value: 'true' },
+                alternate: { type: 'Literal', value: 'false' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report for logical expression', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: (options: any) => {
+        reportCalled = true;
+        expect(options.messageId).toBe('noLogic');
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'logicalValue' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'LogicalExpression',
+                operator: '&&',
+                left: { type: 'Identifier', name: 'value1' },
+                right: { type: 'Identifier', name: 'value2' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report for non-getter methods', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'method',
+      key: { name: 'someMethod' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'CallExpression',
+                callee: { type: 'Identifier', name: 'someFunction' },
+                arguments: [],
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should not report for setter methods', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'set',
+      key: { name: 'someSetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ExpressionStatement',
+              expression: {
+                type: 'AssignmentExpression',
+                operator: '=',
+                left: { type: 'Identifier', name: 'this.value' },
+                right: { type: 'Identifier', name: 'value' },
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should handle getter without body gracefully', () => {
+    let reportCalled = false;
+    const mockContext = {
+      report: () => {
+        reportCalled = true;
+      },
+      options: [],
+      sourceCode: {
+        getText: () => '',
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'emptyGetter' },
+      value: {},
+    } as any;
+
+    expect(() => {
+      rule.MethodDefinition(mockNode);
+    }).not.toThrow();
+
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should handle errors gracefully', () => {
+    const mockContext = {
+      report: () => {},
+      options: [],
+      sourceCode: {
+        getText: () => {
+          throw new Error('Test error');
+        },
+      },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'testGetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'ReturnStatement',
+              argument: {
+                type: 'CallExpression',
+                callee: { type: 'Identifier', name: 'test' },
+                arguments: [],
+              },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    // Should not throw error
+    expect(() => {
+      rule.MethodDefinition(mockNode);
+    }).not.toThrow();
+  });
+});

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

@@ -0,0 +1,201 @@
+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)
+ */
+function isForbiddenNodeType(nodeType: string): boolean {
+  const forbiddenTypes = [
+    'CallExpression',
+    'BinaryExpression',
+    'UnaryExpression',
+    'ConditionalExpression',
+    'LogicalExpression',
+    'AssignmentExpression',
+    'UpdateExpression',
+    'NewExpression',
+    'YieldExpression',
+    'AwaitExpression',
+    'TaggedTemplateExpression',
+    'TemplateLiteral',
+    'SequenceExpression',
+    'SpreadElement',
+    'RestElement',
+  ];
+
+  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
+  if (node.type === 'BlockStatement') {
+    if (node.body && Array.isArray(node.body)) {
+      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;