@futdevpro/dynamo-eslint 1.20.2 → 1.20.5

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

@@ -1,189 +0,0 @@
-import namingPatternsRule from './naming-patterns';
-
-describe('| naming-patterns', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(namingPatternsRule.meta?.type).toBe('suggestion');
-    expect(namingPatternsRule.meta?.docs?.description).toContain('naming conventions');
-  });
-
-  it('| should expose PropertyDefinition / ClassDeclaration / TSEnumDeclaration visitors for non-spec files', () => {
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: () => {},
-      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');
-  });
-
-  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();
-  });
-
-  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 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;
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    const mockNode: any = { id: { name: 'User_DataModel' } };
-    rule.ClassDeclaration(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-
-  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);
-  });
-
-  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);
-  });
-
-  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);
-  });
-
-  // ─ BFR-ADVENTOR-018 — kanonikus `ls` nyelv-service kivétel a service-property-postfix alól ─
-
-  /** Helper: inject(<serviceName>) CallExpression mock. */
-  function buildInjectNode(propName: string, serviceName: string): any {
-    return {
-      key: { type: 'Identifier', name: propName },
-      value: {
-        type: 'CallExpression',
-        callee: { type: 'Identifier', name: 'inject' },
-        arguments: [ { type: 'Identifier', name: serviceName } ],
-      },
-    };
-  }
-
-  it('| BFR-ADVENTOR-018: `ls = inject(A_Language_ControlService)` NEM lelet (beépített kivétel)', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/app.component.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'servicePropertyPostfix') {
-          reportCalled = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    rule.PropertyDefinition(buildInjectNode('ls', 'A_Language_ControlService'));
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| BFR-ADVENTOR-018: más rövid név ControlService-re továbbra is lelet', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/app.component.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'servicePropertyPostfix') {
-          reportCalled = true;
-        }
-      },
-      options: [],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    rule.PropertyDefinition(buildInjectNode('auth', 'A_Auth_ControlService'));
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| BFR-ADVENTOR-018: projekt-szintű allowedPropertyNames opció bővíti a kivétel-listát', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/app.component.ts',
-      report: (options: any): void => {
-        if (options.messageId === 'servicePropertyPostfix') {
-          reportCalled = true;
-        }
-      },
-      options: [ { allowedPropertyNames: [ 'store' ] } ],
-    };
-    const rule: any = namingPatternsRule.create(mockContext);
-    rule.PropertyDefinition(buildInjectNode('store', 'A_Store_ControlService'));
-    expect(reportCalled).toBe(false);
-  });
-});

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

@@ -1,426 +0,0 @@
-import * as path from 'path';
-import { Rule } from 'eslint';
-
-/**
- * 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' },
-];
-
-/**
- * BFR-ADVENTOR-018: kanonikus, a service-property-postfix kényszer ALÓL KIVETT property-nevek.
- * Az `ls` a flotta bevett nyelv-service mintája (`readonly ls = inject(A_Language_ControlService)`;
- * a template-ekben `{{ ls.llt.… }}`) — a szabály eddig a bedrock SAJÁT dokumentált
- * konzumens-mintáját flagelte. Projekt-szinten bővíthető az `allowedPropertyNames` opcióval.
- */
-const DEFAULT_ALLOWED_PROPERTY_NAMES: string[] = [ 'ls' ];
-
-/** 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 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,
-          },
-          allowedPropertyNames: {
-            type: 'array',
-            items: { type: 'string' },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-    messages: {
-      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: 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; allowedPropertyNames?: string[] } =
-      (context.options[0] ?? {}) as { checks?: NamingChecksOptions; allowedPropertyNames?: string[] };
-    const checks: NamingChecksOptions = userOptions.checks ?? {};
-    const isOn = (key: keyof NamingChecksOptions): boolean => checks[key] !== false;
-    // BFR-ADVENTOR-018: beépített kanonikus kivételek + projekt-szintű bővítés
-    const allowedPropertyNames: string[] = [
-      ...DEFAULT_ALLOWED_PROPERTY_NAMES,
-      ...(userOptions.allowedPropertyNames ?? []),
-    ];
-
-    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 {
-      PropertyDefinition(node: any): void {
-        try {
-          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') && !allowedPropertyNames.includes(propName)) {
-            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 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);
-        }
-      },
-    };
-  },
-};
-
-export default rule;