@futdevpro/dynamo-eslint 1.15.22 → 1.15.28

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

@@ -1,100 +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;
+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 +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);
-  });
-});
+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 +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;
+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 +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);
-  });
-});
+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 +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;
+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 +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);
-  });
-});
+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);
+  });
+});