@futdevpro/dynamo-eslint 1.15.7 → 1.15.8

package/pipeline.cicd.config.json

@@ -0,0 +1,152 @@
+{
+  "name": "Dynamo-ESLint CI/CD Pipeline",
+  "outputDir": "./logs/cicd-pipeline",
+  "timing": {
+    "stepTimeout": "10m",
+    "teeMaxRuntime": "10m",
+    "stepCooldown": "1s"
+  },
+  "log": {
+    "runtimeMaxBytes": 5242880,
+    "trimCheckEveryN": 1000
+  },
+  "versionBump": {
+    "enabled": false
+  },
+  "report": {
+    "fileName": "cicd-report.json",
+    "includeLogTail": true,
+    "logTailLines": 10000,
+    "includeStepLogs": false
+  },
+  "steps": [
+    {
+      "label": "discord-start",
+      "command": "dc ci-dn-s '{\"appName\":\"Dynamo-ESLint\",\"appEmoji\":\"🔧\",\"commitMessage\":\"$COMMIT_MESSAGE\",\"branchName\":\"$GITHUB_REF_NAME\",\"author\":\"$GITHUB_ACTOR\",\"runNumber\":\"$GITHUB_RUN_NUMBER\",\"runId\":\"$GITHUB_RUN_ID\",\"repository\":\"$GITHUB_REPOSITORY\",\"eventName\":\"$GITHUB_EVENT_NAME\",\"eventDateTime\":\"$EVENT_DATETIME\"}'",
+      "fatal": false,
+      "discord": {
+        "hide": true
+      },
+      "condition": {
+        "envSet": [
+          "DISCORD_WEBHOOK_ID"
+        ]
+      }
+    },
+    {
+      "label": "pre-flight",
+      "type": "pre-flight-check",
+      "fatal": true,
+      "discord": {
+        "emoji": "🔐",
+        "name": "Pre-flight Check"
+      },
+      "settings": {
+        "requiredEnvVars": [
+          "NPM_TOKEN"
+        ]
+      }
+    },
+    {
+      "label": "install",
+      "command": "pnpm i",
+      "fatal": true,
+      "discord": {
+        "hide": true
+      }
+    },
+    {
+      "label": "check-dev-leftovers",
+      "type": "check-dev-leftovers",
+      "fatal": false,
+      "discord": {
+        "emoji": "🔍",
+        "name": "Dev Leftovers Check"
+      },
+      "settings": {
+        "checks": [
+          {
+            "type": "TSCONFIG_PATHS",
+            "directory": "."
+          },
+          {
+            "type": "PACKAGE_VERSIONS",
+            "directory": ".",
+            "packages": [
+              "@futdevpro/fsm-dynamo"
+            ]
+          }
+        ]
+      }
+    },
+    {
+      "label": "build",
+      "command": "npx tsc",
+      "fatal": true,
+      "discord": {
+        "emoji": "🏗️",
+        "name": "Build"
+      }
+    },
+    {
+      "label": "test",
+      "command": "npx jasmine",
+      "fatal": true,
+      "discord": {
+        "emoji": "🧪",
+        "name": "Tests"
+      }
+    },
+    {
+      "label": "npm-publish",
+      "type": "npm-publish",
+      "fatal": false,
+      "discord": {
+        "emoji": "📦",
+        "name": "NPM Publish"
+      },
+      "condition": {
+        "branchMatch": [
+          "master"
+        ]
+      },
+      "settings": {
+        "directory": ".",
+        "skipIfPublished": true,
+        "retryAttempts": 3,
+        "retryDelaySeconds": 30
+      }
+    },
+    {
+      "label": "pipeline-report",
+      "command": "fdp pipeline-report --report ./logs/cicd-pipeline/cicd-report.json --overseer-url $OVERSEER_URL --overseer-secret $OVERSEER_SECRET_KEY --branch $GITHUB_REF_NAME",
+      "fatal": false,
+      "always": true,
+      "discord": {
+        "emoji": "📊",
+        "name": "Build Report"
+      },
+      "condition": {
+        "envSet": [
+          "OVERSEER_URL"
+        ]
+      }
+    },
+    {
+      "label": "discord-result",
+      "command": "fdp pipeline-notify --report ./logs/cicd-pipeline/cicd-report.json --config ./pipeline.cicd.config.json --app-name Dynamo-ESLint --app-emoji 🔧 --webhook-id $DISCORD_WEBHOOK_ID --webhook-token $DISCORD_WEBHOOK_TOKEN --overseer-url $OVERSEER_DASHBOARD_URL",
+      "fatal": false,
+      "retryOnFail": 2,
+      "retryDelaySec": 5,
+      "always": true,
+      "discord": {
+        "hide": true
+      },
+      "condition": {
+        "envSet": [
+          "DISCORD_WEBHOOK_ID"
+        ]
+      }
+    }
+  ]
+}

