@blumintinc/eslint-plugin-blumint 1.12.6 → 1.13.0

package/lib/rules/no-try-catch-already-exists-in-transaction.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noTryCatchAlreadyExistsInTransaction = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const ALREADY_EXISTS_STRINGS = new Set(['already-exists', 'ALREADY_EXISTS']);
+const ALREADY_EXISTS_NUMBERS = new Set([6, '6']);
+function unwrapChainExpression(expression) {
+    if (expression.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return expression.expression;
+    }
+    return expression;
+}
+function isRunTransactionCall(node) {
+    const callee = unwrapChainExpression(node.callee);
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name === 'runTransaction';
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        const property = callee.property;
+        return (!callee.computed &&
+            property.type === utils_1.AST_NODE_TYPES.Identifier &&
+            property.name === 'runTransaction');
+    }
+    return false;
+}
+function getCallbackArgument(args) {
+    for (const arg of args) {
+        if (arg.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+            arg.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+            return arg;
+        }
+    }
+    return null;
+}
+function isErrorAliasExpression(expression, context) {
+    if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return context.errorAliases.has(expression.name);
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        expression.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
+        return isErrorAliasExpression(expression.expression, context);
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return isErrorAliasExpression(expression.object, context);
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return isErrorAliasExpression(expression.expression, context);
+    }
+    return false;
+}
+function isCodeProperty(property) {
+    if (property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return property.name === 'code';
+    }
+    if (property.type === utils_1.AST_NODE_TYPES.Literal) {
+        return property.value === 'code';
+    }
+    return false;
+}
+function isErrorCodeExpression(expression, context) {
+    if (!expression) {
+        return false;
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return context.codeAliases.has(expression.name);
+    }
+    const unwrapped = expression.type === utils_1.AST_NODE_TYPES.ChainExpression
+        ? expression.expression
+        : expression;
+    if (unwrapped.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        return (isCodeProperty(unwrapped.property) &&
+            isErrorAliasExpression(unwrapped.object, context));
+    }
+    return false;
+}
+function isAlreadyExistsLiteral(expression) {
+    if (!expression) {
+        return null;
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.PrivateIdentifier) {
+        return null;
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.Literal) {
+        if (ALREADY_EXISTS_STRINGS.has(`${expression.value}`)) {
+            return `${expression.value}`;
+        }
+        if (ALREADY_EXISTS_NUMBERS.has(expression.value)) {
+            return `${expression.value}`;
+        }
+    }
+    if (expression.type === utils_1.AST_NODE_TYPES.TemplateLiteral &&
+        expression.expressions.length === 0 &&
+        expression.quasis.length === 1) {
+        const raw = expression.quasis[0].value.cooked;
+        if (raw && ALREADY_EXISTS_STRINGS.has(raw)) {
+            return raw;
+        }
+    }
+    return null;
+}
+function isAlreadyExistsComparison(expression, context) {
+    if (expression.type !== utils_1.AST_NODE_TYPES.BinaryExpression) {
+        return null;
+    }
+    if (!['==', '==='].includes(expression.operator)) {
+        return null;
+    }
+    const leftLiteral = isAlreadyExistsLiteral(expression.left);
+    const rightLiteral = isAlreadyExistsLiteral(expression.right);
+    if (leftLiteral && isErrorCodeExpression(expression.right, context)) {
+        return leftLiteral;
+    }
+    if (rightLiteral && isErrorCodeExpression(expression.left, context)) {
+        return rightLiteral;
+    }
+    return null;
+}
+function addAliasesFromDeclarator(declarator, context) {
+    const init = declarator.init;
+    const id = declarator.id;
+    const initIsAliasSource = !!init &&
+        (isErrorAliasExpression(init, context) ||
+            (init.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                isErrorAliasExpression(init.right, context)));
+    if (id.type === utils_1.AST_NODE_TYPES.Identifier && initIsAliasSource) {
+        context.errorAliases.add(id.name);
+    }
+    if (id.type === utils_1.AST_NODE_TYPES.ObjectPattern && initIsAliasSource) {
+        for (const property of id.properties) {
+            if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+                continue;
+            }
+            const value = property.value;
+            if (isCodeProperty(property.key) &&
+                value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                context.codeAliases.add(value.name);
+            }
+        }
+    }
+}
+function containsAlreadyExistsCheck(node, context) {
+    if (!node) {
+        return null;
+    }
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.BlockStatement: {
+            for (const statement of node.body) {
+                const found = containsAlreadyExistsCheck(statement, context);
+                if (found)
+                    return found;
+            }
+            return null;
+        }
+        case utils_1.AST_NODE_TYPES.ExpressionStatement:
+            return containsAlreadyExistsCheck(node.expression, context);
+        case utils_1.AST_NODE_TYPES.ReturnStatement:
+            return containsAlreadyExistsCheck(node.argument, context);
+        case utils_1.AST_NODE_TYPES.IfStatement: {
+            const testMatch = containsAlreadyExistsCheck(node.test, context);
+            if (testMatch)
+                return testMatch;
+            const consequentMatch = containsAlreadyExistsCheck(node.consequent, context);
+            if (consequentMatch)
+                return consequentMatch;
+            return containsAlreadyExistsCheck(node.alternate, context);
+        }
+        case utils_1.AST_NODE_TYPES.SwitchStatement: {
+            const discriminantIsCode = isErrorCodeExpression(node.discriminant, context);
+            for (const switchCase of node.cases) {
+                const caseLiteral = isAlreadyExistsLiteral(switchCase.test);
+                if (discriminantIsCode && caseLiteral) {
+                    return caseLiteral;
+                }
+                const found = switchCase.consequent
+                    .map((stmt) => containsAlreadyExistsCheck(stmt, context))
+                    .find(Boolean);
+                if (found)
+                    return found;
+            }
+            return null;
+        }
+        case utils_1.AST_NODE_TYPES.VariableDeclaration: {
+            for (const declarator of node.declarations) {
+                addAliasesFromDeclarator(declarator, context);
+                const found = containsAlreadyExistsCheck(declarator.init, context);
+                if (found)
+                    return found;
+            }
+            return null;
+        }
+        case utils_1.AST_NODE_TYPES.VariableDeclarator:
+            addAliasesFromDeclarator(node, context);
+            return containsAlreadyExistsCheck(node.init, context);
+        case utils_1.AST_NODE_TYPES.AssignmentExpression:
+            if (node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                isErrorAliasExpression(node.right, context)) {
+                context.errorAliases.add(node.left.name);
+            }
+            return containsAlreadyExistsCheck(node.right, context);
+        case utils_1.AST_NODE_TYPES.CallExpression:
+        case utils_1.AST_NODE_TYPES.NewExpression: {
+            const calleeMatch = containsAlreadyExistsCheck(node.callee, context);
+            if (calleeMatch)
+                return calleeMatch;
+            for (const arg of node.arguments) {
+                const found = containsAlreadyExistsCheck(arg, context);
+                if (found)
+                    return found;
+            }
+            return null;
+        }
+        case utils_1.AST_NODE_TYPES.LogicalExpression: {
+            const leftMatch = containsAlreadyExistsCheck(node.left, context);
+            if (leftMatch)
+                return leftMatch;
+            return containsAlreadyExistsCheck(node.right, context);
+        }
+        case utils_1.AST_NODE_TYPES.BinaryExpression:
+            return (isAlreadyExistsComparison(node, context) ||
+                containsAlreadyExistsCheck(node.left, context) ||
+                containsAlreadyExistsCheck(node.right, context));
+        case utils_1.AST_NODE_TYPES.ConditionalExpression: {
+            const testMatch = containsAlreadyExistsCheck(node.test, context);
+            if (testMatch)
+                return testMatch;
+            const consequentMatch = containsAlreadyExistsCheck(node.consequent, context);
+            if (consequentMatch)
+                return consequentMatch;
+            return containsAlreadyExistsCheck(node.alternate, context);
+        }
+        case utils_1.AST_NODE_TYPES.MemberExpression:
+            return containsAlreadyExistsCheck(node.object, context);
+        case utils_1.AST_NODE_TYPES.ChainExpression:
+            return containsAlreadyExistsCheck(node.expression, context);
+        case utils_1.AST_NODE_TYPES.AwaitExpression:
+        case utils_1.AST_NODE_TYPES.UnaryExpression:
+        case utils_1.AST_NODE_TYPES.UpdateExpression:
+            return containsAlreadyExistsCheck(node.argument, context);
+        case utils_1.AST_NODE_TYPES.TemplateLiteral:
+            return null;
+        case utils_1.AST_NODE_TYPES.TryStatement: {
+            const blockMatch = containsAlreadyExistsCheck(node.block, context);
+            if (blockMatch)
+                return blockMatch;
+            const handlerMatch = containsAlreadyExistsCheck(node.handler?.body, context);
+            if (handlerMatch)
+                return handlerMatch;
+            return containsAlreadyExistsCheck(node.finalizer, context);
+        }
+        default:
+            return null;
+    }
+}
+function createCatchContext(handler) {
+    const errorAliases = new Set();
+    const codeAliases = new Set();
+    const param = handler.param;
+    if (param?.type === utils_1.AST_NODE_TYPES.Identifier) {
+        errorAliases.add(param.name);
+    }
+    else if (param?.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+        for (const property of param.properties) {
+            if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+                continue;
+            }
+            const value = property.value;
+            if (isCodeProperty(property.key) &&
+                value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                codeAliases.add(value.name);
+            }
+        }
+    }
+    return { errorAliases, codeAliases };
+}
+exports.noTryCatchAlreadyExistsInTransaction = (0, createRule_1.createRule)({
+    name: 'no-try-catch-already-exists-in-transaction',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow catching ALREADY_EXISTS errors inside Firestore transaction callbacks',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noAlreadyExistsCatchInTransaction: 'Do not catch ALREADY_EXISTS ({{codeLiteral}}) inside Firestore transaction callbacks. Firestore retries transaction bodies on contention, so this catch will re-run even though ALREADY_EXISTS is permanent. Move the try/catch outside the transaction or use runCreateForgivenessTransaction so the handler runs once.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const transactionBodies = new Set();
+        function isInsideTransaction(node) {
+            let current = node;
+            while (current) {
+                if (transactionBodies.has(current)) {
+                    return true;
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        return {
+            CallExpression(node) {
+                if (!isRunTransactionCall(node)) {
+                    return;
+                }
+                const callback = getCallbackArgument(node.arguments);
+                if (callback && callback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    transactionBodies.add(callback.body);
+                }
+            },
+            'CallExpression:exit'(node) {
+                if (!isRunTransactionCall(node)) {
+                    return;
+                }
+                const callback = getCallbackArgument(node.arguments);
+                if (callback && callback.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                    transactionBodies.delete(callback.body);
+                }
+            },
+            TryStatement(node) {
+                if (!isInsideTransaction(node)) {
+                    return;
+                }
+                const handler = node.handler;
+                if (!handler) {
+                    return;
+                }
+                const catchContext = createCatchContext(handler);
+                const match = containsAlreadyExistsCheck(handler.body, catchContext);
+                if (match) {
+                    context.report({
+                        node: handler,
+                        messageId: 'noAlreadyExistsCatchInTransaction',
+                        data: { codeLiteral: match },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-try-catch-already-exists-in-transaction.js.map

package/lib/rules/no-type-assertion-returns.js

@@ -28,6 +28,12 @@ function isTypePredicate(node) {
 function isInsideReturnStatement(node) {
     let current = node;
     while (current?.parent) {
+        // If we encounter a variable declaration before a return statement,
+        // then the node is not directly inside a return statement
+        if (current.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+            current.parent.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+            return false;
+        }
         if (current.parent.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
             return true;
         }

package/lib/rules/no-undefined-null-passthrough.js

@@ -6,8 +6,8 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
     create(context) {
         return {
             FunctionDeclaration(node) {
-                // Only apply to functions with exactly one parameter
-                if (node.params.length !== 1) {
+                // Skip functions with no parameters
+                if (node.params.length === 0) {
                     return;
                 }
                 // Skip React hooks (functions starting with 'use')
@@ -16,11 +16,18 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
                     node.id.name.startsWith('use')) {
                     return;
                 }
-                checkFunctionBody(node.body, node.params[0], context);
+                // For functions with exactly one parameter, check if it's passing through null/undefined
+                if (node.params.length === 1) {
+                    checkFunctionBody(node.body, node.params[0], context);
+                }
+                else {
+                    // For functions with multiple parameters, check for early returns without arguments
+                    checkFunctionBodyForEarlyReturns(node.body, node.params, context);
+                }
             },
             ArrowFunctionExpression(node) {
-                // Only apply to arrow functions with exactly one parameter
-                if (node.params.length !== 1) {
+                // Skip functions with no parameters
+                if (node.params.length === 0) {
                     return;
                 }
                 // Skip if the function is part of a variable declaration that starts with 'use' (React hook)
@@ -33,16 +40,22 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
                 }
                 // For arrow functions with block body
                 if (node.body.type === 'BlockStatement') {
-                    checkFunctionBody(node.body, node.params[0], context);
+                    if (node.params.length === 1) {
+                        checkFunctionBody(node.body, node.params[0], context);
+                    }
+                    else {
+                        // For functions with multiple parameters, check for early returns without arguments
+                        checkFunctionBodyForEarlyReturns(node.body, node.params, context);
+                    }
                 }
-                else {
-                    // For arrow functions with expression body (implicit return)
+                else if (node.params.length === 1) {
+                    // For arrow functions with expression body (implicit return) and one parameter
                     checkImplicitReturn(node, context);
                 }
             },
             FunctionExpression(node) {
-                // Only apply to functions with exactly one parameter
-                if (node.params.length !== 1) {
+                // Skip functions with no parameters
+                if (node.params.length === 0) {
                     return;
                 }
                 // Skip if the function is part of a variable declaration that starts with 'use' (React hook)
@@ -53,7 +66,14 @@ exports.noUndefinedNullPassthrough = (0, createRule_1.createRule)({
                     parent.id.name.startsWith('use')) {
                     return;
                 }
-                checkFunctionBody(node.body, node.params[0], context);
+                // For functions with exactly one parameter, check if it's passing through null/undefined
+                if (node.params.length === 1) {
+                    checkFunctionBody(node.body, node.params[0], context);
+                }
+                else {
+                    // For functions with multiple parameters, check for early returns without arguments
+                    checkFunctionBodyForEarlyReturns(node.body, node.params, context);
+                }
             },
         };
     },
@@ -136,18 +156,81 @@ function checkFunctionBody(body, param, context) {
 function checkForTransformation(body, paramName) {
     if (!paramName)
         return false;
-    // Look for return statements that call functions with the parameter
+    // Look for return statements or other statements that use the parameter in a transformation
     for (const statement of body.body) {
         if (statement.type === 'ReturnStatement' && statement.argument) {
-            // Check for return transformData(data) pattern
-            if (statement.argument.type === 'CallExpression' &&
-                statement.argument.arguments.some(arg => arg.type === 'Identifier' && arg.name === paramName)) {
+            // Check for various transformation patterns
+            if (containsParameterTransformation(statement.argument, paramName)) {
+                return true;
+            }
+        }
+        // Check for other statements that might contain transformations (like for loops with yield)
+        if (statement.type === 'ForStatement' ||
+            statement.type === 'ForInStatement' ||
+            statement.type === 'ForOfStatement') {
+            if (containsTransformationInStatement(statement, paramName)) {
                 return true;
             }
         }
     }
     return false;
 }
+/**
+ * Check if a statement contains a transformation of the parameter
+ */
+function containsTransformationInStatement(statement, 
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+_paramName) {
+    // For generator functions, check if there are yield expressions with external function calls
+    if (statement.type === 'ForOfStatement' &&
+        statement.body.type === 'BlockStatement') {
+        for (const stmt of statement.body.body) {
+            if (stmt.type === 'ExpressionStatement' &&
+                stmt.expression.type === 'YieldExpression' &&
+                stmt.expression.argument &&
+                stmt.expression.argument.type === 'CallExpression' &&
+                stmt.expression.argument.callee.type === 'Identifier') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+/**
+ * Check if an expression contains a transformation of the parameter
+ * A transformation is considered to be calling external functions with the parameter,
+ * not just calling methods on the parameter itself.
+ */
+function containsParameterTransformation(node, paramName) {
+    // Check for direct function calls with the parameter: transformData(data)
+    // This is considered a transformation because it's calling an external function
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'Identifier' && // External function call
+        node.arguments.some((arg) => arg.type === 'Identifier' && arg.name === paramName)) {
+        return true;
+    }
+    // Check for Object.* method calls: Object.keys(data), Object.values(data), Object.entries(data)
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'Identifier' &&
+        node.callee.object.name === 'Object' &&
+        node.arguments.some((arg) => arg.type === 'Identifier' && arg.name === paramName)) {
+        return true;
+    }
+    // Check for chained operations that start with external functions: Object.entries(rounds).reduce(...).sort(...)
+    if (node.type === 'CallExpression' &&
+        node.callee.type === 'MemberExpression' &&
+        node.callee.object.type === 'CallExpression' &&
+        node.callee.object.callee.type === 'MemberExpression' &&
+        node.callee.object.callee.object.type === 'Identifier' &&
+        node.callee.object.callee.object.name === 'Object' &&
+        node.callee.object.arguments.some((arg) => arg.type === 'Identifier' && arg.name === paramName)) {
+        return true;
+    }
+    // Method calls on the parameter itself (like data.process(), items.filter())
+    // are NOT considered transformations for the purpose of this rule
+    return false;
+}
 /**
  * Check arrow functions with expression bodies (implicit returns)
  */
@@ -205,8 +288,10 @@ function isNullUndefinedCheck(node, paramName) {
     }
     // Check for param === null, param === undefined, etc.
     if (node.type === 'BinaryExpression' &&
-        (node.operator === '===' || node.operator === '==' ||
-            node.operator === '!==' || node.operator === '!=')) {
+        (node.operator === '===' ||
+            node.operator === '==' ||
+            node.operator === '!==' ||
+            node.operator === '!=')) {
         const left = node.left;
         const right = node.right;
         // param === null/undefined
@@ -224,8 +309,7 @@ function isNullUndefinedCheck(node, paramName) {
         }
     }
     // Check for param === null || param === undefined
-    if (node.type === 'LogicalExpression' &&
-        node.operator === '||') {
+    if (node.type === 'LogicalExpression' && node.operator === '||') {
         return (isNullUndefinedCheck(node.left, paramName) ||
             isNullUndefinedCheck(node.right, paramName));
     }
@@ -251,4 +335,67 @@ function isParameterReference(node, paramName) {
         return false;
     return node.type === 'Identifier' && node.name === paramName;
 }
+/**
+ * Check function body for early returns without arguments (implicit undefined)
+ * based on parameter null/undefined checks
+ */
+function checkFunctionBodyForEarlyReturns(body, params, context) {
+    // Get parameter names
+    const paramNames = params
+        .map((param) => {
+        if (param.type === 'Identifier') {
+            return param.name;
+        }
+        else if (param.type === 'AssignmentPattern' &&
+            param.left.type === 'Identifier') {
+            return param.left.name;
+        }
+        return null;
+    })
+        .filter((name) => name !== null);
+    if (paramNames.length === 0)
+        return;
+    // Look for early returns without arguments based on parameter checks
+    for (const statement of body.body) {
+        if (statement.type === 'IfStatement') {
+            const test = statement.test;
+            // Check if the test is checking any parameter for null/undefined
+            const isParameterCheck = paramNames.some((paramName) => isNullUndefinedCheck(test, paramName));
+            if (isParameterCheck) {
+                // Check if the consequent is a block statement with a return
+                if (statement.consequent.type === 'BlockStatement') {
+                    for (const consequentStmt of statement.consequent.body) {
+                        if (consequentStmt.type === 'ReturnStatement' &&
+                            (!consequentStmt.argument ||
+                                isNullOrUndefinedLiteral(consequentStmt.argument))) {
+                            // Check if there's a transformation in the function
+                            const hasTransformation = paramNames.some((paramName) => checkForTransformation(body, paramName));
+                            if (!hasTransformation) {
+                                context.report({
+                                    node: statement,
+                                    messageId: 'unexpected',
+                                });
+                            }
+                            return;
+                        }
+                    }
+                }
+                // Check if the consequent is a direct return statement without an argument
+                else if (statement.consequent.type === 'ReturnStatement' &&
+                    (!statement.consequent.argument ||
+                        isNullOrUndefinedLiteral(statement.consequent.argument))) {
+                    // Check if there's a transformation in the function
+                    const hasTransformation = paramNames.some((paramName) => checkForTransformation(body, paramName));
+                    if (!hasTransformation) {
+                        context.report({
+                            node: statement,
+                            messageId: 'unexpected',
+                        });
+                    }
+                    return;
+                }
+            }
+        }
+    }
+}
 //# sourceMappingURL=no-undefined-null-passthrough.js.map

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -15,8 +15,6 @@ const COMMON_PREPOSITION_SUFFIXES = new Set([
     'At',
     'Of',
     // Temporal prepositions
-    'After',
-    'Before',
     'During',
     'Until',
     'Till',

package/lib/rules/no-unsafe-firestore-spread.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noUnsafeFirestoreSpread = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const pathLabel = (path) => path || 'the merge payload';
 exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
     name: 'no-unsafe-firestore-spread',
     meta: {
@@ -14,8 +15,8 @@ exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            unsafeObjectSpread: 'Avoid using object spread in Firestore updates. Use dot notation with FieldPath instead.',
-            unsafeArraySpread: 'Avoid using array spread in Firestore updates. Use FieldValue.arrayUnion() instead.',
+            unsafeObjectSpread: 'Firestore merge update spreads an object at "{{path}}" and rewrites that entire field. Spreading bypasses Firestore field-path merges and can drop sibling data. Update specific fields with dot notation or FieldPath instead.',
+            unsafeArraySpread: 'Firestore merge update spreads an array at "{{path}}" and writes a full array value. This bypasses arrayUnion/arrayRemove semantics and can lose concurrent changes. Use FieldValue.arrayUnion/arrayRemove (or the Web SDK equivalents) to add or remove items safely.',
         },
     },
     defaultOptions: [],
@@ -49,6 +50,7 @@ exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
                     context.report({
                         node: property,
                         messageId: 'unsafeObjectSpread',
+                        data: { path: pathLabel(parentPath) },
                         fix: null,
                     });
                 }
@@ -61,14 +63,14 @@ exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
                         checkObjectForSpreads(property.value, newPath);
                     }
                     else if (property.value.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                        checkArrayForSpreads(property.value);
+                        checkArrayForSpreads(property.value, newPath);
                     }
                     else if (property.value.type === utils_1.AST_NODE_TYPES.CallExpression) {
                         // Handle chained array methods like [...array].filter()
                         let current = property.value;
                         while (current) {
                             if (current.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                                checkArrayForSpreads(current);
+                                checkArrayForSpreads(current, newPath);
                                 break;
                             }
                             else if (current.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
@@ -88,13 +90,14 @@ exports.noUnsafeFirestoreSpread = (0, createRule_1.createRule)({
                 }
             }
         }
-        function checkArrayForSpreads(node) {
+        function checkArrayForSpreads(node, parentPath = '') {
             // Check for spreads in the array expression itself
             for (const element of node.elements) {
                 if (element?.type === utils_1.AST_NODE_TYPES.SpreadElement) {
                     context.report({
                         node: element,
                         messageId: 'unsafeArraySpread',
+                        data: { path: pathLabel(parentPath) },
                         fix: null,
                     });
                 }