@dineroregnskab/eslint-plugin-custom-rules 4.3.0 → 4.4.0

package/README.md

@@ -63,7 +63,7 @@ module.exports = {
 ### Publish & install new rule locally
 
 1. Log in to npm using `npm login`
-2. run (in ./Packages/JavaScript/eslint-plugin-custom-rules/):
+2. run:
 
 ```bash
 # {version_type}: The type of version increment (patch, minor, major)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dineroregnskab/eslint-plugin-custom-rules",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "ESLint plugin with custom rules for Dinero Regnskab",
   "main": "eslint-plugin-custom-rules.js",
   "scripts": {
@@ -10,20 +10,23 @@
   "author": "",
   "license": "ISC",
   "devDependencies": {
+    "@angular-eslint/template-parser": "^19.2.1",
     "@typescript-eslint/parser": "^8.26.1",
     "eslint": "^9.22.0",
     "eslint-config-prettier": "^10.1.1",
     "eslint-plugin-prettier": "^5.2.3",
-    "prettier": "^3.5.3",
-    "@angular-eslint/template-parser": "^19.2.1"
+    "prettier": "^3.5.3"
   },
   "peerDependencies": {
-    "eslint": ">=8.0.0",
+    "@angular-eslint/template-parser": ">=17",
     "@typescript-eslint/parser": ">=7",
-    "@angular-eslint/template-parser": ">=17"
+    "eslint": ">=8.0.0"
   },
   "files": [
     "**/*",
     "!example/**/*"
-  ]
+  ],
+  "dependencies": {
+    "@dineroregnskab/eslint-plugin-custom-rules": "^4.0.1"
+  }
 }

package/rules/no-feature-toggle-without-await.js

@@ -3,127 +3,107 @@ module.exports = {
         type: 'suggestion',
         docs: {
             description:
-                'Warn when createUserWithOrganization uses featureToggles in beforeEach but awaitFeatureReady is not used in the it() block',
+                'Warn when an it() block is missing awaitFeatureReady while createUserWithOrganization uses featureToggles without awaiting',
             category: 'Best Practices',
             recommended: true,
         },
         messages: {
             missingAwaitFeatureReady:
-                'Feature toggles detected in beforeEach via createUserWithOrganization, but cy.awaitFeatureReady() not found in this it() block.',
+                'This it() block is missing cy.awaitFeatureReady() / cy.awaitFeaturesReady(), and createUserWithOrganization uses featureToggles without awaiting.',
         },
     },
 
     create(context) {
-        // Map each describe/context CallExpression node -> whether its beforeEach contains feature toggles
-        const describeFeatureMap = new WeakMap();
-
-        function findNearestDescribe(node) {
-            let current = node && node.parent;
-            while (current) {
-                if (
-                    current.type === 'CallExpression' &&
-                    current.callee &&
-                    (current.callee.name === 'describe' || current.callee.name === 'context')
-                ) {
-                    return current;
-                }
-                current = current.parent;
-            }
-            return null;
-        }
+        let hasFeatureToggles = false;
+        let beforeEachHasAwait = false;
 
         return {
             'CallExpression[callee.name="beforeEach"]'(node) {
-                const describeNode = findNearestDescribe(node);
-                if (!describeNode) return;
-
                 const callback = node.arguments[0];
                 if (!callback) return;
 
-                let hasFeatureToggles = false;
                 walkNode(callback, (child) => {
                     if (
                         child.type === 'CallExpression' &&
-                        child.callee &&
-                        child.callee.name === 'createUserWithOrganization'
+                        child.callee?.name === 'createUserWithOrganization' &&
+                        hasFeatureTogglesArg(child)
                     ) {
-                        const arg = child.arguments[0];
-                        if (arg && arg.type === 'ObjectExpression') {
-                            arg.properties.forEach((prop) => {
-                                if (
-                                    prop.type === 'Property' &&
-                                    prop.key &&
-                                    (prop.key.name || prop.key.value)
-                                ) {
-                                    const keyName = prop.key.name || prop.key.value;
-
-                                    if (
-                                        keyName === 'featureToggles' &&
-                                        prop.value.type === 'ArrayExpression' &&
-                                        prop.value.elements.length > 0
-                                    ) {
-                                        hasFeatureToggles = true;
-                                    }
-                                }
-                            });
+                        hasFeatureToggles = true;
+
+                        const chainRoot = findChainRoot(child);
+                        if (hasAwaitFeatureReady(chainRoot)) {
+                            beforeEachHasAwait = true;
                         }
                     }
                 });
-
-                if (hasFeatureToggles) {
-                    describeFeatureMap.set(describeNode, true);
-                }
             },
 
             'CallExpression[callee.name="it"]'(node) {
-                // Walk ancestors to see if any describe/context has feature toggles
-                let current = node.parent;
-                let hasFeatureTogglesInAnyAncestor = false;
-                while (current) {
-                    if (
-                        current.type === 'CallExpression' &&
-                        current.callee &&
-                        (current.callee.name === 'describe' || current.callee.name === 'context')
-                    ) {
-                        if (describeFeatureMap.get(current)) {
-                            hasFeatureTogglesInAnyAncestor = true;
-                            break;
-                        }
-                    }
-                    current = current.parent;
-                }
-                if (!hasFeatureTogglesInAnyAncestor) return;
+                if (!hasFeatureToggles) return;
+                if (beforeEachHasAwait) return;
 
-                const callback = node.arguments[1] || node.arguments[0];
+                const callback = node.arguments[1];
                 if (!callback) return;
 
-                let hasAwaitFeatureReady = false;
-                walkNode(callback, (child) => {
-                    if (
-                        child.type === 'CallExpression' &&
-                        child.callee &&
-                        child.callee.type === 'MemberExpression' &&
-                        child.callee.object &&
-                        child.callee.object.name === 'cy' &&
-                        child.callee.property &&
-                        (child.callee.property.name === 'awaitFeatureReady' ||
-                            child.callee.property.name === 'awaitFeaturesReady')
-                    ) {
-                        hasAwaitFeatureReady = true;
-                    }
-                });
+                const itHasAwait = hasAwaitFeatureReady(callback);
+                if (itHasAwait) return;
 
-                if (!hasAwaitFeatureReady) {
-                    context.report({
-                        node: node,
-                        messageId: 'missingAwaitFeatureReady',
-                    });
-                }
+                context.report({
+                    node,
+                    messageId: 'missingAwaitFeatureReady',
+                });
             },
         };
     },
 };
 
+/* ================= HELPERS ================= */
+
+function hasFeatureTogglesArg(callExpression) {
+    const arg = callExpression.arguments[0];
+    if (!arg || arg.type !== 'ObjectExpression') return false;
+
+    return arg.properties.some((prop) => {
+        const key = prop.key?.name || prop.key?.value;
+        return (
+            key === 'featureToggles' &&
+            prop.value.type === 'ArrayExpression' &&
+            prop.value.elements.length > 0
+        );
+    });
+}
+
+function hasAwaitFeatureReady(node) {
+    let found = false;
+
+    walkNode(node, (n) => {
+        if (
+            n.type === 'CallExpression' &&
+            n.callee?.type === 'MemberExpression' &&
+            n.callee.object?.name === 'cy' &&
+            (n.callee.property?.name === 'awaitFeatureReady' ||
+                n.callee.property?.name === 'awaitFeaturesReady')
+        ) {
+            found = true;
+        }
+    });
+
+    return found;
+}
+
+function findChainRoot(node) {
+    let current = node;
+
+    while (
+        current.parent?.type === 'MemberExpression' &&
+        current.parent.parent?.type === 'CallExpression'
+    ) {
+        current = current.parent.parent;
+    }
+
+    return current;
+}
+
 function walkNode(node, callback) {
     if (!node) return;
 
@@ -133,14 +113,9 @@ function walkNode(node, callback) {
         if (key === 'parent' || key === 'loc' || key === 'range') continue;
 
         const child = node[key];
-
         if (Array.isArray(child)) {
-            child.forEach((item) => {
-                if (item && typeof item === 'object' && item.type) {
-                    walkNode(item, callback);
-                }
-            });
-        } else if (child && typeof child === 'object' && child.type) {
+            child.forEach((c) => c?.type && walkNode(c, callback));
+        } else if (child?.type) {
             walkNode(child, callback);
         }
     }