package/src/configs/base.ts

@@ -88,9 +88,14 @@ module.exports = [
       'keyword-spacing': 'warn',
       'no-else-return': 'warn',
       'no-duplicate-imports': 'warn',
-      'max-params': [ 'warn', 4 ],
+      // CCAP method-input-count: 3+ paraméter helyett egyetlen object input kötelező
+      'max-params': [ 'warn', 3 ],
       'max-params-no-constructor/max-params-no-constructor': [ 'warn', 5 ],
       'quotes': [ 'warn', 'single', { allowTemplateLiterals: true }],
+      // CCAP no-object-shorthand: tilos a `{ foo }` shorthand, mindig `{ foo: foo }`
+      'object-shorthand': [ 'warn', 'never' ],
+      // CCAP no-bracket-property-access: dot-notation előnyben (ahol lehetséges)
+      'dot-notation': 'warn',
       
       // TypeScript rules
       '@typescript-eslint/no-unused-vars': 'warn',
@@ -103,6 +108,12 @@ module.exports = [
         },
       ],
       '@typescript-eslint/no-unnecessary-type-assertion': 'warn',
+      // CCAP no-array-generic: `Array<T>` helyett `T[]`
+      '@typescript-eslint/array-type': [ 'warn', { default: 'array' }],
+      // CCAP prefer-optional-chaining: `a && a.b` helyett `a?.b`
+      '@typescript-eslint/prefer-optional-chain': 'warn',
+      // CCAP no-dynamic-imports (CommonJS variant): `require()` helyett ES import
+      '@typescript-eslint/no-require-imports': 'warn',
       
       // Dynamo custom rules
       '@futdevpro/dynamo/explicit-types': 'warn',
@@ -115,6 +126,15 @@ module.exports = [
       '@futdevpro/dynamo/prefer-enum-over-string-union': [ 'warn', { minValues: 3 }],
       '@futdevpro/dynamo/require-test-description-prefix': [ 'warn', { prefix: '| ' }],
       '@futdevpro/dynamo/no-getter-logic': 'warn',
+
+      // CCAP-portolt TypeScript review-k (AST-alapú).
+      '@futdevpro/dynamo/no-as-cast': 'warn',
+      '@futdevpro/dynamo/no-any-type': 'warn',
+      '@futdevpro/dynamo/no-dynamic-imports': 'warn',
+      '@futdevpro/dynamo/one-export-per-file': 'warn',
+      '@futdevpro/dynamo/no-plain-function-export': 'warn',
+      '@futdevpro/dynamo/data-model-extends': 'warn',
+      '@futdevpro/dynamo/no-native-browser-dialogs': 'warn',
     },
   },
 ];

package/src/configs/ngx.ts

