@blumintinc/eslint-plugin-blumint 1.14.0 → 1.15.0

package/lib/rules/no-passthrough-getters.js

@@ -1,9 +1,33 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noPassthroughGetters = void 0;
 const createRule_1 = require("../utils/createRule");
 const utils_1 = require("@typescript-eslint/utils");
 const getMethodName_1 = require("../utils/getMethodName");
+const ts = __importStar(require("typescript"));
 const COMPLEX_EXPRESSION_TYPES = new Set([
     utils_1.AST_NODE_TYPES.CallExpression,
     utils_1.AST_NODE_TYPES.TemplateLiteral,
@@ -14,7 +38,7 @@ const COMPLEX_EXPRESSION_TYPES = new Set([
 ]);
 exports.noPassthroughGetters = (0, createRule_1.createRule)({
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         return {
             // Target getter methods in classes
             MethodDefinition(node) {
@@ -26,6 +50,10 @@ exports.noPassthroughGetters = (0, createRule_1.createRule)({
                 if (node.decorators && node.decorators.length > 0) {
                     return;
                 }
+                // Check if this getter satisfies an interface or overrides a base class member
+                if (isRequiredByInterfaceOrBaseClass(node, sourceCode)) {
+                    return;
+                }
                 const methodBody = node.value.body;
                 if (!methodBody) {
                     return;
@@ -74,6 +102,60 @@ exports.noPassthroughGetters = (0, createRule_1.createRule)({
                 }
             },
         };
+        /**
+         * Check if the getter is required by an implemented interface or overrides a base class member
+         */
+        function isRequiredByInterfaceOrBaseClass(node, sourceCode) {
+            const parserServices = sourceCode.parserServices;
+            if (!parserServices ||
+                !parserServices.program ||
+                !parserServices.esTreeNodeToTSNodeMap) {
+                return false;
+            }
+            const checker = parserServices.program.getTypeChecker();
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            if (!tsNode) {
+                return false;
+            }
+            const symbol = checker.getSymbolAtLocation(tsNode.name);
+            if (!symbol ||
+                !tsNode.parent ||
+                !(ts.isClassDeclaration(tsNode.parent) ||
+                    ts.isClassExpression(tsNode.parent))) {
+                return false;
+            }
+            const classNode = tsNode.parent;
+            const classType = checker.getTypeAtLocation(classNode);
+            const classSymbol = classType.getSymbol();
+            if (!classSymbol) {
+                return false;
+            }
+            const instanceType = checker.getDeclaredTypeOfSymbol(classSymbol);
+            const name = symbol.getName();
+            // Check base classes
+            const baseTypes = instanceType.getBaseTypes() || [];
+            for (const baseType of baseTypes) {
+                if (baseType.getProperty(name)) {
+                    return true;
+                }
+            }
+            // Check interfaces
+            if (classNode.heritageClauses) {
+                for (const clause of classNode.heritageClauses) {
+                    // Only check implemented interfaces as base classes are already checked via getBaseTypes()
+                    if (clause.token !== ts.SyntaxKind.ImplementsKeyword) {
+                        continue;
+                    }
+                    for (const typeNode of clause.types) {
+                        const type = checker.getTypeAtLocation(typeNode);
+                        if (type.getProperty(name)) {
+                            return true;
+                        }
+                    }
+                }
+            }
+            return false;
+        }
         /**
          * Check if the node is a simple property access from a constructor parameter
          * like this.settings.property or this.settings['property'] or this.settings.nested.deep.property

package/lib/rules/no-redundant-this-params.js

@@ -21,6 +21,7 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
     defaultOptions: [],
     create(context) {
         const classInfoMap = new WeakMap();
+        const classStatsMap = new WeakMap();
         function isFunctionLike(node) {
             return (node?.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
                 node?.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
@@ -412,6 +413,24 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
         return {
             'ClassDeclaration, ClassExpression'(node) {
                 collectClassInfo(node);
+                classStatsMap.set(node, { methods: new Map() });
+            },
+            'ClassDeclaration, ClassExpression:exit'(node) {
+                const stats = classStatsMap.get(node);
+                if (!stats) {
+                    return;
+                }
+                for (const [methodName, methodStats] of stats.methods) {
+                    for (const [argIndex, argProperties] of methodStats.argStats) {
+                        for (const [, propStats] of argProperties) {
+                            if (propStats.callsWithProperty === methodStats.totalCalls) {
+                                for (const violation of propStats.violations) {
+                                    reportAccess(methodName, violation.methodMeta, argIndex, violation.access);
+                                }
+                            }
+                        }
+                    }
+                }
             },
             CallExpression(node) {
                 const methodName = getMethodNameFromCallee(node.callee);
@@ -442,6 +461,18 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
                         return;
                     }
                 }
+                const stats = classStatsMap.get(classNode);
+                if (!stats) {
+                    return;
+                }
+                let methodStats = stats.methods.get(methodName);
+                if (!methodStats) {
+                    methodStats = { totalCalls: 0, argStats: new Map() };
+                    stats.methods.set(methodName, methodStats);
+                }
+                const currentMethodStats = methodStats;
+                currentMethodStats.totalCalls++;
+                const seenInThisCall = new Set();
                 node.arguments.forEach((arg, index) => {
                     if (!arg) {
                         return;
@@ -449,7 +480,25 @@ exports.noRedundantThisParams = (0, createRule_1.createRule)({
                     const targetNode = arg.type === utils_1.AST_NODE_TYPES.SpreadElement ? arg.argument : arg;
                     const accesses = collectThisAccesses(targetNode);
                     for (const access of accesses) {
-                        reportAccess(methodName, methodMeta, index, access);
+                        const key = `${index}:${access.propertyName}`;
+                        let argMap = currentMethodStats.argStats.get(index);
+                        if (!argMap) {
+                            argMap = new Map();
+                            currentMethodStats.argStats.set(index, argMap);
+                        }
+                        let propStats = argMap.get(access.propertyName);
+                        if (!propStats) {
+                            propStats = { callsWithProperty: 0, violations: [] };
+                            argMap.set(access.propertyName, propStats);
+                        }
+                        propStats.violations.push({
+                            methodMeta: methodMeta,
+                            access,
+                        });
+                        if (!seenInThisCall.has(key)) {
+                            propStats.callsWithProperty++;
+                            seenInThisCall.add(key);
+                        }
                     }
                 });
             },

package/lib/rules/no-unmemoized-memo-without-props.js

@@ -274,7 +274,7 @@ exports.noUnmemoizedMemoWithoutProps = (0, createRule_1.createRule)({
             if (!node.body) {
                 return;
             }
-            const returnsJsx = ASTHelpers_1.ASTHelpers.returnsJSX(node.body);
+            const returnsJsx = ASTHelpers_1.ASTHelpers.returnsJSX(node.body, context);
             if (!returnsJsx) {
                 return;
             }

package/lib/rules/no-unnecessary-destructuring-rename.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnnecessaryDestructuringRename = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 const BINDABLE_IDENTIFIER_PATTERN = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
 const RESERVED_BINDINGS = new Set([
     'break',
@@ -113,11 +114,7 @@ exports.noUnnecessaryDestructuringRename = (0, createRule_1.createRule)({
         const sourceCode = context.getSourceCode();
         const candidates = [];
         const getDeclaredVariables = (node) => {
-            const sourceCodeWithDeclarations = sourceCode;
-            if (typeof sourceCodeWithDeclarations.getDeclaredVariables === 'function') {
-                return sourceCodeWithDeclarations.getDeclaredVariables(node);
-            }
-            return context.getDeclaredVariables(node);
+            return ASTHelpers_1.ASTHelpers.getDeclaredVariables(context, node);
         };
         function collectDeclaredVariablesUpTree(node) {
             const variables = [];

package/lib/rules/parallelize-async-operations.js

@@ -13,6 +13,9 @@ const defaultOptions = [
             'updatethreshold',
             'setthreshold',
             'checkthreshold',
+            'commit',
+            'flush',
+            'saveall',
         ],
     },
 ];
@@ -95,81 +98,149 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             return null;
         }
         /**
-         * Checks if an identifier is used in a node
+         * Generic AST visitor for identifier collection
          */
-        function isIdentifierUsedInNode(identifier, node) {
-            let isUsed = false;
-            function visit(node) {
-                if (node.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.name === identifier) {
-                    isUsed = true;
-                    return;
+        function visitIdentifiers(node, callback, options = {}) {
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const parent = node.parent;
+                // Skip non-computed properties in MemberExpressions as they are not value uses
+                if (parent && parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    if (parent.property === node &&
+                        !parent.computed &&
+                        !options.includeMemberProperties) {
+                        return false;
+                    }
+                }
+                // Skip non-shorthand keys in object literals as they are not value uses
+                if (parent && parent.type === utils_1.AST_NODE_TYPES.Property) {
+                    if (parent.key === node &&
+                        !parent.computed &&
+                        !parent.shorthand) {
+                        return false;
+                    }
                 }
-                // Recursively visit all child nodes
-                for (const key in node) {
-                    if (key === 'parent' || key === 'range' || key === 'loc')
-                        continue;
-                    const child = node[key];
-                    if (child && typeof child === 'object') {
-                        if (Array.isArray(child)) {
-                            for (const item of child) {
-                                if (item && typeof item === 'object' && 'type' in item) {
-                                    visit(item);
+                if (callback(node.name) === true)
+                    return true;
+            }
+            /**
+             * Recursively traverses child nodes while skipping 'parent' to avoid
+             * circular back-references, and 'range'/'loc' which are metadata.
+             */
+            for (const key in node) {
+                if (key === 'parent' || key === 'range' || key === 'loc')
+                    continue;
+                const child = node[key];
+                if (child && typeof child === 'object') {
+                    if (Array.isArray(child)) {
+                        for (const item of child) {
+                            if (item && typeof item === 'object' && 'type' in item) {
+                                if (visitIdentifiers(item, callback, options)) {
+                                    return true;
                                 }
                             }
                         }
-                        else if ('type' in child) {
-                            visit(child);
+                    }
+                    else if ('type' in child) {
+                        if (visitIdentifiers(child, callback, options)) {
+                            return true;
                         }
                     }
                 }
             }
-            visit(node);
-            return isUsed;
+            return false;
+        }
+        /**
+         * Checks if an identifier is used in a node
+         */
+        function isIdentifierUsedInNode(identifier, node) {
+            return visitIdentifiers(node, (name) => name === identifier);
         }
+        /**
+         * Extracts all identifiers used in a node
+         */
+        function getAllIdentifiers(node, options) {
+            const identifiers = new Set();
+            visitIdentifiers(node, (name) => {
+                identifiers.add(name);
+            }, options);
+            return identifiers;
+        }
+        /**
+         * Matches coordinator-like identifiers. Intentionally uses substring
+         * matching (no word boundaries) to catch patterns like "batchManager",
+         * "transactionCollector", etc. This may produce false positives for
+         * unrelated managers, but errs on the side of safety.
+         */
+        const COORDINATOR_PATTERN = /batch|manager|collector|transaction|tx|unitofwork|accumulator/i;
         /**
          * Checks if there are dependencies between await expressions
          */
         function hasDependencies(awaitNodes, variableNames, sideEffectPatterns) {
-            // If we have fewer than 2 nodes, there are no dependencies to check
             if (awaitNodes.length < 2) {
                 return false;
             }
-            // For each await node (except the first), check if it depends on previous variables
-            for (let i = 1; i < awaitNodes.length; i++) {
+            const allIdentifiers = awaitNodes.map((node) => {
+                const awaitExpr = getAwaitExpression(node);
+                return awaitExpr
+                    ? getAllIdentifiers(awaitExpr.argument, {
+                        includeMemberProperties: true,
+                    })
+                    : new Set();
+            });
+            // Check all nodes for side effects and shared coordinators
+            for (let i = 0; i < awaitNodes.length; i++) {
                 const currentNode = awaitNodes[i];
-                // Check if any previous variable is used in the current await expression
-                for (const varName of variableNames) {
-                    const awaitExpr = getAwaitExpression(currentNode);
-                    if (awaitExpr &&
-                        isIdentifierUsedInNode(varName, awaitExpr.argument)) {
-                        return true;
-                    }
-                }
-                // Check for operations that might have side effects that affect subsequent operations
-                // This is a conservative heuristic - we only flag very specific patterns
                 const awaitExpr = getAwaitExpression(currentNode);
-                if (awaitExpr &&
-                    awaitExpr.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                    const callee = awaitExpr.argument.callee;
-                    // Check for method calls that might indicate side effects
-                    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const methodName = callee.property.name;
-                        if (sideEffectPatterns.some((pattern) => pattern.test(methodName))) {
+                if (!awaitExpr)
+                    continue;
+                // 1. Check if current node depends on variables DECLARED in previous awaits
+                if (i > 0) {
+                    for (const varName of variableNames) {
+                        if (isIdentifierUsedInNode(varName, awaitExpr.argument)) {
                             return true;
                         }
                     }
-                    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
-                        const functionName = callee.name;
-                        if (sideEffectPatterns.some((pattern) => pattern.test(functionName))) {
-                            return true;
+                }
+                // 2. Check for shared coordinators between this node and ANY previous node
+                if (i > 0) {
+                    const currentIds = allIdentifiers[i];
+                    for (const id of currentIds) {
+                        if (COORDINATOR_PATTERN.test(id)) {
+                            for (let j = 0; j < i; j++) {
+                                if (allIdentifiers[j].has(id)) {
+                                    return true;
+                                }
+                            }
                         }
                     }
                 }
+                // 3. Check for operations that might have side effects
+                // If any node has a side effect, we should not parallelize the sequence
+                let callExpr = null;
+                if (awaitExpr.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    callExpr = awaitExpr.argument;
+                }
+                else if (awaitExpr.argument.type === utils_1.AST_NODE_TYPES.ChainExpression &&
+                    awaitExpr.argument.expression.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    callExpr = awaitExpr.argument.expression;
+                }
+                if (callExpr) {
+                    const callee = callExpr.callee;
+                    let methodName = null;
+                    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        methodName = callee.property.name;
+                    }
+                    else if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        methodName = callee.name;
+                    }
+                    if (methodName &&
+                        sideEffectPatterns.some((pattern) => pattern.test(methodName))) {
+                        return true;
+                    }
+                }
             }
             // If any node is a variable declaration with destructuring, consider it as having dependencies
-            // This is because destructuring often creates variables that are used later
             for (const node of awaitNodes) {
                 if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
                     for (const declaration of node.declarations) {
@@ -234,7 +305,6 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
         function areInTryCatchBlocks(nodes) {
             for (const node of nodes) {
                 let current = node;
-                // Traverse up to find if the node is in a try block
                 while (current && current.parent) {
                     if (current.parent.type === utils_1.AST_NODE_TYPES.TryStatement &&
                         current.parent.block === current) {
@@ -253,7 +323,6 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
         function areInLoop(nodes) {
             for (const node of nodes) {
                 let current = node;
-                // Traverse up to find if the node is in a loop
                 while (current && current.parent) {
                     if (current.parent.type === utils_1.AST_NODE_TYPES.ForStatement ||
                         current.parent.type === utils_1.AST_NODE_TYPES.ForInStatement ||
@@ -276,14 +345,12 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
             if (awaitNodes.length < 2) {
                 return null;
             }
-            // Extract the await expressions
             const awaitExpressions = awaitNodes
                 .map((node) => getAwaitExpression(node))
                 .filter((node) => node !== null);
             if (awaitExpressions.length < 2) {
                 return null;
             }
-            // Get the text of each await argument
             const awaitArguments = awaitExpressions.map((expr) => sourceCode.getText(expr.argument));
             const idsText = [];
             const declKinds = new Set();
@@ -316,9 +383,7 @@ exports.parallelizeAsyncOperations = (0, createRule_1.createRule)({
                 // Simple Promise.all without variable assignments
                 promiseAllText = `await Promise.all([\n  ${awaitArguments.join(',\n  ')}\n]);`;
             }
-            // Find the start position, accounting for leading comments
             const startPos = awaitNodes[0].range[0];
-            // Replace the range from the start of the first await to the end of the last await
             const endPos = awaitNodes[awaitNodes.length - 1].range[1];
             return fixer.replaceTextRange([startPos, endPos], promiseAllText);
         }

package/lib/rules/prefer-nullish-coalescing-boolean-props.js

@@ -1,9 +1,73 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.preferNullishCoalescingBooleanProps = void 0;
 const utils_1 = require("@typescript-eslint/utils");
+const ts = __importStar(require("typescript"));
 const createRule_1 = require("../utils/createRule");
 const BOOLEAN_PROP_REGEX = /^(is|has|should|can|will|do|does|did|was|were|enable|disable)/;
+function isBooleanType(type, checker) {
+    if (type.isUnion()) {
+        return type.types.every((t) => isBooleanType(t, checker));
+    }
+    // For type parameters, check if the constraint is a boolean type
+    if (type.getFlags() & ts.TypeFlags.TypeParameter) {
+        if (checker) {
+            const constraint = checker.getBaseConstraintOfType(type);
+            if (constraint && constraint !== type) {
+                return isBooleanType(constraint, checker);
+            }
+        }
+        return false;
+    }
+    return ((type.getFlags() & (ts.TypeFlags.Boolean | ts.TypeFlags.BooleanLiteral)) !==
+        0);
+}
+function isPossiblyNullish(type, checker) {
+    if (type.isUnion()) {
+        return type.types.some((t) => isPossiblyNullish(t, checker));
+    }
+    // For type parameters, check if the constraint excludes nullish
+    if (type.getFlags() & ts.TypeFlags.TypeParameter) {
+        if (checker) {
+            const constraint = checker.getBaseConstraintOfType(type);
+            if (constraint && constraint !== type) {
+                return isPossiblyNullish(constraint, checker);
+            }
+        }
+        // If we can't determine the constraint, assume it could be nullish
+        return true;
+    }
+    return ((type.getFlags() &
+        (ts.TypeFlags.Null |
+            ts.TypeFlags.Undefined |
+            ts.TypeFlags.Void |
+            ts.TypeFlags.Any |
+            ts.TypeFlags.Unknown)) !==
+        0);
+}
 function isInJSXBooleanAttribute(node) {
     const parent = node.parent;
     if (parent?.type !== utils_1.AST_NODE_TYPES.JSXAttribute)
@@ -57,7 +121,34 @@ function isInConditionalContext(node) {
 /**
  * Determines if a node is within a boolean context in JSX props or other boolean contexts
  */
-function isInBooleanContext(node) {
+function isInBooleanContext(node, checker, parserServices) {
+    if (checker && parserServices) {
+        try {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const contextualType = checker.getContextualType(tsNode);
+            if (contextualType && isBooleanType(contextualType, checker)) {
+                return true;
+            }
+            // Also check if the expression itself is a boolean type
+            const actualType = checker.getTypeAtLocation(tsNode);
+            if (actualType && isBooleanType(actualType, checker)) {
+                return true;
+            }
+            // If this is a logical expression, also check if the left operand is a boolean
+            if (node.type === utils_1.AST_NODE_TYPES.LogicalExpression) {
+                const leftTSNode = parserServices.esTreeNodeToTSNodeMap.get(node.left);
+                const leftType = checker.getTypeAtLocation(leftTSNode);
+                if (leftType && isBooleanType(leftType, checker)) {
+                    return true;
+                }
+            }
+        }
+        catch {
+            // esTreeNodeToTSNodeMap may fail for synthetic nodes or nodes without
+            // source positions; getContextualType may return undefined for non-expression
+            // contexts. Fall back to AST-based heuristics in these cases.
+        }
+    }
     let current = node;
     // Traverse up the AST to find if we're in a boolean context
     while (current && current.parent) {
@@ -365,7 +456,19 @@ function isInBooleanContext(node) {
 /**
  * Checks if the left operand could be nullish (null or undefined)
  */
-function couldBeNullish(node) {
+function couldBeNullish(node, checker, parserServices) {
+    if (checker && parserServices) {
+        try {
+            const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
+            const type = checker.getTypeAtLocation(tsNode);
+            return isPossiblyNullish(type, checker);
+        }
+        catch {
+            // esTreeNodeToTSNodeMap may fail for synthetic nodes or nodes without
+            // source positions; getTypeAtLocation may throw for nodes without
+            // type information. Fall back to manual check.
+        }
+    }
     // For literals, check the actual value
     if (node.type === utils_1.AST_NODE_TYPES.Literal) {
         return node.value === null || node.value === undefined;
@@ -402,16 +505,18 @@ exports.preferNullishCoalescingBooleanProps = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
+        const parserServices = utils_1.ESLintUtils.getParserServices(context, true);
+        const checker = parserServices?.program?.getTypeChecker();
         return {
             LogicalExpression(node) {
                 if (node.operator === '||') {
                     // If the node is in a boolean context, we allow logical OR
-                    if (isInBooleanContext(node)) {
+                    if (isInBooleanContext(node, checker, parserServices)) {
                         return;
                     }
                     // Check if this could benefit from nullish coalescing
                     // We only suggest nullish coalescing when the left operand could be nullish
-                    if (couldBeNullish(node.left)) {
+                    if (couldBeNullish(node.left, checker, parserServices)) {
                         const sourceCode = context.getSourceCode();
                         const leftText = sourceCode.getText(node.left);
                         const rightText = sourceCode.getText(node.right);

package/lib/rules/prefer-params-over-parent-id.js

@@ -202,7 +202,7 @@ exports.preferParamsOverParentId = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Prefer handler params for parent IDs instead of traversing ref.parent.id so Firebase triggers stay aligned with path templates and type-safe.',
+            description: 'Prefer event.params over ref.parent.id for type-safe Firebase trigger paths.',
             recommended: 'error',
         },
         fixable: 'code',