@futdevpro/dynamo-eslint 1.15.6 → 1.15.8

package/src/plugin/rules/naming-patterns.spec.ts

@@ -6,36 +6,122 @@ describe('| naming-patterns', () => {
     expect(namingPatternsRule.meta?.docs?.description).toContain('naming conventions');
   });
 
-  it('| should have create function that returns object with Identifier method', () => {
-    const mockContext = {
+  it('| should expose PropertyDefinition / ClassDeclaration / TSEnumDeclaration visitors for non-spec files', () => {
+    const mockContext: any = {
+      filename: '/x/foo.ts',
       report: () => {},
-    } as any;
+      options: [],
+    };
+    const result: any = namingPatternsRule.create(mockContext);
+    expect(typeof result.PropertyDefinition).toBe('function');
+    expect(typeof result.ClassDeclaration).toBe('function');
+    expect(typeof result.TSEnumDeclaration).toBe('function');
+  });
 
-    const result = namingPatternsRule.create(mockContext);
+  it('| should skip .spec.ts files entirely', () => {
+    const mockContext: any = {
+      filename: '/x/foo.spec.ts',
+      report: () => {},
+      options: [],
+    };
+    const result: any = namingPatternsRule.create(mockContext);
+    expect(result.PropertyDefinition).toBeUndefined();
+  });
 
-    expect(typeof result).toBe('object');
-    expect(typeof result.Identifier).toBe('function');
+  it('| should report class without required postfix in *.data-model.ts', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'fileClassPostfix') {
+          reportCalled = true;
+          expect(options.data.requiredPostfix).toBe('_DataModel');
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = { id: { name: 'User' } };
+    rule.ClassDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
   });
 
-  it('| should handle valid identifiers without errors', () => {
-    const mockContext = {
-      report: (options: any) => {
-        // Should not be called for valid identifiers
-        fail('Should not report errors for valid identifiers');
+  it('| should NOT report class with correct postfix in *.data-model.ts', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'fileClassPostfix') {
+          reportCalled = true;
+        }
       },
-    } as any;
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = { id: { name: 'User_DataModel' } };
+    rule.ClassDeclaration(mockNode);
+    expect(reportCalled).toBe(false);
+  });
 
-    const mockNode = {
-      type: 'Identifier' as const,
-      name: 'validVariableName',
-      loc: { start: { line: 1 }, end: { line: 1 } },
-    } as any;
+  it('| should report non-camelCase enum key in *.type-enum.ts', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user-status.type-enum.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'enumKeyCamel') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = {
+      members: [
+        { id: { name: 'NotCamelCase' }, initializer: null },
+      ],
+    };
+    rule.TSEnumDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
 
-    const rule = namingPatternsRule.create(mockContext);
+  it('| should report non-kebab-case string value in enum', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user-status.type-enum.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'enumValueKebab') {
+          reportCalled = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = {
+      members: [
+        {
+          id: { name: 'activeUser' },
+          initializer: { type: 'Literal', value: 'NotKebabCase' },
+        },
+      ],
+    };
+    rule.TSEnumDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
 
-    rule.Identifier(mockNode);
-    
-    // If we get here without the report function being called, the test passes
-    expect(true).toBe(true);
+  it('| should respect `checks` option and disable booleanIsPrefix', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.ts',
+      report: () => { reportCalled = true; },
+      options: [{ checks: { booleanIsPrefix: false }}],
+    };
+    const rule: any = namingPatternsRule.create(mockContext);
+    const mockNode: any = {
+      key: { type: 'Identifier', name: 'active' },
+      typeAnnotation: { typeAnnotation: { type: 'TSBooleanKeyword' }},
+      value: null,
+    };
+    rule.PropertyDefinition(mockNode);
+    expect(reportCalled).toBe(false);
   });
 });

package/src/plugin/rules/naming-patterns.ts

@@ -1,23 +1,404 @@
+import * as path from 'path';
 import { Rule } from 'eslint';
-// import * as dyfmUtils from '@futdevpro/fsm-dynamo';
 