@@ -45,6 +45,11 @@ module.exports = [
       '@angular-eslint/no-outputs-metadata-property': 'error',
       '@angular-eslint/use-lifecycle-interface': 'error',
       '@angular-eslint/use-pipe-transform-interface': 'error',
+
+      // CCAP-portolt Angular TypeScript review-k.
+      '@futdevpro/dynamo/no-async-ngoninit': 'warn',
+      '@futdevpro/dynamo/no-component-direct-api': 'warn',
+      '@futdevpro/dynamo/effect-signal-loop': 'warn',
     },
   },
   {
@@ -57,6 +62,7 @@ module.exports = [
       },
     },
     plugins: {
+      ...ngxBaseConfig[1].plugins,
       '@angular-eslint/template': angularTemplatePlugin,
     },
     rules: {
@@ -67,6 +73,12 @@ module.exports = [
       '@angular-eslint/template/no-duplicate-attributes': 'error',
       '@angular-eslint/template/no-negated-async': 'error',
       '@angular-eslint/template/use-track-by-function': 'error',
+
+      // CCAP-portolt Angular template review-k (regex-alapú text scan).
+      '@futdevpro/dynamo/no-method-call-in-template': 'warn',
+      '@futdevpro/dynamo/angular-for-track-logic': 'warn',
+      '@futdevpro/dynamo/no-ngif-directive': 'warn',
+      '@futdevpro/dynamo/no-ngfor-directive': 'warn',
     },
   },
 ];

package/src/plugin/index.ts

@@ -9,6 +9,22 @@ import preferEnumRule from './rules/prefer-enum-over-string-union';
 import requireTestPrefixRule from './rules/require-test-description-prefix';
 import noGetterLogicRule from './rules/no-getter-logic';
 
+import noAsCastRule from './rules/ts/no-as-cast';
+import noAnyTypeRule from './rules/ts/no-any-type';
+import noDynamicImportsRule from './rules/ts/no-dynamic-imports';
+import oneExportPerFileRule from './rules/ts/one-export-per-file';
+import noPlainFunctionExportRule from './rules/ts/no-plain-function-export';
+import dataModelExtendsRule from './rules/ts/data-model-extends';
+import noNativeBrowserDialogsRule from './rules/ts/no-native-browser-dialogs';
+
+import noAsyncNgOnInitRule from './rules/angular/no-async-ngoninit';
+import noComponentDirectApiRule from './rules/angular/no-component-direct-api';
+import effectSignalLoopRule from './rules/angular/effect-signal-loop';
+import noMethodCallInTemplateRule from './rules/angular/no-method-call-in-template';
+import angularForTrackLogicRule from './rules/angular/angular-for-track-logic';
+import noNgIfDirectiveRule from './rules/angular/no-ngif-directive';
+import noNgForDirectiveRule from './rules/angular/no-ngfor-directive';
+
 export = {
   rules: {
     'explicit-types': explicitTypesRule,
@@ -22,6 +38,24 @@ export = {
     'no-getter-logic': noGetterLogicRule,
 
     'naming-patterns': namingPatternsRule,
+
+    // CCAP-portolt TypeScript review-k (AST-alapú).
+    'no-as-cast': noAsCastRule,
+    'no-any-type': noAnyTypeRule,
+    'no-dynamic-imports': noDynamicImportsRule,
+    'one-export-per-file': oneExportPerFileRule,
+    'no-plain-function-export': noPlainFunctionExportRule,
+    'data-model-extends': dataModelExtendsRule,
+    'no-native-browser-dialogs': noNativeBrowserDialogsRule,
+
+    // CCAP-portolt Angular review-k (TS + template-szöveg AST-alapú).
+    'no-async-ngoninit': noAsyncNgOnInitRule,
+    'no-component-direct-api': noComponentDirectApiRule,
+    'effect-signal-loop': effectSignalLoopRule,
+    'no-method-call-in-template': noMethodCallInTemplateRule,
+    'angular-for-track-logic': angularForTrackLogicRule,
+    'no-ngif-directive': noNgIfDirectiveRule,
+    'no-ngfor-directive': noNgForDirectiveRule,
   },
   configs: {
     recommended: {
@@ -35,11 +69,18 @@ export = {
         '@futdevpro/dynamo/prefer-enum-over-string-union': 'warn',
         '@futdevpro/dynamo/require-test-description-prefix': 'warn',
         '@futdevpro/dynamo/no-getter-logic': 'warn',
-        
+
         '@futdevpro/dynamo/naming-patterns': 'warn',
+
+        // CCAP-portolt TypeScript review-k (AST-alapú).
+        '@futdevpro/dynamo/no-as-cast': 'warn',
+        '@futdevpro/dynamo/no-any-type': 'warn',
+        '@futdevpro/dynamo/no-dynamic-imports': 'warn',
+        '@futdevpro/dynamo/one-export-per-file': 'warn',
+        '@futdevpro/dynamo/no-plain-function-export': 'warn',
+        '@futdevpro/dynamo/data-model-extends': 'warn',
+        '@futdevpro/dynamo/no-native-browser-dialogs': 'warn',
       },
     },
   },
 };
-
-

package/src/plugin/rules/angular/angular-for-track-logic.spec.ts

@@ -0,0 +1,44 @@
+import angularForTrackLogicRule from './angular-for-track-logic';
+
+describe('| angular-for-track-logic', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(angularForTrackLogicRule.meta?.type).toBe('problem');
+    expect(angularForTrackLogicRule.meta?.messages?.trackLogic).toBeDefined();
+  });
+
+  it('| should skip non-html files', () => {
+    const mockContext: any = { filename: '/x/foo.ts', report: () => {}, options: [], sourceCode: { text: '' } };
+    const result: any = angularForTrackLogicRule.create(mockContext);
+    expect(result.Program).toBeUndefined();
+  });
+
+  it('| should NOT report `track item.id` (simple property access)', () => {
+    let reportCount: number = 0;
+    const mockContext: any = {
+      filename: '/x/list.component.html',
+      report: (): void => { reportCount += 1; },
+      options: [],
+      sourceCode: { text: '@for (item of items; track item.id) { <div>X</div> }' },
+    };
+    const rule: any = angularForTrackLogicRule.create(mockContext);
+    rule.Program();
+    expect(reportCount).toBe(0);
+  });
+
+  it('| should report `track method(item)` (logic in track)', () => {
+    let reportCount: number = 0;
+    const mockContext: any = {
+      filename: '/x/list.component.html',
+      report: (options: any): void => {
+        if (options.messageId === 'trackLogic') {
+          reportCount += 1;
+        }
+      },
+      options: [],
+      sourceCode: { text: '@for (item of items; track trackFn(item)) { <div>X</div> }' },
+    };
+    const rule: any = angularForTrackLogicRule.create(mockContext);
+    rule.Program();
+    expect(reportCount).toBeGreaterThan(0);
+  });
+});

