@blumintinc/eslint-plugin-blumint 1.12.5 → 1.13.0

package/lib/rules/firestore-transaction-reads-before-writes.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.firestoreTransactionReadsBeforeWrites = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+// Define the operations that are considered reads and writes
+const READ_OPERATIONS = new Set(['get']);
+const WRITE_OPERATIONS = new Set(['set', 'update', 'delete']);
+exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
+    name: 'firestore-transaction-reads-before-writes',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce that all Firestore transaction read operations are performed before any write operations',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            readsAfterWrites: 'Firestore transaction read operations must be performed before any write operations. Move this read operation before any write operations.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track transaction objects and their operations
+        const transactionScopes = new Map();
+        // Helper to check if a node is a transaction parameter
+        function isTransactionParameter(param) {
+            if (param.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            // Check for type annotation
+            const typeAnnotation = param.typeAnnotation;
+            if (!typeAnnotation ||
+                typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation) {
+                // If no type annotation, check the parameter name for common patterns
+                // Include 't' as a valid transaction parameter name
+                return /^(transaction|tx|t)$/i.test(param.name);
+            }
+            const type = typeAnnotation.typeAnnotation;
+            // Check for Transaction type
+            if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                const typeName = type.typeName;
+                // Check for FirebaseFirestore.Transaction
+                if (typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                    return (typeName.left.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        typeName.left.name === 'FirebaseFirestore' &&
+                        typeName.right.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        typeName.right.name === 'Transaction');
+                }
+                // Check for Transaction or FirestoreTransaction
+                if (typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    return /Transaction/i.test(typeName.name);
+                }
+            }
+            return false;
+        }
+        // Helper to find the transaction scope for a node
+        function findTransactionScope(node) {
+            let current = node;
+            while (current) {
+                // Check if this node is a transaction scope
+                if (transactionScopes.has(current)) {
+                    return current;
+                }
+                // Check if this is a function with a transaction parameter
+                if (current.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+                    current.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+                    current.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+                    const params = current.params;
+                    if (params.some(isTransactionParameter)) {
+                        // If this function has a transaction parameter, track it
+                        if (!transactionScopes.has(current.body)) {
+                            const transactionParam = params.find(isTransactionParameter);
+                            const transactionVariables = new Set();
+                            if (transactionParam &&
+                                transactionParam.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                transactionVariables.add(transactionParam.name);
+                            }
+                            transactionScopes.set(current.body, {
+                                hasWriteOperation: false,
+                                writeNodes: [],
+                                transactionVariables,
+                            });
+                        }
+                        return current.body;
+                    }
+                }
+                current = current.parent;
+            }
+            return null;
+        }
+        // Helper to check if a node is a transaction method call
+        function isTransactionMethodCall(node, transactionScope) {
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
+                return { isRead: false, isWrite: false, methodName: null };
+            }
+            const object = callee.object;
+            const property = callee.property;
+            // Check if the object is a transaction
+            if (object.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                return { isRead: false, isWrite: false, methodName: null };
+            }
+            // If we have a transaction scope, check if the object name is a known transaction variable
+            if (transactionScope) {
+                const scopeInfo = transactionScopes.get(transactionScope);
+                if (scopeInfo && !scopeInfo.transactionVariables.has(object.name)) {
+                    return { isRead: false, isWrite: false, methodName: null };
+                }
+            }
+            else {
+                // Fallback to general pattern matching
+                if (!/^(transaction|tx|t)$/i.test(object.name)) {
+                    return { isRead: false, isWrite: false, methodName: null };
+                }
+            }
+            let methodName = null;
+            // Check if the property is a read or write operation
+            if (property.type === utils_1.AST_NODE_TYPES.Identifier && !callee.computed) {
+                // Normal property access: transaction.get()
+                methodName = property.name;
+            }
+            else if (callee.computed &&
+                property.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof property.value === 'string') {
+                // Computed property access with string literal: transaction['get']
+                methodName = property.value;
+            }
+            else if (callee.computed &&
+                property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Computed property access with variable: transaction[methodName]
+                // This is tricky to analyze statically. For now, we'll be conservative
+                // and assume it could be any method. We'll handle this in the caller.
+                return { isRead: true, isWrite: true, methodName: null }; // Could be either - let caller decide
+            }
+            if (!methodName) {
+                return { isRead: false, isWrite: false, methodName: null };
+            }
+            const isRead = READ_OPERATIONS.has(methodName);
+            const isWrite = WRITE_OPERATIONS.has(methodName);
+            return { isRead, isWrite, methodName };
+        }
+        return {
+            // Track transaction scopes from runTransaction calls
+            'CallExpression[callee.property.name="runTransaction"]'(node) {
+                const callback = node.arguments[0];
+                if (callback &&
+                    (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    const transactionParam = callback.params.find(isTransactionParameter);
+                    const transactionVariables = new Set();
+                    if (transactionParam &&
+                        transactionParam.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        transactionVariables.add(transactionParam.name);
+                    }
+                    transactionScopes.set(callback.body, {
+                        hasWriteOperation: false,
+                        writeNodes: [],
+                        transactionVariables,
+                    });
+                }
+            },
+            // Clean up transaction scopes when exiting runTransaction calls
+            'CallExpression[callee.property.name="runTransaction"]:exit'(node) {
+                const callback = node.arguments[0];
+                if (callback &&
+                    (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                        callback.type === utils_1.AST_NODE_TYPES.FunctionExpression)) {
+                    transactionScopes.delete(callback.body);
+                }
+            },
+            // Track variable assignments that reference the transaction
+            VariableDeclarator(node) {
+                if (node.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.init &&
+                    node.init.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const transactionScope = findTransactionScope(node);
+                    if (transactionScope) {
+                        const scopeInfo = transactionScopes.get(transactionScope);
+                        if (scopeInfo &&
+                            scopeInfo.transactionVariables.has(node.init.name)) {
+                            scopeInfo.transactionVariables.add(node.id.name);
+                        }
+                    }
+                }
+            },
+            // Check all call expressions for transaction operations
+            CallExpression(node) {
+                const transactionScope = findTransactionScope(node);
+                const { isRead, isWrite, methodName } = isTransactionMethodCall(node, transactionScope);
+                if (!isRead && !isWrite) {
+                    return;
+                }
+                if (!transactionScope) {
+                    return;
+                }
+                const scopeInfo = transactionScopes.get(transactionScope);
+                if (!scopeInfo) {
+                    return;
+                }
+                // Handle computed property access specially
+                if (isRead && isWrite) {
+                    // This is a computed property access - we need to be more careful
+                    // Only flag as a read if we already have writes in this scope
+                    if (scopeInfo.hasWriteOperation) {
+                        context.report({
+                            node,
+                            messageId: 'readsAfterWrites',
+                            data: { method: methodName ?? 'unknown' },
+                        });
+                    }
+                    // Don't mark as write since we don't know what method it is
+                    return;
+                }
+                // If it's a write operation, mark the scope as having a write
+                if (isWrite) {
+                    scopeInfo.hasWriteOperation = true;
+                    scopeInfo.writeNodes.push(node);
+                }
+                // If it's a read operation and the scope already has a write, report an error
+                if (isRead && scopeInfo.hasWriteOperation) {
+                    context.report({
+                        node,
+                        messageId: 'readsAfterWrites',
+                        data: { method: methodName ?? 'unknown' },
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=firestore-transaction-reads-before-writes.js.map

package/lib/rules/generic-starts-with-t.js

@@ -9,9 +9,15 @@ exports.genericStartsWithT = (0, createRule_1.createRule)({
                 for (const param of node.params) {
                     if (typeof param.name.name === 'string' &&
                         param.name.name[0] !== 'T') {
+                        const name = param.name.name;
+                        const suggestedName = `T${name}`;
                         context.report({
                             node: param,
                             messageId: 'genericStartsWithT',
+                            data: {
+                                name,
+                                suggestedName,
+                            },
                         });
                     }
                 }
@@ -22,12 +28,12 @@ exports.genericStartsWithT = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce TypeScript generic types to start with T',
+            description: 'Enforce TypeScript generic type parameters to start with T so they stand out from runtime values.',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            genericStartsWithT: 'Generic type parameter should start with T.',
+            genericStartsWithT: 'Generic type parameter "{{name}}" should start with "T" (e.g., "{{suggestedName}}") so readers immediately recognize it as a generic type rather than a concrete value. T-prefixed generics make type parameters stand out in signatures and prevent confusion with runtime parameters.',
         },
     },
     defaultOptions: [],

package/lib/rules/memoize-root-level-hocs.d.ts

@@ -0,0 +1,7 @@
+type Options = [
+    {
+        additionalHocNames?: string[];
+    }
+];
+export declare const memoizeRootLevelHocs: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"wrapHocInUseMemo", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};

package/lib/rules/memoize-root-level-hocs.js

@@ -0,0 +1,242 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.memoizeRootLevelHocs = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const defaultOptions = [{ additionalHocNames: [] }];
+const isFunctionNode = (node) => node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+    node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+    node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression;
+const isHookName = (name) => /^use[A-Z]/.test(name);
+const isComponentName = (name) => /^[A-Z]/.test(name);
+const forEachChildNode = (node, callback) => {
+    for (const key of Object.keys(node)) {
+        if (key === 'parent')
+            continue;
+        const value = node[key];
+        if (!value)
+            continue;
+        if (Array.isArray(value)) {
+            for (const child of value) {
+                if (child && typeof child.type === 'string') {
+                    if (callback(child)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        else if (value && typeof value.type === 'string') {
+            if (callback(value)) {
+                return true;
+            }
+        }
+    }
+    return false;
+};
+const getFunctionName = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && node.id) {
+        return node.id.name;
+    }
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionExpression ||
+        node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression) {
+        const parent = node.parent;
+        if (parent &&
+            parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+            parent.id.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return parent.id.name;
+        }
+        if (parent &&
+            parent.type === utils_1.AST_NODE_TYPES.Property &&
+            parent.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return parent.key.name;
+        }
+    }
+    return null;
+};
+const containsJsx = (node, options) => {
+    if (!node)
+        return false;
+    if (node.type === utils_1.AST_NODE_TYPES.JSXElement ||
+        node.type === utils_1.AST_NODE_TYPES.JSXFragment) {
+        return true;
+    }
+    return forEachChildNode(node, (child) => {
+        if (options?.skipFunctionBodies && isFunctionNode(child)) {
+            return false;
+        }
+        return containsJsx(child, options);
+    });
+};
+const hasFunctionParent = (node) => {
+    let current = node.parent;
+    while (current) {
+        if (isFunctionNode(current)) {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+};
+const getBodyNodeForJsxCheck = (node) => {
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration ||
+        node.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+        return node.body;
+    }
+    if (node.body && node.body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
+        return node.body;
+    }
+    return node.body;
+};
+const isComponentOrHook = (node) => {
+    const name = getFunctionName(node);
+    const hook = name ? isHookName(name) : false;
+    const component = name ? isComponentName(name) : false;
+    const nestedFunction = hasFunctionParent(node);
+    const jsxBody = containsJsx(getBodyNodeForJsxCheck(node), {
+        skipFunctionBodies: !hook && !component,
+    });
+    if (!hook && !component && nestedFunction) {
+        return null;
+    }
+    if (!hook && !component && !jsxBody) {
+        return null;
+    }
+    if (hook) {
+        return { contextLabel: `hook${name ? ` ${name}` : ''}` };
+    }
+    return { contextLabel: `component${name ? ` ${name}` : ''}` };
+};
+const getCallableIdentifierName = (callee) => {
+    const maybeChain = callee;
+    if (maybeChain.type === utils_1.AST_NODE_TYPES.ChainExpression) {
+        return getCallableIdentifierName(maybeChain.expression);
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.name;
+    }
+    if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return callee.property.name;
+    }
+    return null;
+};
+const isHocIdentifier = (name, additionalHocs) => {
+    if (additionalHocs.has(name)) {
+        return true;
+    }
+    if (!name.startsWith('with')) {
+        return false;
+    }
+    const suffix = name.charAt(4);
+    return Boolean(suffix) && /^[A-Z]$/.test(suffix);
+};
+const findHocName = (node, additionalHocs) => {
+    const identifier = getCallableIdentifierName(node.callee);
+    if (identifier && isHocIdentifier(identifier, additionalHocs)) {
+        return identifier;
+    }
+    if (node.callee.type === utils_1.AST_NODE_TYPES.CallExpression) {
+        return findHocName(node.callee, additionalHocs);
+    }
+    return null;
+};
+/**
+ * Detects chained HOC calls where an inner call is immediately invoked by
+ * another call (for example, withHoc(Component)()). We only treat calls as
+ * part of the same chain when the current CallExpression is the callee of its
+ * parent and both resolve to the same HOC name, which prevents duplicate
+ * reports for patterns like withHoc(Component)(props).
+ */
+const getParentCallExpression = (callExpr) => callExpr.parent &&
+    callExpr.parent.type === utils_1.AST_NODE_TYPES.CallExpression &&
+    callExpr.parent.callee === callExpr
+    ? callExpr.parent
+    : null;
+const isPartOfHocChain = (hocName, parentHocName) => Boolean(parentHocName && parentHocName === hocName);
+exports.memoizeRootLevelHocs = (0, createRule_1.createRule)({
+    name: 'memoize-root-level-hocs',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent creating Higher-Order Components at the root level of React components/hooks without wrapping them in useMemo to keep wrapped component identities stable across renders.',
+            recommended: 'error',
+        },
+        fixable: undefined,
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    additionalHocNames: {
+                        type: 'array',
+                        items: { type: 'string' },
+                        default: [],
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            wrapHocInUseMemo: 'HOC "{{hocName}}" is created inside {{contextLabel}} during render, so every render creates a brand-new wrapped component reference. React treats that as a different component, unmounting/remounting it (resetting internal state) and forcing children to re-render even when props stay the same. Wrap the HOC creation in useMemo with the correct dependencies or hoist it outside the {{contextLabel}} so the wrapped component identity stays stable.',
+        },
+    },
+    defaultOptions,
+    create(context, [options]) {
+        const additionalHocs = new Set(options?.additionalHocNames ?? []);
+        const reportUnmemoizedHoc = (node, hocName, contextInfo) => {
+            context.report({
+                node,
+                messageId: 'wrapHocInUseMemo',
+                data: {
+                    hocName,
+                    contextLabel: contextInfo.contextLabel,
+                },
+            });
+        };
+        const checkHocCall = (callExpr, contextInfo) => {
+            const hocName = findHocName(callExpr, additionalHocs);
+            const parentCall = getParentCallExpression(callExpr);
+            const parentHocName = parentCall && findHocName(parentCall, additionalHocs);
+            if (hocName && !isPartOfHocChain(hocName, parentHocName)) {
+                reportUnmemoizedHoc(callExpr, hocName, contextInfo);
+            }
+        };
+        const traverseFunctionBody = (node, contextInfo) => {
+            const visitNode = (current) => {
+                if (isFunctionNode(current) && current !== node) {
+                    return;
+                }
+                if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    checkHocCall(current, contextInfo);
+                }
+                forEachChildNode(current, (child) => {
+                    visitNode(child);
+                    return false;
+                });
+            };
+            if (!node.body) {
+                return;
+            }
+            if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement) {
+                for (const statement of node.body.body) {
+                    visitNode(statement);
+                }
+                return;
+            }
+            visitNode(node.body);
+        };
+        const analyzeFunction = (node) => {
+            const contextInfo = isComponentOrHook(node);
+            if (!contextInfo) {
+                return;
+            }
+            traverseFunctionBody(node, contextInfo);
+        };
+        return {
+            FunctionDeclaration: analyzeFunction,
+            FunctionExpression: analyzeFunction,
+            ArrowFunctionExpression: analyzeFunction,
+        };
+    },
+});
+//# sourceMappingURL=memoize-root-level-hocs.js.map

package/lib/rules/no-array-length-in-deps.d.ts

@@ -0,0 +1,12 @@
+import { TSESLint } from '@typescript-eslint/utils';
+export type MessageIds = 'noArrayLengthInDeps';
+type Options = [
+    {
+        hashImport?: {
+            source?: string;
+            importName?: string;
+        };
+    }?
+];
+export declare const noArrayLengthInDeps: TSESLint.RuleModule<"noArrayLengthInDeps", Options, TSESLint.RuleListener>;
+export {};