@futdevpro/dynamo-eslint 1.20.3 → 1.20.5

package/src/plugin/rules/ts/data-model-extends.ts

@@ -1,100 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * Parallel date field nevek – ezeket egy DataModel sem tartalmazhatja,
- * mert a `DyFM_Metadata` `__created` / `__updated` mezőit kell használni.
- */
-const PARALLEL_DATE_FIELD_NAMES: Set<string> = new Set<string>([
-  'firstRegisteredAt',
-  'lastSeenAt',
-  'createdAt',
-  'updatedAt',
-  'registeredAt',
-  'seenAt',
-  'modifiedAt',
-  'lastModified',
-  'lastUpdated',
-  'dateCreated',
-  'dateUpdated',
-]);
-
-/**
- * Data-model-extends szabály: `*.data-model.ts` osztályoknak `DyFM_Metadata`-t (vagy bármely `DyFM_*`-ot)
- * kell kiterjeszteniük, és tilos párhuzamos dátum mezőket definiálni.
- * CCAP "data-model-extends" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: '`*.data-model.ts` classes must extend `DyFM_*`; no parallel date fields allowed.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      missingExtends:
-        '`{{className}}` nem terjeszti ki a `DyFM_Metadata`-t (vagy `DyFM_*` base-t). '
-        + 'DataModel osztálynak `extends DyFM_Metadata` szükséges.',
-      parallelDateField:
-        'Párhuzamos dátum mező `{{fieldName}}` tilos. '
-        + 'Használd a `DyFM_Metadata`-ból örökölt `__created` / `__updated` mezőket.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (!filename.endsWith('.data-model.ts')) {
-      return {};
-    }
-
-    return {
-      ClassDeclaration(node: any): void {
-        try {
-          const superClass: any = node.superClass;
-          let extendsName: string | null = null;
-          if (superClass && superClass.type === 'Identifier') {
-            extendsName = superClass.name;
-          } else if (
-            superClass
-            && superClass.type === 'MemberExpression'
-            && superClass.property
-            && superClass.property.name
-          ) {
-            extendsName = superClass.property.name;
-          }
-          const isDyFmExtends: boolean = extendsName !== null && extendsName.startsWith('DyFM_');
-          if (!isDyFmExtends) {
-            const className: string = (node.id && node.id.name) ? node.id.name : 'anonymous';
-            context.report({
-              node: node.id ?? node,
-              messageId: 'missingExtends',
-              data: { className: className },
-            });
-          }
-
-          const body: any = node.body;
-          if (!body || !Array.isArray(body.body)) {
-            return;
-          }
-          for (const member of body.body) {
-            if (member.type !== 'PropertyDefinition') {
-              continue;
-            }
-            const key: any = member.key;
-            const fieldName: string | null = (key && key.type === 'Identifier' && key.name) ? key.name : null;
-            if (fieldName !== null && PARALLEL_DATE_FIELD_NAMES.has(fieldName)) {
-              context.report({
-                node: member,
-                messageId: 'parallelDateField',
-                data: { fieldName: fieldName },
-              });
-            }
-          }
-        } catch (error) {
-          console.error('[data-model-extends] Error in ClassDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/ts/no-any-type.spec.ts

@@ -1,28 +0,0 @@
-import noAnyTypeRule from './no-any-type';
-
-describe('| no-any-type', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noAnyTypeRule.meta?.type).toBe('suggestion');
-    expect(noAnyTypeRule.meta?.messages?.noAny).toBeDefined();
-  });
-
-  it('| should have create function returning visitor object', () => {
-    const mockContext: any = { report: () => {}, options: [] };
-    const result: any = noAnyTypeRule.create(mockContext);
-    expect(typeof result.TSAnyKeyword).toBe('function');
-  });
-
-  it('| should report on `any` keyword', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noAny');
-      },
-      options: [],
-    };
-    const rule: any = noAnyTypeRule.create(mockContext);
-    rule.TSAnyKeyword({});
-    expect(reportCalled).toBe(true);
-  });
-});

package/src/plugin/rules/ts/no-any-type.ts

@@ -1,36 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * No-any-type szabály: `any` típus annotáció tilos.
- * CCAP "no-any-type" review ESLint AST-portja.
- * Lefedi a `: any`, `<any>`, `as any`, `Array<any>`, `Promise<any>` eseteket egyaránt.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid `any` type annotation in TypeScript files.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noAny: '`any` típus tilos. Adj meg konkrét típust vagy használj `unknown`-t.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      TSAnyKeyword(node: any): void {
-        try {
-          context.report({
-            node: node,
-            messageId: 'noAny',
-          });
-        } catch (error) {
-          console.error('[no-any-type] Error in TSAnyKeyword visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/ts/no-as-cast.spec.ts

@@ -1,51 +0,0 @@
-import noAsCastRule from './no-as-cast';
-
-describe('| no-as-cast', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noAsCastRule.meta?.type).toBe('suggestion');
-    expect(noAsCastRule.meta?.messages?.noAsCast).toBeDefined();
-  });
-
-  it('| should have create function returning visitor object', () => {
-    const mockContext: any = {
-      report: () => {},
-      options: [],
-      sourceCode: { getText: () => 'X' },
-    };
-    const result: any = noAsCastRule.create(mockContext);
-    expect(typeof result.TSAsExpression).toBe('function');
-  });
-
-  it('| should not report `as const`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: () => { reportCalled = true; },
-      options: [],
-      sourceCode: { getText: () => 'const' },
-    };
-    const rule: any = noAsCastRule.create(mockContext);
-    const mockNode: any = {
-      typeAnnotation: { type: 'TSTypeReference', typeName: { type: 'Identifier', name: 'const' } },
-    };
-    rule.TSAsExpression(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-
-  it('| should report `as SomeType`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noAsCast');
-      },
-      options: [],
-      sourceCode: { getText: () => 'MyType' },
-    };
-    const rule: any = noAsCastRule.create(mockContext);
-    const mockNode: any = {
-      typeAnnotation: { type: 'TSTypeReference', typeName: { type: 'Identifier', name: 'MyType' } },
-    };
-    rule.TSAsExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-});

package/src/plugin/rules/ts/no-as-cast.ts

@@ -1,51 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * No-as-cast szabály: TypeScript `as` type cast tilos.
- * CCAP "no-as-cast" review ESLint AST-portja.
- * Megjegyzés: az `as const` kifejezést megengedjük (immutable literal-ként standard).
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid TypeScript `as` type casts (except `as const`); design issue indicator.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noAsCast: '`as {{typeName}}` type cast tilos. Tervezési problémát jelezhet — használj rendes típust.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      TSAsExpression(node: any): void {
-        try {
-          const annotation: any = node.typeAnnotation;
-          if (!annotation) {
-            return;
-          }
-          // `as const` esetén megengedjük – immutable literal idiomatika.
-          if (
-            annotation.type === 'TSTypeReference'
-            && annotation.typeName
-            && annotation.typeName.type === 'Identifier'
-            && annotation.typeName.name === 'const'
-          ) {
-            return;
-          }
-          const typeName: string = context.sourceCode.getText(annotation);
-          context.report({
-            node: node,
-            messageId: 'noAsCast',
-            data: { typeName: typeName },
-          });
-        } catch (error) {
-          console.error('[no-as-cast] Error in TSAsExpression visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/ts/no-dynamic-imports.spec.ts

@@ -1,54 +0,0 @@
-import noDynamicImportsRule from './no-dynamic-imports';
-
-describe('| no-dynamic-imports', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noDynamicImportsRule.meta?.type).toBe('suggestion');
-    expect(noDynamicImportsRule.meta?.messages?.noDynamicImport).toBeDefined();
-    expect(noDynamicImportsRule.meta?.messages?.noRequireCall).toBeDefined();
-  });
-
-  it('| should have create function returning visitor object', () => {
-    const mockContext: any = { report: () => {}, options: [] };
-    const result: any = noDynamicImportsRule.create(mockContext);
-    expect(typeof result.ImportExpression).toBe('function');
-    expect(typeof result.CallExpression).toBe('function');
-  });
-
-  it('| should report dynamic import()', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noDynamicImport');
-      },
-      options: [],
-    };
-    const rule: any = noDynamicImportsRule.create(mockContext);
-    rule.ImportExpression({});
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report require() call', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noRequireCall');
-      },
-      options: [],
-    };
-    const rule: any = noDynamicImportsRule.create(mockContext);
-    const mockNode: any = { callee: { type: 'Identifier', name: 'require' } };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report unrelated function calls', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noDynamicImportsRule.create(mockContext);
-    const mockNode: any = { callee: { type: 'Identifier', name: 'someOtherCall' } };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});

package/src/plugin/rules/ts/no-dynamic-imports.ts

@@ -1,49 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * No-dynamic-imports szabály: `import()` és `require()` dinamikus hívás tilos.
- * Minden import a fájl tetején, top-level `import { … } from '…'` formában szerepeljen.
- * CCAP "no-dynamic-imports" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Forbid dynamic `import()` and `require()` calls; all imports must be top-level.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noDynamicImport: 'Dinamikus `import()` hívás tilos. Tedd top-level `import { … } from "…"` formába.',
-      noRequireCall: '`require()` hívás tilos. Használj top-level ES `import` szintaxist.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      ImportExpression(node: any): void {
-        try {
-          context.report({
-            node: node,
-            messageId: 'noDynamicImport',
-          });
-        } catch (error) {
-          console.error('[no-dynamic-imports] Error in ImportExpression visitor:', error);
-        }
-      },
-      CallExpression(node: any): void {
-        try {
-          if (node.callee && node.callee.type === 'Identifier' && node.callee.name === 'require') {
-            context.report({
-              node: node,
-              messageId: 'noRequireCall',
-            });
-          }
-        } catch (error) {
-          console.error('[no-dynamic-imports] Error in CallExpression visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/ts/no-native-browser-dialogs.spec.ts

@@ -1,54 +0,0 @@
-import noNativeBrowserDialogsRule from './no-native-browser-dialogs';
-
-describe('| no-native-browser-dialogs', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noNativeBrowserDialogsRule.meta?.type).toBe('suggestion');
-    expect(noNativeBrowserDialogsRule.meta?.messages?.noNativeDialog).toBeDefined();
-  });
-
-  it('| should report `alert(...)`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noNativeDialog');
-        expect(options.data.name).toBe('alert');
-      },
-      options: [],
-    };
-    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
-    const mockNode: any = { callee: { type: 'Identifier', name: 'alert' } };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report `window.confirm(...)`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.data.name).toBe('window.confirm');
-      },
-      options: [],
-    };
-    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
-    const mockNode: any = {
-      callee: {
-        type: 'MemberExpression',
-        object: { type: 'Identifier', name: 'window' },
-        property: { type: 'Identifier', name: 'confirm' },
-      },
-    };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report unrelated calls', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noNativeBrowserDialogsRule.create(mockContext);
-    const mockNode: any = { callee: { type: 'Identifier', name: 'doSomething' } };
-    rule.CallExpression(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});

package/src/plugin/rules/ts/no-native-browser-dialogs.ts

@@ -1,84 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * Tiltott natív browser dialog nevek.
- */
-const NATIVE_DIALOG_NAMES: Set<string> = new Set<string>([
-  'alert',
-  'confirm',
-  'prompt',
-  'showModalDialog',
-]);
-
-/**
- * Globális objektum nevek, amelyeken a dialog hívás detektálandó.
- */
-const GLOBAL_NAMES: Set<string> = new Set<string>([
-  'window',
-  'globalThis',
-  'self',
-  'top',
-  'parent',
-]);
-
-/**
- * No-native-browser-dialogs szabály: tilos a natív `window.alert` / `window.confirm` /
- * `window.prompt` / `showModalDialog` hívás. Helyette shared modal komponens (`S_Modal_Component`)
- * használandó. CCAP "no-native-browser-dialogs" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Forbid native blocking browser dialogs (`alert`, `confirm`, `prompt`, `showModalDialog`); '
-        + 'use shared modal component instead.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noNativeDialog:
-        'Natív browser dialog `{{name}}` tilos. '
-        + 'Használj shared modal komponenst (pl. `S_Modal_Component` / `app-s-modal`).',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    return {
-      CallExpression(node: any): void {
-        try {
-          const callee: any = node.callee;
-          if (!callee) {
-            return;
-          }
-          if (callee.type === 'Identifier' && NATIVE_DIALOG_NAMES.has(callee.name)) {
-            context.report({
-              node: node,
-              messageId: 'noNativeDialog',
-              data: { name: callee.name },
-            });
-            return;
-          }
-          if (
-            callee.type === 'MemberExpression'
-            && callee.object
-            && callee.object.type === 'Identifier'
-            && GLOBAL_NAMES.has(callee.object.name)
-            && callee.property
-            && callee.property.type === 'Identifier'
-            && NATIVE_DIALOG_NAMES.has(callee.property.name)
-          ) {
-            context.report({
-              node: node,
-              messageId: 'noNativeDialog',
-              data: { name: `${callee.object.name}.${callee.property.name}` },
-            });
-          }
-        } catch (error) {
-          console.error('[no-native-browser-dialogs] Error in CallExpression visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;

package/src/plugin/rules/ts/no-plain-function-export.spec.ts

@@ -1,72 +0,0 @@
-import noPlainFunctionExportRule from './no-plain-function-export';
-
-describe('| no-plain-function-export', () => {
-  it('| should be a valid ESLint rule', () => {
-    expect(noPlainFunctionExportRule.meta?.type).toBe('suggestion');
-    expect(noPlainFunctionExportRule.meta?.messages?.noFunctionExport).toBeDefined();
-    expect(noPlainFunctionExportRule.meta?.messages?.noConstFunctionExport).toBeDefined();
-  });
-
-  it('| should skip spec files', () => {
-    const mockContext: any = { filename: '/x/foo.spec.ts', report: () => {}, options: [] };
-    const result: any = noPlainFunctionExportRule.create(mockContext);
-    expect(result.ExportNamedDeclaration).toBeUndefined();
-  });
-
-  it('| should report `export function fn`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noFunctionExport');
-      },
-      options: [],
-    };
-    const rule: any = noPlainFunctionExportRule.create(mockContext);
-    const mockNode: any = {
-      declaration: { type: 'FunctionDeclaration', id: { name: 'helperFn' } },
-    };
-    rule.ExportNamedDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should report `export const fn = () => …`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = {
-      filename: '/x/foo.ts',
-      report: (options: any): void => {
-        reportCalled = true;
-        expect(options.messageId).toBe('noConstFunctionExport');
-      },
-      options: [],
-    };
-    const rule: any = noPlainFunctionExportRule.create(mockContext);
-    const mockNode: any = {
-      declaration: {
-        type: 'VariableDeclaration',
-        declarations: [
-          { id: { name: 'helperFn' }, init: { type: 'ArrowFunctionExpression' } },
-        ],
-      },
-    };
-    rule.ExportNamedDeclaration(mockNode);
-    expect(reportCalled).toBe(true);
-  });
-
-  it('| should not report `export const data = { … }`', () => {
-    let reportCalled: boolean = false;
-    const mockContext: any = { filename: '/x/foo.ts', report: () => { reportCalled = true; }, options: [] };
-    const rule: any = noPlainFunctionExportRule.create(mockContext);
-    const mockNode: any = {
-      declaration: {
-        type: 'VariableDeclaration',
-        declarations: [
-          { id: { name: 'data' }, init: { type: 'ObjectExpression' } },
-        ],
-      },
-    };
-    rule.ExportNamedDeclaration(mockNode);
-    expect(reportCalled).toBe(false);
-  });
-});

package/src/plugin/rules/ts/no-plain-function-export.ts

@@ -1,73 +0,0 @@
-import { Rule } from 'eslint';
-
-/**
- * No-plain-function-export szabály: tilos top-level `export function fn()` és
- * `export const fn = () => …` arrow/function deklaráció.
- * Megosztott logika static `_Util` / `UtilService` osztály metódusokban kell legyen.
- * CCAP "no-plain-function-export" review ESLint AST-portja.
- */
-const rule: Rule.RuleModule = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Forbid top-level `export function` and `export const fn = () => …`; '
-        + 'use static methods on `_Util` / `UtilService` classes.',
-      recommended: true,
-    },
-    schema: [],
-    messages: {
-      noFunctionExport:
-        'Top-level `export function {{name}}` tilos. '
-        + 'Tedd static metódusba `_Util` / `UtilService` osztályon belül.',
-      noConstFunctionExport:
-        'Top-level `export const {{name}} = () => …` tilos. '
-        + 'Tedd static metódusba `_Util` / `UtilService` osztályon belül.',
-    },
-  },
-  create(context: Rule.RuleContext): Rule.RuleListener {
-    const filename: string = context.filename ?? '';
-    if (filename.endsWith('.spec.ts') || filename.endsWith('.test.ts')) {
-      return {};
-    }
-
-    return {
-      ExportNamedDeclaration(node: any): void {
-        try {
-          const decl: any = node.declaration;
-          if (!decl) {
-            return;
-          }
-          if (decl.type === 'FunctionDeclaration' && decl.id && decl.id.name) {
-            context.report({
-              node: decl,
-              messageId: 'noFunctionExport',
-              data: { name: decl.id.name },
-            });
-            return;
-          }
-          if (decl.type === 'VariableDeclaration' && Array.isArray(decl.declarations)) {
-            for (const declarator of decl.declarations) {
-              const init: any = declarator.init;
-              if (!init) {
-                continue;
-              }
-              if (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression') {
-                const name: string = (declarator.id && declarator.id.name) ? declarator.id.name : 'anonymous';
-                context.report({
-                  node: declarator,
-                  messageId: 'noConstFunctionExport',
-                  data: { name: name },
-                });
-              }
-            }
-          }
-        } catch (error) {
-          console.error('[no-plain-function-export] Error in ExportNamedDeclaration visitor:', error);
-        }
-      },
-    };
-  },
-};
-
-export default rule;