@blumintinc/eslint-plugin-blumint 1.3.0 → 1.3.1

package/lib/index.js

@@ -43,7 +43,7 @@ const enforce_mock_firestore_1 = require("./rules/enforce-mock-firestore");
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.3.0',
+        version: '1.3.1',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-firestore-doc-ref-generic.d.ts

@@ -1,5 +1,5 @@
 /**
- * @fileoverview Enforce generic argument for Firestore DocumentReference
+ * @fileoverview Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup
  * @author BluMint
  */
 type MessageIds = 'missingGeneric' | 'invalidGeneric';

package/lib/rules/enforce-firestore-doc-ref-generic.js

@@ -1,6 +1,6 @@
 "use strict";
 /**
- * @fileoverview Enforce generic argument for Firestore DocumentReference
+ * @fileoverview Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup
  * @author BluMint
  */
 Object.defineProperty(exports, "__esModule", { value: true });
@@ -18,14 +18,14 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce generic argument for Firestore DocumentReference',
+            description: 'Enforce generic argument for Firestore DocumentReference, CollectionReference and CollectionGroup',
             recommended: 'error',
             requiresTypeChecking: true,
         },
         schema: [],
         messages: {
-            missingGeneric: 'DocumentReference must specify a generic type argument',
-            invalidGeneric: 'DocumentReference must not use "any" or "{}" as generic type argument',
+            missingGeneric: '{{ type }} must specify a generic type argument',
+            invalidGeneric: '{{ type }} must not use "any" or "{}" as generic type argument',
         },
     },
     defaultOptions: [],
@@ -109,12 +109,16 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
         return {
             TSTypeReference(node) {
                 if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    node.typeName.name === 'DocumentReference') {
+                    (node.typeName.name === 'DocumentReference' ||
+                        node.typeName.name === 'CollectionReference' ||
+                        node.typeName.name === 'CollectionGroup')) {
+                    const typeName = node.typeName.name;
                     // Check if generic type argument is missing
                     if (!node.typeParameters || node.typeParameters.params.length === 0) {
                         context.report({
                             node,
                             messageId: 'missingGeneric',
+                            data: { type: typeName }
                         });
                         return;
                     }
@@ -124,6 +128,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'invalidGeneric',
+                            data: { type: typeName }
                         });
                     }
                 }

package/lib/rules/no-entire-object-hook-deps.js