package/src/plugin/rules/angular/angular-for-track-logic.ts

@@ -0,0 +1,88 @@
+import { Rule } from 'eslint';
+
+/**
+ * `@for (...; track <expr>)` kifejezés keresése — capture group 1: a track expression.
+ */
+const FOR_TRACK_REGEX: RegExp = /@for\s*\([^)]*;\s*track\s+([^;)]+)/g;
+
+/**
+ * Logika detektáló minták a track kifejezésben.
+ * Tiltott: `??`, `||`, `&&`, `()`, `+-*\/`, ternary `?`.
+ * Megengedett: egyszerű property access (`item.id`).
+ */
+const TRACK_LOGIC_PATTERNS: RegExp[] = [
+  /\?\?/,
+  /\|\|/,
+  /&&/,
+  /\(/,
+  /\)/,
+  /[+\-*/%]/,
+  /\?\s*[^:]/,
+];
+
+/**
+ * Adott offset alapján a sor és oszlop kiszámítása az alap szövegből.
+ */
+function computeLoc(text: string, index: number): { line: number; column: number } {
+  const before: string = text.substring(0, index);
+  const newlineMatches: RegExpMatchArray | null = before.match(/\n/g);
+  const line: number = (newlineMatches ? newlineMatches.length : 0) + 1;
+  const lastNewline: number = before.lastIndexOf('\n');
+  const column: number = lastNewline === -1 ? index : index - lastNewline - 1;
+  return { line: line, column: column };
+}
+
+/**
+ * Angular-for-track-logic szabály: tilos logika `@for (...; track <expr>)` kifejezésben.
+ * CCAP "angular-for-track-logic" review ESLint template-text-scan portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description:
+        'Forbid logic in Angular `@for (...; track <expr>)`; '
+        + 'only direct property access (`item.id`) allowed.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      trackLogic: 'Logika a `@for track` kifejezésben: `track {{expr}}`.',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    const filename: string = context.filename ?? '';
+    if (!filename.endsWith('.html')) {
+      return {};
+    }
+    const text: string = context.sourceCode.text ?? '';
+
+    return {
+      Program(): void {
+        try {
+          const localRegex: RegExp = new RegExp(FOR_TRACK_REGEX.source, 'g');
+          let match: RegExpExecArray | null = localRegex.exec(text);
+          while (match !== null) {
+            const expr: string = match[1].trim();
+            const hasLogic: boolean = TRACK_LOGIC_PATTERNS.some(
+              (p: RegExp): boolean => p.test(expr),
+            );
+            if (hasLogic) {
+              const loc: { line: number; column: number } = computeLoc(text, match.index);
+              context.report({
+                loc: { start: loc, end: { line: loc.line, column: loc.column + match[0].length } },
+                messageId: 'trackLogic',
+                data: { expr: expr },
+              });
+            }
+            match = localRegex.exec(text);
+          }
+        } catch (error) {
+          console.error('[angular-for-track-logic] Error in Program visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;

package/src/plugin/rules/angular/effect-signal-loop.spec.ts

@@ -0,0 +1,89 @@
+import effectSignalLoopRule from './effect-signal-loop';
+
+describe('| effect-signal-loop', () => {
+  it('| should be a valid ESLint rule', () => {
+    expect(effectSignalLoopRule.meta?.type).toBe('problem');
+    expect(effectSignalLoopRule.meta?.messages?.effectSignalLoop).toBeDefined();
+  });
+
+  it('| should report when same signal is read AND written in effect', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = {
+      report: (options: any): void => {
+        reportCalled = true;
+        expect(options.messageId).toBe('effectSignalLoop');
+        expect(options.data.signalName).toBe('count_$');
+      },
+      options: [],
+    };
+    const rule: any = effectSignalLoopRule.create(mockContext);
+    const mockNode: any = {
+      callee: { type: 'Identifier', name: 'effect' },
+      arguments: [
+        {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'BlockStatement',
+            body: [
+              {
+                type: 'ExpressionStatement',
+                expression: {
+                  type: 'CallExpression',
+                  callee: { type: 'Identifier', name: 'count_$' },
+                  arguments: [],
+                },
+              },
+              {
+                type: 'ExpressionStatement',
+                expression: {
+                  type: 'CallExpression',
+                  callee: {
+                    type: 'MemberExpression',
+                    object: { type: 'Identifier', name: 'count_$' },
+                    property: { type: 'Identifier', name: 'set' },
+                  },
+                  arguments: [{ type: 'Literal', value: 1 }],
+                },
+              },
+            ],
+          },
+        },
+      ],
+    };
+    rule.CallExpression(mockNode);
+    expect(reportCalled).toBe(true);
+  });
+
+  it('| should not report when only reading a signal', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
+    const rule: any = effectSignalLoopRule.create(mockContext);
+    const mockNode: any = {
+      callee: { type: 'Identifier', name: 'effect' },
+      arguments: [
+        {
+          type: 'ArrowFunctionExpression',
+          body: {
+            type: 'CallExpression',
+            callee: { type: 'Identifier', name: 'count_$' },
+            arguments: [],
+          },
+        },
+      ],
+    };
+    rule.CallExpression(mockNode);
+    expect(reportCalled).toBe(false);
+  });
+
+  it('| should ignore non-effect calls', () => {
+    let reportCalled: boolean = false;
+    const mockContext: any = { report: () => { reportCalled = true; }, options: [] };
+    const rule: any = effectSignalLoopRule.create(mockContext);
+    const mockNode: any = {
+      callee: { type: 'Identifier', name: 'computed' },
+      arguments: [],
+    };
+    rule.CallExpression(mockNode);
+    expect(reportCalled).toBe(false);
+  });
+});

package/src/plugin/rules/angular/effect-signal-loop.ts

@@ -0,0 +1,125 @@
+import { Rule } from 'eslint';
+
+/**
+ * Adott AST node alá tartozó signal olvasások / írások begyűjtése.
+ * Olvasás: `something_$()` hívás (callee Identifier `*_$` névvel vagy
+ *   MemberExpression `.foo_$()` property-vel).
+ * Írás: `something_$.set(...)` vagy `something_$.update(...)`.
+ */
+function collectSignals(
+  rootNode: any,
+  reads: Set<string>,
+  writes: Set<string>,
+): void {
+  if (!rootNode || typeof rootNode !== 'object') {
+    return;
+  }
+
+  if (rootNode.type === 'CallExpression') {
+    const callee: any = rootNode.callee;
+    // Signal olvasás: `name_$()` direkt hívás (Identifier callee)
+    if (callee && callee.type === 'Identifier' && /_\$$/.test(callee.name)) {
+      reads.add(callee.name);
+    }
+    // Signal olvasás: `this.name_$()` vagy `obj.name_$()`
+    if (
+      callee
+      && callee.type === 'MemberExpression'
+      && callee.property
+      && callee.property.type === 'Identifier'
+      && /_\$$/.test(callee.property.name)
+    ) {
+      reads.add(callee.property.name);
+    }
+    // Signal írás: `name_$.set(...)` / `name_$.update(...)`
+    if (
+      callee
+      && callee.type === 'MemberExpression'
+      && callee.property
+      && callee.property.type === 'Identifier'
+      && (callee.property.name === 'set' || callee.property.name === 'update')
+    ) {
+      const obj: any = callee.object;
+      if (obj && obj.type === 'Identifier' && /_\$$/.test(obj.name)) {
+        writes.add(obj.name);
+      }
+      if (
+        obj
+        && obj.type === 'MemberExpression'
+        && obj.property
+        && obj.property.type === 'Identifier'
+        && /_\$$/.test(obj.property.name)
+      ) {
+        writes.add(obj.property.name);
+      }
+    }
+  }
+
+  for (const key in rootNode) {
+    if (key === 'parent' || key === 'loc' || key === 'range') {
+      continue;
+    }
+    const value: any = rootNode[key];
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        collectSignals(item, reads, writes);
+      }
+    } else if (value && typeof value === 'object' && typeof value.type === 'string') {
+      collectSignals(value, reads, writes);
+    }
+  }
+}
+
+/**
+ * Effect-signal-loop szabály: detektálja azt az `effect(...)` hívást ami
+ * ugyanazt a signal-t olvassa (dependency-ként) és írja (`.set` / `.update`).
+ * Ez végtelen loop-ot okozna, mert a write újra triggereli az effect-et.
+ * CCAP "effect-signal-loop" review ESLint AST-portja.
+ */
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Detect `effect()` callbacks that read and write the same signal — infinite loop risk.',
+      recommended: true,
+    },
+    schema: [],
+    messages: {
+      effectSignalLoop:
+        'Effect-signal loop: `{{signalName}}` olvasva ÉS írva (.set/.update) ugyanabban az `effect()`-ben. '
+        + 'Végtelen újrafutás veszélye — a signal-írás újra triggereli az effect-et.',
+    },
+  },
+  create(context: Rule.RuleContext): Rule.RuleListener {
+    return {
+      CallExpression(node: any): void {
+        try {
+          const callee: any = node.callee;
+          if (!callee || callee.type !== 'Identifier' || callee.name !== 'effect') {
+            return;
+          }
+          const firstArg: any = node.arguments && node.arguments[0];
+          if (!firstArg) {
+            return;
+          }
+          const reads: Set<string> = new Set<string>();
+          const writes: Set<string> = new Set<string>();
+          collectSignals(firstArg, reads, writes);
+          for (const signalName of writes) {
+            if (reads.has(signalName)) {
+              context.report({
+                node: node,
+                messageId: 'effectSignalLoop',
+                data: { signalName: signalName },
+              });
+            }
+          }
+        } catch (error) {
+          console.error('[effect-signal-loop] Error in CallExpression visitor:', error);
+        }
+      },
+    };
+  },
+};
+
+export default rule;