+/**
+ * Konfigurálható al-ellenőrzések — alapból minden bekapcsolva.
+ * Eredete: CCAP "naming/*" review-k (boolean-is-prefix, signal-postfix, rxjs-postfix,
+ * file-class-postfix, enum-value-format, service-property-postfix,
+ * file-class-name-consistency).
+ */
+interface NamingChecksOptions {
+  booleanIsPrefix?: boolean;
+  signalPostfix?: boolean;
+  rxjsPostfix?: boolean;
+  fileClassPostfix?: boolean;
+  enumValueFormat?: boolean;
+  servicePropertyPostfix?: boolean;
+  fileClassNameConsistency?: boolean;
+}
+
+/**
+ * Fájlminta → kötelező class postfix leképezés (CCAP file-class-postfix).
+ */
+const FILE_POSTFIX_MAP: { pattern: RegExp; classPostfix: string; entitySuffix: string }[] = [
+  { pattern: /\.data-model\.ts$/, classPostfix: '_DataModel', entitySuffix: '.data-model.ts' },
+  { pattern: /\.control-model\.ts$/, classPostfix: '_ControlModel', entitySuffix: '.control-model.ts' },
+  { pattern: /\.control-service\.ts$/, classPostfix: '_ControlService', entitySuffix: '.control-service.ts' },
+  { pattern: /\.data-service\.ts$/, classPostfix: '_DataService', entitySuffix: '.data-service.ts' },
+  { pattern: /\.api-service\.ts$/, classPostfix: '_ApiService', entitySuffix: '.api-service.ts' },
+  { pattern: /\.util-service\.ts$/, classPostfix: '_Util', entitySuffix: '.util-service.ts' },
+  { pattern: /\.service-base\.ts$/, classPostfix: '_ServiceBase', entitySuffix: '.service-base.ts' },
+  { pattern: /\.controller\.ts$/, classPostfix: '_Controller', entitySuffix: '.controller.ts' },
+  { pattern: /\.component\.ts$/, classPostfix: '_Component', entitySuffix: '.component.ts' },
+  { pattern: /\.pipe\.ts$/, classPostfix: '_Pipe', entitySuffix: '.pipe.ts' },
+  { pattern: /\.directive\.ts$/, classPostfix: '_Directive', entitySuffix: '.directive.ts' },
+  { pattern: /\.module\.ts$/, classPostfix: '_Module', entitySuffix: '.module.ts' },
+];
+
+/** Service class postfix → kötelező inject property postfix leképezés (CCAP service-property-postfix). */
+const SERVICE_INJECT_POSTFIX_MAP: { classPostfix: string; propertyPostfix: string }[] = [
+  { classPostfix: '_DataService', propertyPostfix: '_DS' },
+  { classPostfix: '_ControlService', propertyPostfix: '_CS' },
+  { classPostfix: '_ApiService', propertyPostfix: '_AS' },
+  { classPostfix: '_MasterService', propertyPostfix: '_MS' },
+];
+
+/** Signal factory függvény nevek (CCAP signal-postfix). */
+const SIGNAL_FACTORY_NAMES: Set<string> = new Set<string>([ 'signal', 'computed', 'toSignal' ]);
+
+/** RxJS típusnevek detektáláshoz. */
+const RXJS_BEHAVIOR_SUBJECT_NAME: string = 'BehaviorSubject';
+const RXJS_SUBJECT_NAME: string = 'Subject';
+const RXJS_OBSERVABLE_NAME: string = 'Observable';
+
+/** camelCase enum kulcs regex. */
+const CAMEL_CASE_KEY_REGEX: RegExp = /^[a-z][a-zA-Z0-9]*$/;
+
+/** kebab-case enum érték regex. */
+const KEBAB_CASE_VALUE_REGEX: RegExp = /^[a-z0-9][a-z0-9-]*$/;
+
+/**
+ * PascalCase szót kebab-case-re konvertál (CCAP file-class-name-consistency).
+ */
+function pascalPartToKebab(str: string): string {
+  if (str === str.toUpperCase() && str.length > 1) {
+    return str.toLowerCase();
+  }
+  return str
+    .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+    .replace(/([A-Z]+)([A-Z][a-z])/g, '$1-$2')
+    .toLowerCase();
+}
+
+/**
+ * Class entity nevet kebab-case fájlnév entity részére konvertál.
+ */
+function classEntityToKebab(classEntity: string): string {
+  const parts: string[] = classEntity.split('_').filter((p: string): boolean => p.length > 0);
+  return parts.map(pascalPartToKebab).join('-');
+}
+
+/**
+ * Megnézi, hogy a property type-annotation `boolean`-e.
+ */
+function isBooleanType(typeAnnotation: any): boolean {
+  if (!typeAnnotation || !typeAnnotation.typeAnnotation) {
+    return false;
+  }
+  return typeAnnotation.typeAnnotation.type === 'TSBooleanKeyword';
+}
+
+/**
+ * Megnézi, hogy a property init signal/computed/toSignal hívás-e.
+ */
+function isSignalFactoryCall(init: any): boolean {
+  if (!init || init.type !== 'CallExpression') {
+    return false;
+  }
+  const callee: any = init.callee;
+  if (!callee || callee.type !== 'Identifier') {
+    return false;
+  }
+  return SIGNAL_FACTORY_NAMES.has(callee.name);
+}
+
+/**
+ * Detektálja az RxJS típust property type-annotation vagy `new XSubject()` init alapján.
+ */
+function detectRxjsKind(typeAnnotation: any, init: any): 'BS' | 'S' | 'OBS' | null {
+  const typeName: string | null = (() => {
+    if (!typeAnnotation || !typeAnnotation.typeAnnotation) {
+      return null;
+    }
+    const t: any = typeAnnotation.typeAnnotation;
+    if (t.type !== 'TSTypeReference' || !t.typeName) {
+      return null;
+    }
+    if (t.typeName.type === 'Identifier') {
+      return t.typeName.name;
+    }
+    return null;
+  })();
+
+  const newName: string | null = (() => {
+    if (!init || init.type !== 'NewExpression' || !init.callee || init.callee.type !== 'Identifier') {
+      return null;
+    }
+    return init.callee.name;
+  })();
+
+  const candidate: string | null = typeName ?? newName;
+  if (candidate === null) {
+    return null;
+  }
+  if (candidate === RXJS_BEHAVIOR_SUBJECT_NAME) {
+    return 'BS';
+  }
+  if (candidate === RXJS_SUBJECT_NAME) {
+    return 'S';
+  }
+  if (candidate === RXJS_OBSERVABLE_NAME) {
+    return 'OBS';
+  }
+  return null;
+}
+
+/**
+ * Detektálja, hogy az init `inject(SomeService)` hívás-e — visszaadja a service nevet.
+ */
+function detectInjectedService(init: any): string | null {
+  if (!init || init.type !== 'CallExpression') {
+    return null;
+  }
+  if (!init.callee || init.callee.type !== 'Identifier' || init.callee.name !== 'inject') {
+    return null;
+  }
+  const arg: any = init.arguments && init.arguments[0];
+  if (!arg || arg.type !== 'Identifier') {
+    return null;
+  }
+  return arg.name;
+}
+
+/**
+ * Property kulcs név szöveggé alakítása.
+ */
+function getPropertyKeyName(node: any): string | null {
+  if (node.key && node.key.type === 'Identifier' && node.key.name) {
+    return node.key.name;
+  }
+  return null;
+}
+
+/**
+ * Naming-patterns szabály (CCAP-megerősített): 7 al-ellenőrzés a CCAP "naming/*" review-kből.
+ * Minden al-ellenőrzés külön-külön kapcsolható a `checks` schema option-nel.
+ */
 const rule: Rule.RuleModule = {
   meta: {
     type: 'suggestion',
-    docs: { description: 'Enforce naming conventions using DyFM patterns' },
-    schema: [],
+    docs: {
+      description: 'Enforce Dynamo naming conventions (CCAP-derived sub-checks).',
+      recommended: true,
+    },
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          checks: {
+            type: 'object',
+            properties: {
+              booleanIsPrefix: { type: 'boolean' },
+              signalPostfix: { type: 'boolean' },
+              rxjsPostfix: { type: 'boolean' },
+              fileClassPostfix: { type: 'boolean' },
+              enumValueFormat: { type: 'boolean' },
+              servicePropertyPostfix: { type: 'boolean' },
+              fileClassNameConsistency: { type: 'boolean' },
+            },
+            additionalProperties: false,
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
     messages: {
-      invalidName: 'Identifier "{{name}}" does not match required naming pattern.',
+      booleanIsPrefix: 'Boolean property `{{name}}` nem `is`-sel kezdődik.',
+      signalPostfix: 'Signal változó `{{name}}` nem végződik `_$`-re.',
+      rxjsBsPostfix: '`BehaviorSubject` mező `{{name}}` nem végződik `_BS`-re.',
+      rxjsSPostfix: '`Subject` mező `{{name}}` nem végződik `_S`-re.',
+      rxjsObsPostfix: '`Observable` mező `{{name}}` nem végződik `$`-re.',
+      fileClassPostfix:
+        'Osztály `{{className}}` nem végződik `{{requiredPostfix}}`-re (fájlminta: {{fileName}}).',
+      enumKeyCamel: 'Enum kulcs `{{keyName}}` nem camelCase.',
+      enumValueKebab: 'Enum érték `{{value}}` nem kebab-case.',
+      servicePropertyPostfix:
+        'Property `{{property}}` `{{service}}`-t inject-el, de nem végződik `{{requiredPostfix}}`-re.',
+      fileClassNameConsistency:
+        'Osztály `{{className}}` entity része `{{classEntity}}` → '
+        + 'elvárt fájlnév entity: `{{expected}}`, de a tényleges: `{{actual}}`.',
     },
   },
-  create(context) {
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    const filename: string = context.filename ?? '';
+    const baseName: string = path.basename(filename);
+    if (baseName.endsWith('.spec.ts') || baseName.endsWith('.test.ts') || baseName.endsWith('.d.ts')) {
+      return {};
+    }
+
+    const userOptions: { checks?: NamingChecksOptions } = (context.options[0] ?? {}) as { checks?: NamingChecksOptions };
+    const checks: NamingChecksOptions = userOptions.checks ?? {};
+    const isOn = (key: keyof NamingChecksOptions): boolean => checks[key] !== false;
+
+    const filePostfixRule: { pattern: RegExp; classPostfix: string; entitySuffix: string } | undefined =
+      FILE_POSTFIX_MAP.find(
+        (r: { pattern: RegExp; classPostfix: string; entitySuffix: string }): boolean =>
+          r.pattern.test(baseName),
+      );
+
     return {
-      Identifier(node) {
+      PropertyDefinition(node: any): void {
         try {
-          // Future: use dyfmUtils naming patterns to validate identifiers
-          void node;
+          const propName: string | null = getPropertyKeyName(node);
+          if (propName === null) {
+            return;
+          }
+
+          if (
+            isOn('booleanIsPrefix')
+            && isBooleanType(node.typeAnnotation)
+            && !propName.startsWith('is')
+            && !propName.endsWith('_$')
+          ) {
+            context.report({
+              node: node.key,
+              messageId: 'booleanIsPrefix',
+              data: { name: propName },
+            });
+          }
+
+          if (
+            isOn('signalPostfix')
+            && isSignalFactoryCall(node.value)
+            && !propName.endsWith('_$')
+          ) {
+            context.report({
+              node: node.key,
+              messageId: 'signalPostfix',
+              data: { name: propName },
+            });
+          }
+
+          if (isOn('rxjsPostfix')) {
+            const rxKind: 'BS' | 'S' | 'OBS' | null = detectRxjsKind(node.typeAnnotation, node.value);
+            if (rxKind === 'BS' && !propName.endsWith('_BS')) {
+              context.report({ node: node.key, messageId: 'rxjsBsPostfix', data: { name: propName } });
+            } else if (rxKind === 'S' && !propName.endsWith('_S') && !propName.endsWith('_BS')) {
+              context.report({ node: node.key, messageId: 'rxjsSPostfix', data: { name: propName } });
+            } else if (rxKind === 'OBS' && !propName.endsWith('$')) {
+              context.report({ node: node.key, messageId: 'rxjsObsPostfix', data: { name: propName } });
+            }
+          }
+
+          if (isOn('servicePropertyPostfix')) {
+            const injectedService: string | null = detectInjectedService(node.value);
+            if (injectedService !== null) {
+              for (const mapping of SERVICE_INJECT_POSTFIX_MAP) {
+                if (
+                  injectedService.endsWith(mapping.classPostfix)
+                  && !propName.endsWith(mapping.propertyPostfix)
+                ) {
+                  context.report({
+                    node: node.key,
+                    messageId: 'servicePropertyPostfix',
+                    data: {
+                      property: propName,
+                      service: injectedService,
+                      requiredPostfix: mapping.propertyPostfix,
+                    },
+                  });
+                  break;
+                }
+              }
+            }
+          }
         } catch (error) {
-          console.error('[naming-patterns] Error in Identifier visitor:', error);
+          console.error('[naming-patterns] Error in PropertyDefinition visitor:', error);
+        }
+      },
+
+      ClassDeclaration(node: any): void {
+        try {
+          if (!node.id || !node.id.name || !filePostfixRule) {
+            return;
+          }
+          const className: string = node.id.name;
+
+          if (isOn('fileClassPostfix') && !className.endsWith(filePostfixRule.classPostfix)) {
+            context.report({
+              node: node.id,
+              messageId: 'fileClassPostfix',
+              data: {
+                className: className,
+                requiredPostfix: filePostfixRule.classPostfix,
+                fileName: baseName,
+              },
+            });
+          }
+
+          if (isOn('fileClassNameConsistency') && className.endsWith(filePostfixRule.classPostfix)) {
+            const fileEntity: string = baseName.slice(
+              0,
+              baseName.length - filePostfixRule.entitySuffix.length,
+            );
+            const classEntity: string = className.slice(
+              0,
+              className.length - filePostfixRule.classPostfix.length,
+            );
+            const expectedFull: string = classEntityToKebab(classEntity);
+            const firstUnderscoreIdx: number = classEntity.indexOf('_');
+            const expectedWithoutPrefix: string = firstUnderscoreIdx > 0
+              ? classEntityToKebab(classEntity.slice(firstUnderscoreIdx + 1))
+              : '';
+            const isMatch: boolean = expectedFull === fileEntity || expectedWithoutPrefix === fileEntity;
+            if (!isMatch && classEntity.length > 0) {
+              context.report({
+                node: node.id,
+                messageId: 'fileClassNameConsistency',
+                data: {
+                  className: className,
+                  classEntity: classEntity,
+                  expected: expectedFull + (expectedWithoutPrefix ? ` vagy ${expectedWithoutPrefix}` : ''),
+                  actual: fileEntity,
+                },
+              });
+            }
+          }
+        } catch (error) {
+          console.error('[naming-patterns] Error in ClassDeclaration visitor:', error);
+        }
+      },
+
+      TSEnumDeclaration(node: any): void {
+        try {
+          if (!isOn('enumValueFormat')) {
+            return;
+          }
+          if (!baseName.endsWith('.type-enum.ts')) {
+            return;
+          }
+          const members: any[] = node.members ?? [];
+          for (const member of members) {
+            const keyName: string | null = (member.id && member.id.name) ? member.id.name : null;
+            const initializer: any = member.initializer;
+            if (keyName === null) {
+              continue;
+            }
+            if (!CAMEL_CASE_KEY_REGEX.test(keyName)) {
+              context.report({
+                node: member.id,
+                messageId: 'enumKeyCamel',
+                data: { keyName: keyName },
+              });
+              continue;
+            }
+            if (
+              initializer
+              && initializer.type === 'Literal'
+              && typeof initializer.value === 'string'
+            ) {
+              const value: string = initializer.value;
+              if (!KEBAB_CASE_VALUE_REGEX.test(value)) {
+                context.report({
+                  node: initializer,
+                  messageId: 'enumValueKebab',
+                  data: { value: value },
+                });
+              }
+            }
+          }
+        } catch (error) {
+          console.error('[naming-patterns] Error in TSEnumDeclaration visitor:', error);
         }
       },
     };
@@ -25,5 +406,3 @@ const rule: Rule.RuleModule = {
 };
 
 export default rule;
-
-

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

@@ -479,6 +479,77 @@ describe('| no-getter-logic', () => {
     expect(reportCalled).toBe(false);
   });
 
+  it('| should report multi-statement getter body (CCAP-megerősítés)', () => {
+    let reportCalled: boolean = 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: 'multiStatementGetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'VariableDeclaration',
+              declarations: [{ id: { name: 'tmp' }, init: { type: 'Identifier', name: 'foo' }}],
+            },
+            {
+              type: 'ReturnStatement',
+              argument: { type: 'Identifier', name: 'tmp' },
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should report `if`-statement inside getter (CCAP-megerősítés)', () => {
+    let reportCalled: boolean = false;
+    const mockContext = {
+      report: () => { reportCalled = true; },
+      options: [],
+      sourceCode: { getText: () => '' },
+    } as any;
+
+    const rule = noGetterLogicRule.create(mockContext);
+
+    const mockNode = {
+      kind: 'get',
+      key: { name: 'gateGetter' },
+      value: {
+        body: {
+          type: 'BlockStatement',
+          body: [
+            {
+              type: 'IfStatement',
+              test: { type: 'Identifier', name: 'cond' },
+              consequent: { type: 'ReturnStatement', argument: { type: 'Literal', value: 1 }},
+              alternate: { type: 'ReturnStatement', argument: { type: 'Literal', value: 0 }},
+            },
+          ],
+        },
+      },
+    } as any;
+
+    rule.MethodDefinition(mockNode);
+
+    expect(reportCalled).toBe(true);
+  });
+
   it('| should handle errors gracefully', () => {
     const mockContext = {
       report: () => {},

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

@@ -18,7 +18,9 @@ function isAllowedNodeType(nodeType: string): boolean {
 }
 
 /**
- * Check if a node type is explicitly forbidden (logic, calculations, function calls)
+ * 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 = [
@@ -37,6 +39,18 @@ function isForbiddenNodeType(nodeType: string): boolean {
     '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);
@@ -85,9 +99,14 @@ function containsForbiddenNode(node: any): boolean {
     return false;
   }
 
-  // Special handling for BlockStatement - check all statements
+  // 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;