@@ -42,22 +42,31 @@ function isArrayOrPrimitive(checker, esTreeNode, nodeMap) {
 function getObjectUsagesInHook(hookBody, objectName) {
     const usages = new Set();
     const visited = new Set();
+    let needsEntireObject = false;
     function buildAccessPath(node) {
         const parts = [];
         let current = node;
+        let hasOptionalChaining = false;
+        // Collect all parts from leaf to root
         while (current.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-            if (current.computed) {
+            const memberExpr = current;
+            if (memberExpr.computed) {
                 return null; // Skip computed properties
             }
-            if (current.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
+            if (memberExpr.property.type !== utils_1.AST_NODE_TYPES.Identifier) {
                 return null;
             }
-            parts.unshift(current.property.name);
-            current = current.object;
+            parts.unshift(memberExpr.property.name);
+            if (memberExpr.optional) {
+                hasOptionalChaining = true;
+            }
+            current = memberExpr.object;
         }
-        if (current.type === utils_1.AST_NODE_TYPES.Identifier &&
-            current.name === objectName) {
-            return parts.join('.');
+        // Check if we reached the target identifier
+        if (current.type === utils_1.AST_NODE_TYPES.Identifier && current.name === objectName) {
+            // Build the path with optional chaining
+            const path = objectName + (hasOptionalChaining ? '?' : '') + parts.map(part => '.' + part).join('');
+            return path;
         }
         return null;
     }
@@ -65,10 +74,27 @@ function getObjectUsagesInHook(hookBody, objectName) {
         if (visited.has(node))
             return;
         visited.add(node);
-        if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+        if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            // Check if the object is directly passed as an argument
+            node.arguments.forEach((arg) => {
+                if (arg.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    arg.name === objectName) {
+                    needsEntireObject = true;
+                }
+            });
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+            // If we find a spread operator with our target object, consider it as accessing all properties
+            if (node.argument.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.argument.name === objectName) {
+                needsEntireObject = true;
+                return;
+            }
+        }
+        else if (node.type === utils_1.AST_NODE_TYPES.MemberExpression) {
             const path = buildAccessPath(node);
             if (path) {
-                usages.add(`${objectName}.${path}`);
+                usages.add(path);
             }
         }
         // Visit all child nodes
@@ -90,6 +116,10 @@ function getObjectUsagesInHook(hookBody, objectName) {
         }
     }
     visit(hookBody);
+    // If the entire object is needed, return an empty set to indicate valid usage
+    if (needsEntireObject) {
+        return new Set();
+    }
     // Filter out intermediate paths
     const paths = Array.from(usages);
     const filteredPaths = paths.filter((path) => !paths.some((otherPath) => otherPath !== path && otherPath.startsWith(path + '.')));
@@ -145,6 +175,7 @@ exports.noEntireObjectHookDeps = (0, createRule_1.createRule)({
                         }
                         const usages = getObjectUsagesInHook(callbackArg.body, objectName);
                         // If we found specific field usages and the entire object is in deps
+                        // Skip reporting if usages is empty (indicates spread operator usage)
                         if (usages.size > 0) {
                             const fields = Array.from(usages).join(', ');
                             context.report({

package/lib/rules/require-https-error.js

@@ -22,23 +22,32 @@ module.exports = (0, createRule_1.createRule)({
         if (!filename.includes('functions/src')) {
             return {};
         }
-        let hasFirebaseAdminImport = false;
         let httpsIdentifier = null;
+        let httpsErrorIdentifier = null;
         return {
             ImportDeclaration(node) {
                 if (node.source.value === 'firebase-admin' ||
                     node.source.value === 'firebase-admin/lib/https-error') {
-                    hasFirebaseAdminImport = true;
-                    // Track the local name of the https import
+                    // Check for direct HttpsError import
+                    const httpsErrorSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                        spec.imported.name === 'HttpsError');
+                    // Check for https import that could be used for https.HttpsError
                     const httpsSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         spec.imported.name === 'https');
+                    if (httpsErrorSpecifier && 'local' in httpsErrorSpecifier) {
+                        httpsErrorIdentifier = httpsErrorSpecifier.local.name;
+                        context.report({
+                            node,
+                            messageId: 'useProprietaryHttpsError',
+                        });
+                    }
                     if (httpsSpecifier && 'local' in httpsSpecifier) {
                         httpsIdentifier = httpsSpecifier.local.name;
+                        context.report({
+                            node,
+                            messageId: 'useProprietaryHttpsError',
+                        });
                     }
-                    context.report({
-                        node,
-                        messageId: 'useProprietaryHttpsError',
-                    });
                 }
             },
             ThrowStatement(node) {
@@ -60,17 +69,14 @@ module.exports = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check for firebase-admin HttpsError usage
-                if (!hasFirebaseAdminImport) {
-                    return;
-                }
-                const isHttpsError = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    callee.name === 'HttpsError';
                 const isFirebaseHttpsError = callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
                     callee.object.type === utils_1.AST_NODE_TYPES.Identifier &&
                     callee.object.name === httpsIdentifier &&
                     callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
                     callee.property.name === 'HttpsError';
-                if (isHttpsError || isFirebaseHttpsError) {
+                const isDirectHttpsError = callee.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    callee.name === httpsErrorIdentifier;
+                if (isFirebaseHttpsError || isDirectHttpsError) {
                     context.report({
                         node,
                         messageId: 'useProprietaryHttpsError',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blumintinc/eslint-plugin-blumint",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "Custom eslint rules for use within BluMint",
   "author": {
     "name": "Brodie McGuire",