@blumintinc/eslint-plugin-blumint 1.5.4 → 1.6.0

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

@@ -87,12 +87,31 @@ function isInterfaceOrAbstractMethodSignature(node) {
     }
     return false;
 }
+function isTypeGuardFunction(node) {
+    if (!('returnType' in node) || !node.returnType)
+        return false;
+    const returnType = node.returnType;
+    if (returnType.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
+        return false;
+    const typeAnnotation = returnType.typeAnnotation;
+    // 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',
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript\'s powerful type inference. Exceptions are made for recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.',
+            description: 'Disallow explicit return type annotations on functions when TypeScript can infer them. This reduces code verbosity and maintenance burden while leveraging TypeScript\'s powerful type inference. Exceptions are made for type guard functions (using the `is` keyword), recursive functions, overloaded functions, interface methods, and abstract methods where explicit types improve clarity.',
             recommended: 'error',
             requiresTypeChecking: false,
             extendsBaseRule: false,
@@ -136,8 +155,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             FunctionDeclaration(node) {
                 if (!node.returnType)
                     return;
-                if (mergedOptions.allowRecursiveFunctions &&
-                    isRecursiveFunction(node)) {
+                if (isTypeGuardFunction(node) ||
+                    (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node))) {
                     return;
                 }
                 context.report({
@@ -149,8 +168,8 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             FunctionExpression(node) {
                 if (!node.returnType)
                     return;
-                if (mergedOptions.allowRecursiveFunctions &&
-                    isRecursiveFunction(node)) {
+                if (isTypeGuardFunction(node) ||
+                    (mergedOptions.allowRecursiveFunctions && isRecursiveFunction(node))) {
                     return;
                 }
                 context.report({
@@ -162,6 +181,9 @@ exports.noExplicitReturnType = (0, createRule_1.createRule)({
             ArrowFunctionExpression(node) {
                 if (!node.returnType)
                     return;
+                if (isTypeGuardFunction(node)) {
+                    return;
+                }
                 context.report({
                     node: node.returnType,
                     messageId: 'noExplicitReturnType',

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>;

package/lib/rules/no-mixed-firestore-transactions.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noMixedFirestoreTransactions = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const NON_TRANSACTIONAL_CLASSES = new Set([
+    'DocSetter',
+    'FirestoreDocFetcher',
+    'FirestoreFetcher',
+]);
+exports.noMixedFirestoreTransactions = (0, createRule_1.createRule)({
+    name: 'no-mixed-firestore-transactions',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Prevent mixing transactional and non-transactional Firestore operations within a transaction',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            noMixedTransactions: 'Do not use non-transactional Firestore operations ({{ className }}) inside a transaction. Use {{ transactionalClass }} instead.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const transactionScopes = new Set();
+        function getTransactionalClassName(className) {
+            if (className === 'DocSetter')
+                return 'DocSetterTransaction';
+            if (className === 'FirestoreDocFetcher')
+                return 'FirestoreDocFetcherTransaction';
+            if (className === 'FirestoreFetcher')
+                return 'FirestoreFetcherTransaction';
+            return className;
+        }
+        function isFirestoreTransaction(node) {
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.MemberExpression)
+                return false;
+            const property = callee.property;
+            return property.type === utils_1.AST_NODE_TYPES.Identifier && property.name === 'runTransaction';
+        }
+        function isNonTransactionalClass(node) {
+            const callee = node.callee;
+            if (callee.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            return NON_TRANSACTIONAL_CLASSES.has(callee.name);
+        }
+        function isTransactionParameter(param) {
+            if (param.type !== utils_1.AST_NODE_TYPES.Identifier)
+                return false;
+            const typeAnnotation = param.typeAnnotation;
+            if (!typeAnnotation || typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeAnnotation)
+                return false;
+            const type = typeAnnotation.typeAnnotation;
+            if (type.type !== utils_1.AST_NODE_TYPES.TSTypeReference)
+                return false;
+            const typeName = type.typeName;
+            if (typeName.type !== utils_1.AST_NODE_TYPES.TSQualifiedName)
+                return false;
+            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';
+        }
+        function isInTransactionScope(node) {
+            let current = node;
+            while (current) {
+                if (transactionScopes.has(current)) {
+                    return true;
+                }
+                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)) {
+                        return true;
+                    }
+                }
+                current = current.parent;
+            }
+            return false;
+        }
+        return {
+            'CallExpression[callee.property.name="runTransaction"]'(node) {
+                if (!isFirestoreTransaction(node))
+                    return;
+                const callback = node.arguments[0];
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    transactionScopes.add(callback.body);
+                }
+            },
+            'CallExpression[callee.property.name="runTransaction"]:exit'(node) {
+                const callback = node.arguments[0];
+                if (callback.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression ||
+                    callback.type === utils_1.AST_NODE_TYPES.FunctionExpression) {
+                    transactionScopes.delete(callback.body);
+                }
+            },
+            NewExpression(node) {
+                if (!isInTransactionScope(node) || !isNonTransactionalClass(node))
+                    return;
+                const className = node.callee.name;
+                context.report({
+                    node,
+                    messageId: 'noMixedTransactions',
+                    data: {
+                        className,
+                        transactionalClass: getTransactionalClassName(className),
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=no-mixed-firestore-transactions.js.map

package/lib/rules/no-unused-props.js

@@ -39,9 +39,35 @@ exports.noUnusedProps = (0, createRule_1.createRule)({
                             typeNode.types.forEach(extractProps);
                         }
                         else if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
-                            // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
                             if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                                props[`...${typeNode.typeName.name}`] = typeNode.typeName;
+                                if (typeNode.typeName.name === 'Pick' && typeNode.typeParameters) {
+                                    // Handle Pick utility type
+                                    const [baseType, pickedProps] = typeNode.typeParameters.params;
+                                    if (baseType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                                        baseType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                                        // Extract the picked properties from the union type
+                                        if (pickedProps.type === utils_1.AST_NODE_TYPES.TSUnionType) {
+                                            pickedProps.types.forEach((type) => {
+                                                if (type.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                                    type.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                                    typeof type.literal.value === 'string') {
+                                                    // Add each picked property as a regular prop
+                                                    props[type.literal.value] = type.literal;
+                                                }
+                                            });
+                                        }
+                                        else if (pickedProps.type === utils_1.AST_NODE_TYPES.TSLiteralType &&
+                                            pickedProps.literal.type === utils_1.AST_NODE_TYPES.Literal &&
+                                            typeof pickedProps.literal.value === 'string') {
+                                            // Single property pick
+                                            props[pickedProps.literal.value] = pickedProps.literal;
+                                        }
+                                    }
+                                }
+                                else {
+                                    // For referenced types like FormControlLabelProps, we need to track that these props should be forwarded
+                                    props[`...${typeNode.typeName.name}`] = typeNode.typeName;
+                                }
                             }
                         }
                     }

package/lib/rules/prefer-batch-operations.d.ts

@@ -0,0 +1,3 @@
+type MessageIds = 'preferSetAll' | 'preferOverwriteAll';
+export declare const preferBatchOperations: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};