@futdevpro/dynamo-eslint 1.15.7 → 1.15.8

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

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

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

package/src/plugin/rules/ts/one-export-per-file.spec.ts

@@ -0,0 +1,64 @@
+import oneExportPerFileRule from './one-export-per-file';
+
+describe('| one-export-per-file', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(oneExportPerFileRule.meta?.type).toBe('suggestion');
+    expect(oneExportPerFileRule.meta?.messages?.tooManyExports).toBeDefined();
+  });
+
+  it('| should skip .const.ts (exception pattern)', () => {
+    const mockContext: any = { filename: '/x/foo.const.ts', report: () => {}, options: [] };
+    const result: any = oneExportPerFileRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should skip .data-model.ts (DataModel + DataParams allowed)', () => {
+    const mockContext: any = { filename: '/x/user.data-model.ts', report: () => {}, options: [] };
+    const result: any = oneExportPerFileRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should skip .spec.ts files', () => {
+    const mockContext: any = { filename: '/x/foo.spec.ts', report: () => {}, options: [] };
+    const result: any = oneExportPerFileRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should not report when file has 1 export', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: () => { reportCalled = true; },
+      options: [],
+    };
+    const rule: any = oneExportPerFileRule.create(mockContext);
+    const mockProgram: any = {
+      body: [
+        { type: 'ExportNamedDeclaration', declaration: { type: 'FunctionDeclaration' } },
+      ],
+    };
+    rule.Program(mockProgram);
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should report when file has 2+ exports', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      filename: '/x/foo.ts',
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.messageId).toBe('tooManyExports');
+      },
+      options: [],
+    };
+    const rule: any = oneExportPerFileRule.create(mockContext);
+    const mockProgram: any = {
+      body: [
+        { type: 'ExportNamedDeclaration', declaration: { type: 'ClassDeclaration' } },
+        { type: 'ExportNamedDeclaration', declaration: { type: 'FunctionDeclaration' } },
+      ],
+    };
+    rule.Program(mockProgram);
+    expect(reportCalled).toBe(true);
+  });
+});

package/src/plugin/rules/ts/one-export-per-file.ts

@@ -0,0 +1,77 @@
+import { Rule } from 'eslint';
+
+/**
+ * Kivétel fájl-minták – ezekben megengedett több export.
+ * CCAP konvenció: `*.const.ts`, `*.type-enum.ts`, `*.interface.ts`, DataModel + DataParams.
+ */
+const MULTI_EXPORT_EXCEPTION_PATTERNS: RegExp[] = [
+  /\.const\.ts$/,
+  /\.type-enum\.ts$/,
+  /\.interface\.ts$/,
+  /\.data-model\.ts$/,
+  /\.control-model\.ts$/,
+];
+
+/**
+ * One-export-per-file szabály: nem-kivétel fájlokban max 1 exportált
+ * class/interface/enum/type/function deklaráció lehet.
+ * CCAP "one-export-per-file" review ESLint AST-portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Limit to one exported class/interface/enum/type/function per file (with named exceptions).',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      tooManyExports:
+        '{{count}} export deklaráció a fájlban (max 1). Vegyél ki minden további exportot külön fájlba.',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    const filename: string = context.filename ?? '';
+    if (MULTI_EXPORT_EXCEPTION_PATTERNS.some((p: RegExp): boolean => p.test(filename))) {
+      return {};
+    }
+    if (filename.endsWith('.spec.ts') || filename.endsWith('.test.ts') || filename.endsWith('.d.ts')) {
+      return {};
+    }
+
+    return {
+      Program(node: any): void {
+        try {
+          const exportNodes: any[] = [];
+          for (const statement of node.body) {
+            if (statement.type === 'ExportNamedDeclaration' && statement.declaration) {
+              const decl: any = statement.declaration;
+              if (
+                decl.type === 'ClassDeclaration'
+                || decl.type === 'TSInterfaceDeclaration'
+                || decl.type === 'TSEnumDeclaration'
+                || decl.type === 'TSTypeAliasDeclaration'
+                || decl.type === 'FunctionDeclaration'
+              ) {
+                exportNodes.push(statement);
+              }
+            } else if (statement.type === 'ExportDefaultDeclaration') {
+              exportNodes.push(statement);
+            }
+          }
+          if (exportNodes.length > 1) {
+            context.report({
+              node: exportNodes[1],
+              messageId: 'tooManyExports',
+              data: { count: String(exportNodes.length) },
+            });
+          }
+        } catch (error) {
+          console.error('[one-export-per-file] Error in Program visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;