@blumintinc/eslint-plugin-blumint 1.5.5 → 1.7.0

package/lib/rules/enforce-firestore-set-merge.js

@@ -41,8 +41,80 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                             }
                         }
                     }
-                    // Only flag update() calls
-                    return property.name === 'update';
+                    // Only flag update() calls that are Firestore operations
+                    if (property.name === 'update') {
+                        const object = node.callee.object;
+                        // Check for BatchManager update calls
+                        if (object.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                            object.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            object.property.name === 'batchManager') {
+                            return true;
+                        }
+                        if (object.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                            // Check if it's a createHash().update() call
+                            if (object.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                                object.callee.name === 'createHash') {
+                                return false;
+                            }
+                        }
+                        // Check if it's a Firestore document reference or transaction
+                        let current = node;
+                        while (current?.parent) {
+                            current = current.parent;
+                            if (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                                const obj = current.object;
+                                if (obj.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    // Check for common Firestore variable names
+                                    if (obj.name === 'db' ||
+                                        obj.name === 'firestore' ||
+                                        obj.name === 'transaction' ||
+                                        obj.name === 'docRef' ||
+                                        obj.name === 'userRef' ||
+                                        obj.name.endsWith('Ref')) {
+                                        return true;
+                                    }
+                                }
+                            }
+                        }
+                        // Check if it's a Firestore document reference method chain
+                        let currentObj = object;
+                        while (currentObj.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                            if (currentObj.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                const methodName = currentObj.property.name;
+                                if (methodName === 'collection' || methodName === 'doc') {
+                                    return true;
+                                }
+                            }
+                            currentObj = currentObj.object;
+                        }
+                        // Check if it's a transaction.update() call
+                        if (object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            object.name === 'transaction') {
+                            return true;
+                        }
+                        // Check if it's a Firestore document reference by looking at imports
+                        const program = context
+                            .getAncestors()
+                            .find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
+                        if (program) {
+                            for (const node of program.body) {
+                                if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+                                    for (const decl of node.declarations) {
+                                        if (decl.init?.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                                            decl.init.callee.type ===
+                                                utils_1.AST_NODE_TYPES.MemberExpression &&
+                                            decl.init.callee.property.type ===
+                                                utils_1.AST_NODE_TYPES.Identifier &&
+                                            decl.init.callee.property.name === 'firestore') {
+                                            return true;
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                        return false;
+                    }
+                    return false;
                 }
             }
             if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
@@ -75,6 +147,15 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                     const data = sourceCode.getText(args[1]);
                     return `${object}.set(${docRef}, ${data}, { merge: true })`;
                 }
+                if (object.includes('batchManager')) {
+                    const docRef = sourceCode.getText(args[0]);
+                    const data = sourceCode.getText(args[1]);
+                    return `${object}.set({
+          ref: ${docRef},
+          data: ${data},
+          merge: true,
+        })`;
+                }
                 const data = sourceCode.getText(args[0]);
                 return `${object}.set(${data}, { merge: true })`;
             }

package/lib/rules/enforce-verb-noun-naming.js

