@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.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;
         }
@@ -91,13 +97,40 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            noTypeAssertionReturns: 'Type assertions in return statements are not allowed. Type the variable explicitly before returning it.',
-            useExplicitVariable: 'Explicit return type annotations are not allowed. Type the variable explicitly before returning it.',
+            noTypeAssertionReturns: `What's wrong: Return value uses a type assertion to "{{assertedType}}", which bypasses TypeScript checks. ` +
+                `→ Why it matters: Casts can hide missing or invalid data and let unsafe values reach callers without compile-time errors. ` +
+                `→ How to fix: Create a typed variable or add a narrowing step before returning so the value is validated by the type system instead of forced with a cast.`,
+            useExplicitVariable: `What's wrong: Return type "{{returnType}}" is declared while returning an unchecked expression, so TypeScript trusts the annotation instead of validating the actual value. ` +
+                `→ Why it matters: This hides mismatches between implementation and contract, letting incorrect return values propagate without type errors. ` +
+                `→ How to fix: Assign the expression to a typed variable or narrow it first, then return that variable so TypeScript can verify it against the declared return type.`,
         },
     },
     defaultOptions: [defaultOptions],
     create(context, [options]) {
         const mergedOptions = { ...defaultOptions, ...options };
+        const sourceCode = context.getSourceCode();
+        function getTypeText(typeNode, fallback) {
+            const text = typeNode ? sourceCode.getText(typeNode).trim() : '';
+            return text || fallback;
+        }
+        function reportTypeAssertion(node) {
+            context.report({
+                node,
+                messageId: 'noTypeAssertionReturns',
+                data: {
+                    assertedType: getTypeText(node.typeAnnotation, 'the asserted type'),
+                },
+            });
+        }
+        function reportReturnTypeAnnotation(typeAnnotation) {
+            context.report({
+                node: typeAnnotation,
+                messageId: 'useExplicitVariable',
+                data: {
+                    returnType: getTypeText(typeAnnotation.typeAnnotation, 'the declared return type'),
+                },
+            });
+        }
         /**
          * Checks if a node is inside a JSX attribute or object property (which could be JSX props)
          */
@@ -196,7 +229,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
         /**
          * Check if the current file is a .f.ts file
          */
-        function isFunctionFile(context) {
+        function isFunctionFile() {
             const filename = context.getFilename();
             return filename.endsWith('.f.ts');
         }
@@ -207,7 +240,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             if (!node.returnType)
                 return;
             // Skip checking return types in .f.ts files
-            if (isFunctionFile(context)) {
+            if (isFunctionFile()) {
                 return;
             }
             // Allow type predicates if configured
@@ -218,10 +251,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
             // If type predicates are not allowed, report them
             if (!mergedOptions.allowTypePredicates &&
                 isTypePredicate(node.returnType)) {
-                context.report({
-                    node: node.returnType,
-                    messageId: 'useExplicitVariable',
-                });
+                reportReturnTypeAnnotation(node.returnType);
                 return;
             }
             // Check if the function has a return statement with a direct value (not a variable)
@@ -238,10 +268,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                         if (statement.argument.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
                             statement.argument.type === utils_1.AST_NODE_TYPES.ArrayExpression ||
                             statement.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
-                            context.report({
-                                node: node.returnType,
-                                messageId: 'useExplicitVariable',
-                            });
+                            reportReturnTypeAnnotation(node.returnType);
                             break;
                         }
                     }
@@ -261,23 +288,14 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     }
                     // For nested type assertions, only report the outermost one
                     if (node.argument.expression.type === utils_1.AST_NODE_TYPES.TSAsExpression) {
-                        context.report({
-                            node: node.argument,
-                            messageId: 'noTypeAssertionReturns',
-                        });
+                        reportTypeAssertion(node.argument);
                         return;
                     }
-                    context.report({
-                        node: node.argument,
-                        messageId: 'noTypeAssertionReturns',
-                    });
+                    reportTypeAssertion(node.argument);
                 }
                 // Check for type assertions using angle bracket syntax
                 if (node.argument.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
-                    context.report({
-                        node: node.argument,
-                        messageId: 'noTypeAssertionReturns',
-                    });
+                    reportTypeAssertion(node.argument);
                 }
             },
             // Check functions with explicit return types
@@ -295,7 +313,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     // Check for explicit return type
                     if (node.returnType) {
                         // Skip checking return types in .f.ts files
-                        if (isFunctionFile(context)) {
+                        if (isFunctionFile()) {
                             return;
                         }
                         // Allow type predicates if configured
@@ -306,19 +324,13 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                         // If type predicates are not allowed, report them
                         if (!mergedOptions.allowTypePredicates &&
                             isTypePredicate(node.returnType)) {
-                            context.report({
-                                node: node.returnType,
-                                messageId: 'useExplicitVariable',
-                            });
+                            reportReturnTypeAnnotation(node.returnType);
                             return;
                         }
                         // If returning an object literal with explicit return type, report it
                         if (node.body.type === utils_1.AST_NODE_TYPES.ObjectExpression ||
                             node.body.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
-                            context.report({
-                                node: node.returnType,
-                                messageId: 'useExplicitVariable',
-                            });
+                            reportReturnTypeAnnotation(node.returnType);
                         }
                     }
                     // Check for type assertions in the body
@@ -327,16 +339,10 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                         if (mergedOptions.allowAsConst && isAsConstAssertion(node.body)) {
                             return;
                         }
-                        context.report({
-                            node: node.body,
-                            messageId: 'noTypeAssertionReturns',
-                        });
+                        reportTypeAssertion(node.body);
                     }
                     else if (node.body.type === utils_1.AST_NODE_TYPES.TSTypeAssertion) {
-                        context.report({
-                            node: node.body,
-                            messageId: 'noTypeAssertionReturns',
-                        });
+                        reportTypeAssertion(node.body);
                     }
                 }
                 else if (node.returnType) {
@@ -359,10 +365,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     return;
                 }
                 // For standalone type assertions in expressions
-                context.report({
-                    node,
-                    messageId: 'noTypeAssertionReturns',
-                });
+                reportTypeAssertion(node);
             },
             // Check for type assertions using angle bracket syntax
             TSTypeAssertion(node) {
@@ -371,10 +374,7 @@ exports.noTypeAssertionReturns = (0, createRule_1.createRule)({
                     return;
                 }
                 // For standalone type assertions in expressions
-                context.report({
-                    node,
-                    messageId: 'noTypeAssertionReturns',
-                });
+                reportTypeAssertion(node);
             },
         };
     },