@futdevpro/dynamo-eslint 1.15.7 → 1.15.9

package/src/plugin/rules/require-jsdoc-description.spec.ts

@@ -23,6 +23,7 @@ describe('| require-jsdoc-description', () => {
     expect(typeof result.ClassDeclaration).toBe('function');
     expect(typeof result.TSInterfaceDeclaration).toBe('function');
     expect(typeof result.TSEnumDeclaration).toBe('function');
+    expect(typeof result.TSTypeAliasDeclaration).toBe('function');
     expect(typeof result.MethodDefinition).toBe('function');
     expect(typeof result.VariableDeclarator).toBe('function');
   });

package/src/plugin/rules/require-jsdoc-description.ts

@@ -298,6 +298,8 @@ const rule: Rule.RuleModule = {
             return 'Interface';
           case 'TSEnumDeclaration':
             return 'Enum';
+          case 'TSTypeAliasDeclaration':
+            return 'Type';
           case 'MethodDefinition':
             return 'Method';
           case 'PropertyDefinition':
@@ -462,6 +464,23 @@ const rule: Rule.RuleModule = {
         }
       },
 
+      // Type alias declarations (CCAP-megerősítés: exportált `type X = …` kötelező JSDoc).
+      TSTypeAliasDeclaration(node: any, _context?: any, _sourceCode?: any): void {
+        try {
+          if (!shouldBeDocumented(node)) {
+            return;
+          }
+
+          const jsdocResult = hasValidJSDoc(node);
+
+          if (!jsdocResult.hasJSDoc || !jsdocResult.isValid || !jsdocResult.isOnPreviousLine) {
+            reportJSDocIssue(node, jsdocResult);
+          }
+        } catch (error) {
+          console.error('[require-jsdoc-description] Error in TSTypeAliasDeclaration visitor:', error);
+        }
+      },
+
       // Class methods
       MethodDefinition(node: any, _context?: any, _sourceCode?: any): void {
         try {

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

@@ -0,0 +1,84 @@
+import dataModelExtendsRule from './data-model-extends';
+
+describe('| data-model-extends', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(dataModelExtendsRule.meta?.type).toBe('suggestion');
+    expect(dataModelExtendsRule.meta?.messages?.missingExtends).toBeDefined();
+    expect(dataModelExtendsRule.meta?.messages?.parallelDateField).toBeDefined();
+  });
+
+  it('| should skip non-data-model files', () => {
+    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [] };
+    const result: any = dataModelExtendsRule.create(mockContext);
+    expect(result.ClassDeclaration).toBeUndefined();
+  });
+
+  it('| should report when data-model class has no `extends`', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'missingExtends') {
+          reportCalled = true;
+          expect(options.data.className).toBe('User_DataModel');
+        }
+      },
+      options: [],
+    };
+    const rule: any = dataModelExtendsRule.create(mockContext);
+    const mockNode: any = {
+      id: { name: 'User_DataModel' },
+      superClass: null,
+      body: { body: [] },
+    };
+    rule.ClassDeclaration(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report when extending DyFM_Metadata', () => {
+    let missingReported: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'missingExtends') {
+          missingReported = true;
+        }
+      },
+      options: [],
+    };
+    const rule: any = dataModelExtendsRule.create(mockContext);
+    const mockNode: any = {
+      id: { name: 'User_DataModel' },
+      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
+      body: { body: [] },
+    };
+    rule.ClassDeclaration(mockNode);
+    expect(missingReported).toBe(false);
+  });
+
+  it('| should report parallel date field `createdAt`', () => {
+    let parallelReported: boolean = false;
+    const mockContext: any = {
+      filename: '/x/user.data-model.ts',
+      report: (options: any): void => {
+        if (options.messageId === 'parallelDateField') {
+          parallelReported = true;
+          expect(options.data.fieldName).toBe('createdAt');
+        }
+      },
+      options: [],
+    };
+    const rule: any = dataModelExtendsRule.create(mockContext);
+    const mockNode: any = {
+      id: { name: 'User_DataModel' },
+      superClass: { type: 'Identifier', name: 'DyFM_Metadata' },
+      body: {
+        body: [
+          { type: 'PropertyDefinition', key: { type: 'Identifier', name: 'createdAt' } },
+        ],
+      },
+    };
+    rule.ClassDeclaration(mockNode);
+    expect(parallelReported).toBe(true);
+  });
+});

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

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

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

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

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

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

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

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

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

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