@@ -69,6 +69,7 @@ const VERBS_SET = new Set([
     'auto',
     'avoid',
     'back',
+    'backfill',
     'backup',
     'bake',
     'balance',
@@ -432,6 +433,7 @@ const VERBS_SET = new Set([
     'include',
     'includes',
     'increase',
+    'increment',
     'index',
     'influence',
     'inform',

package/lib/rules/no-complex-cloud-params.d.ts

@@ -0,0 +1 @@
+export declare const noComplexCloudParams: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noComplexObjects", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-complex-cloud-params.js

@@ -0,0 +1,363 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noComplexCloudParams = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noComplexCloudParams = (0, createRule_1.createRule)({
+    name: 'no-complex-cloud-params',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Disallow passing complex objects to cloud functions',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noComplexObjects: 'Do not pass complex objects to cloud functions. Complex objects include class instances, objects with methods, non-serializable values (RegExp, BigInt, TypedArray, etc.), or objects with nested complex properties.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Track imported cloud functions
+        const cloudFunctions = new Set();
+        // Track objects to detect circular references
+        const objectsInPath = new Set();
+        // Track nodes that have already been reported
+        const reportedNodes = new Set();
+        function isFunction(node) {
+            return [
+                utils_1.AST_NODE_TYPES.FunctionExpression,
+                utils_1.AST_NODE_TYPES.ArrowFunctionExpression,
+                utils_1.AST_NODE_TYPES.MethodDefinition,
+            ].includes(node.type);
+        }
+        function isMethod(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+                return true;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.Property) {
+                // Check for methods, getters, setters
+                if (node.method || node.kind === 'get' || node.kind === 'set') {
+                    return true;
+                }
+                // Check if the value is a function
+                if (node.value && isFunction(node.value)) {
+                    return true;
+                }
+                // Check for bound functions
+                if (node.value &&
+                    node.value.type === utils_1.AST_NODE_TYPES.CallExpression &&
+                    node.value.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.value.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.value.callee.property.name === 'bind') {
+                    return true;
+                }
+                // Check for generator methods
+                if (node.value &&
+                    node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression &&
+                    node.value.generator) {
+                    return true;
+                }
+                // Check for async methods
+                if (node.value &&
+                    node.value.type === utils_1.AST_NODE_TYPES.FunctionExpression &&
+                    node.value.async) {
+                    return true;
+                }
+            }
+            return false;
+        }
+        function isClassInstance(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.NewExpression) {
+                // Check for known non-serializable constructors
+                if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const nonSerializableTypes = new Set([
+                        'RegExp',
+                        'BigInt',
+                        'Int8Array',
+                        'Uint8Array',
+                        'Uint8ClampedArray',
+                        'Int16Array',
+                        'Uint16Array',
+                        'Int32Array',
+                        'Uint32Array',
+                        'Float32Array',
+                        'Float64Array',
+                        'BigInt64Array',
+                        'BigUint64Array',
+                        'WeakMap',
+                        'WeakSet',
+                        'Promise',
+                        'Error',
+                        'Proxy',
+                        'Map',
+                        'Set',
+                        'ArrayBuffer',
+                        'SharedArrayBuffer',
+                        'DataView',
+                    ]);
+                    if (nonSerializableTypes.has(node.callee.name)) {
+                        return true;
+                    }
+                    // Allow Date objects as they are serializable
+                    if (node.callee.name === 'Date') {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                // Try to find the variable declaration
+                const scope = context.getScope();
+                const variable = scope.variables.find((v) => v.name === node.name);
+                if (variable && variable.defs.length > 0) {
+                    const def = variable.defs[0];
+                    if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                        def.node.init) {
+                        return isClassInstance(def.node.init);
+                    }
+                }
+                // Check if the identifier starts with a capital letter (potential class instance)
+                return node.name[0] === node.name[0].toUpperCase();
+            }
+            return false;
+        }
+        function isNonSerializableLiteral(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.Literal) {
+                // Check for RegExp literal
+                if ('regex' in node && node.regex) {
+                    return true;
+                }
+                // Check for BigInt literal
+                if ('bigint' in node && node.bigint) {
+                    return true;
+                }
+                return false;
+            }
+            // Check for RegExp constructor or literal
+            if ((node.type === utils_1.AST_NODE_TYPES.NewExpression ||
+                node.type === utils_1.AST_NODE_TYPES.CallExpression) &&
+                node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'RegExp') {
+                return true;
+            }
+            // Check for BigInt constructor or function
+            if ((node.type === utils_1.AST_NODE_TYPES.CallExpression ||
+                node.type === utils_1.AST_NODE_TYPES.NewExpression) &&
+                node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.callee.name === 'BigInt') {
+                return true;
+            }
+            return false;
+        }
+        function isComplexValue(node) {
+            // Prevent infinite recursion with circular references
+            if (objectsInPath.has(node)) {
+                return true;
+            }
+            objectsInPath.add(node);
+            try {
+                // Check for function expressions
+                if (isFunction(node)) {
+                    return true;
+                }
+                // Check for class instances
+                if (isClassInstance(node)) {
+                    return true;
+                }
+                // Check for non-serializable literals
+                if (isNonSerializableLiteral(node)) {
+                    return true;
+                }
+                // Check for method calls that could create complex objects
+                if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    // Allow JSON.stringify
+                    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.callee.object.name === 'JSON' &&
+                        node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.callee.property.name === 'stringify') {
+                        return false;
+                    }
+                    // Allow Object.create(null)
+                    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.callee.object.name === 'Object' &&
+                        node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.callee.property.name === 'create') {
+                        // Only allow Object.create(null), check if the prototype object is complex
+                        if (node.arguments.length === 1) {
+                            if (node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
+                                node.arguments[0].value === null) {
+                                return false;
+                            }
+                            return isComplexValue(node.arguments[0]);
+                        }
+                        return true;
+                    }
+                    // Check for function binding
+                    if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                        node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.callee.property.name === 'bind') {
+                        return true;
+                    }
+                    return isComplexValue(node.callee);
+                }
+                // Check for arrays
+                if (node.type === utils_1.AST_NODE_TYPES.ArrayExpression) {
+                    return node.elements.some((element) => element !== null && isComplexValue(element));
+                }
+                // Check for objects
+                if (node.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    return node.properties.some((prop) => {
+                        if (prop.type === utils_1.AST_NODE_TYPES.Property) {
+                            // Check for computed properties (including Symbols)
+                            if (prop.computed) {
+                                return true;
+                            }
+                            // Check for methods, getters, and setters
+                            if (isMethod(prop)) {
+                                return true;
+                            }
+                            // Check property value
+                            return isComplexValue(prop.value);
+                        }
+                        // SpreadElement or other non-Property types are considered complex
+                        return true;
+                    });
+                }
+                // Check for member expressions that might be complex
+                if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                    // Check for prototype chain access
+                    if (node.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        (node.property.name === 'prototype' ||
+                            node.property.name === '__proto__')) {
+                        return true;
+                    }
+                    // Check for Symbol properties
+                    if (node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        node.object.name === 'Symbol') {
+                        return true;
+                    }
+                    // Check for WeakMap, WeakSet, Promise, Error constructors
+                    if (node.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                        ['WeakMap', 'WeakSet', 'Promise', 'Error'].includes(node.object.name)) {
+                        return true;
+                    }
+                    // Check for circular references in member expressions
+                    return isComplexValue(node.object) || isComplexValue(node.property);
+                }
+                // Check for Symbols
+                if (node.type === utils_1.AST_NODE_TYPES.Identifier && node.name === 'Symbol') {
+                    return true;
+                }
+                // Check for object references that might be circular
+                if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
+                    const scope = context.getScope();
+                    const variable = scope.variables.find((v) => v.name === node.name);
+                    if (variable && variable.references.length > 0) {
+                        // Check if this identifier is used in a way that creates a circular reference
+                        const isCircular = variable.references.some((ref) => {
+                            const refParent = ref.identifier.parent;
+                            if (refParent) {
+                                // Check for direct assignment
+                                if (refParent.type === utils_1.AST_NODE_TYPES.AssignmentExpression) {
+                                    if (refParent.right === ref.identifier) {
+                                        // The identifier is being assigned to a property of itself
+                                        let current = refParent.parent;
+                                        while (current) {
+                                            if (current === node) {
+                                                return true;
+                                            }
+                                            current = current.parent;
+                                        }
+                                    }
+                                }
+                                // Check for property assignment
+                                if (refParent.type === utils_1.AST_NODE_TYPES.Property) {
+                                    let current = refParent.parent;
+                                    while (current) {
+                                        if (current === node) {
+                                            return true;
+                                        }
+                                        current = current.parent;
+                                    }
+                                }
+                            }
+                            return false;
+                        });
+                        if (isCircular) {
+                            return true;
+                        }
+                        // Check the value the identifier refers to
+                        if (variable.defs.length > 0) {
+                            const def = variable.defs[0];
+                            if (def.node.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                                def.node.init) {
+                                return isComplexValue(def.node.init);
+                            }
+                        }
+                    }
+                }
+                return false;
+            }
+            finally {
+                objectsInPath.delete(node);
+            }
+        }
+        function hasComplexProperties(node) {
+            return isComplexValue(node);
+        }
+        function checkCloudFunctionCall(node) {
+            if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                cloudFunctions.has(node.callee.name)) {
+                // Check each argument for complex objects
+                node.arguments.forEach((arg) => {
+                    if (hasComplexProperties(arg) && !reportedNodes.has(node)) {
+                        reportedNodes.add(node);
+                        context.report({
+                            node,
+                            messageId: 'noComplexObjects',
+                        });
+                    }
+                });
+            }
+        }
+        return {
+            // Track cloud function imports
+            ImportExpression(node) {
+                if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof node.source.value === 'string' &&
+                    node.source.value.includes('firebaseCloud')) {
+                    // Find the variable declarator that contains this import
+                    let parent = node.parent;
+                    while (parent && parent.type !== utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                        parent = parent.parent;
+                    }
+                    if (parent && parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+                        // Handle destructuring pattern
+                        if (parent.id.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                            parent.id.properties.forEach((prop) => {
+                                if (prop.type === utils_1.AST_NODE_TYPES.Property &&
+                                    prop.value.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                    cloudFunctions.add(prop.value.name);
+                                }
+                            });
+                        }
+                    }
+                }
+            },
+            // Check for complex objects in cloud function calls
+            CallExpression(node) {
+                checkCloudFunctionCall(node);
+            },
+            // Check for await expressions with cloud function calls
+            AwaitExpression(node) {
+                if (node.argument.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                    checkCloudFunctionCall(node.argument);
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-complex-cloud-params.js.map

package/lib/rules/no-explicit-return-type.js

@@ -94,9 +94,17 @@ function isTypeGuardFunction(node) {
     if (returnType.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
         return false;
     const typeAnnotation = returnType.typeAnnotation;
-    if (typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypePredicate)
-        return false;
-    return true;
+    // Check for type predicates (is keyword)
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypePredicate)
+        return true;
+    // Check for assertion functions (asserts keyword)
+    if (typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        const typeName = typeAnnotation.typeName;
+        if (typeName.type === utils_1.AST_NODE_TYPES.Identifier && typeName.name === 'asserts') {
+            return true;
+        }
+    }
+    return false;
 }
 exports.noExplicitReturnType = (0, createRule_1.createRule)({
     name: 'no-explicit-return-type',

package/lib/rules/no-firestore-jest-mock.d.ts

@@ -0,0 +1 @@
+export declare const noFirestoreJestMock: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noFirestoreJestMock", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;

package/lib/rules/no-firestore-jest-mock.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noFirestoreJestMock = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+exports.noFirestoreJestMock = (0, createRule_1.createRule)({
+    name: 'no-firestore-jest-mock',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent importing firestore-jest-mock in test files',
+            recommended: 'error',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            noFirestoreJestMock: 'Do not import from firestore-jest-mock. Use mockFirestore from the centralized mock utility instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const filename = context.getFilename();
+        // Only apply rule to test files
+        if (!filename.endsWith('.test.ts')) {
+            return {};
+        }
+        return {
+            ImportDeclaration(node) {
+                if (node.source.value === 'firestore-jest-mock') {
+                    context.report({
+                        node,
+                        messageId: 'noFirestoreJestMock',
+                        fix(fixer) {
+                            // Replace with mockFirestore import
+                            return fixer.replaceText(node, "import { mockFirestore } from '../../../../../__mocks__/functions/src/config/mockFirestore';");
+                        },
+                    });
+                }
+            },
+            CallExpression(node) {
+                // Check for jest.mock('firestore-jest-mock')
+                if (node.callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                    node.callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.object.name === 'jest' &&
+                    node.callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    node.callee.property.name === 'mock' &&
+                    node.arguments.length > 0 &&
+                    node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
+                    node.arguments[0].value === 'firestore-jest-mock') {
+                    context.report({
+                        node,
+                        messageId: 'noFirestoreJestMock',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-firestore-jest-mock.js.map

package/lib/rules/no-mixed-firestore-transactions.d.ts

@@ -0,0 +1 @@
+export declare const noMixedFirestoreTransactions: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"noMixedTransactions", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;