@blumintinc/eslint-plugin-blumint 1.20.77 → 1.20.79

package/lib/index.js

@@ -223,7 +223,7 @@ function noFrontendImportsFromFunctionsPatterns(pattern) {
 module.exports = {
     meta: {
         name: '@blumintinc/eslint-plugin-blumint',
-        version: '1.20.77',
+        version: '1.20.79',
     },
     parseOptions: {
         ecmaVersion: 2020,

package/lib/rules/enforce-firestore-path-utils.js

@@ -14,12 +14,17 @@ exports.enforceFirestorePathUtils = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            requirePathUtil: 'Use a utility function for Firestore paths to ensure type safety and maintainability. Instead of `doc("users/" + userId)`, create and use a utility function: `const toUserPath = (id: string) => `users/${id}`; doc(toUserPath(userId))`.',
+            requirePathUtil: 'Use a utility function for Firestore paths to ensure type safety and maintainability. Instead of `db.doc("users/" + userId)`, create and use a utility function: `const toUserPath = (id: string) => `users/${id}`; db.doc(toUserPath(userId))`.',
         },
     },
     defaultOptions: [],
     create(context) {
         function isFirestoreCall(node) {
+            // Requiring an explicit receiver keeps unrelated `doc(...)`/`collection(...)`
+            // calls out of scope, at the cost of not covering the modular SDK, whose
+            // path sits in the second argument. The requirePathUtil example is written
+            // with a receiver for the same reason: a bare call is never reportable, so
+            // an example without one points at code this rule does not govern.
             if (node.callee.type !== utils_1.AST_NODE_TYPES.MemberExpression) {
                 return false;
             }
@@ -34,6 +39,24 @@ exports.enforceFirestorePathUtils = (0, createRule_1.createRule)({
                 typeof node.value === 'string') ||
                 node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
+        /**
+         * A `+` chain qualifies as an inline path only when a string literal or
+         * template literal appears somewhere in it: that literal is the hard-coded
+         * path fragment the rule exists to push behind a helper. The walk recurses
+         * because `'teams/' + teamId + '/members'` parses as a left-nested
+         * BinaryExpression, which leaves the literals below the outermost operands.
+         * A chain of opaque operands (`a + b`) constructs no path fragment inline,
+         * so it keeps the same indirection allowance as a bare variable.
+         */
+        function isInlinePathExpression(node) {
+            if (isStringLiteralOrTemplate(node)) {
+                return true;
+            }
+            return (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                node.operator === '+' &&
+                (isInlinePathExpression(node.left) ||
+                    isInlinePathExpression(node.right)));
+        }
         function isUtilityFunction(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
                 return false;
@@ -59,8 +82,9 @@ exports.enforceFirestorePathUtils = (0, createRule_1.createRule)({
                 if (isUtilityFunction(pathArg)) {
                     return;
                 }
-                // Skip if it's a variable or other non-literal expression
-                if (!isStringLiteralOrTemplate(pathArg)) {
+                // Skip if it's a variable or other expression that hides construction
+                // behind a name rather than assembling the path inline
+                if (!isInlinePathExpression(pathArg)) {
                     return;
                 }
                 // Skip test files

package/lib/rules/enforce-realtimedb-path-utils.js

@@ -14,7 +14,7 @@ exports.enforceRealtimedbPathUtils = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            requirePathUtil: 'Use a utility function for Realtime Database paths to ensure type safety and maintainability. Instead of `ref("users/" + userId)`, create and use a utility function: `const toUserPath = (id: string) => `users/${id}`; ref(toUserPath(userId))`.',
+            requirePathUtil: 'Use a utility function for Realtime Database paths to ensure type safety and maintainability. Instead of `admin.database().ref(`users/${userId}`)`, create and use a utility function: `const toUserPath = (id: string) => `users/${id}`; admin.database().ref(toUserPath(userId))`.',
         },
     },
     defaultOptions: [],
@@ -59,6 +59,24 @@ exports.enforceRealtimedbPathUtils = (0, createRule_1.createRule)({
                 typeof node.value === 'string') ||
                 node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
+        /**
+         * A `+` chain qualifies as an inline path only when a string literal or
+         * template literal appears somewhere in it: that literal is the hard-coded
+         * path fragment the rule exists to push behind a helper. The walk recurses
+         * because `'users/' + userId + '/posts'` parses as a left-nested
+         * BinaryExpression, which leaves the literals below the outermost operands.
+         * A chain of opaque operands (`a + b`) constructs no path fragment inline,
+         * so it keeps the same indirection allowance as a bare variable.
+         */
+        function isInlinePathExpression(node) {
+            if (isStringLiteralOrTemplate(node)) {
+                return true;
+            }
+            return (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&
+                node.operator === '+' &&
+                (isInlinePathExpression(node.left) ||
+                    isInlinePathExpression(node.right)));
+        }
         function isUtilityFunction(node) {
             if (node.type !== utils_1.AST_NODE_TYPES.CallExpression) {
                 return false;
@@ -84,8 +102,9 @@ exports.enforceRealtimedbPathUtils = (0, createRule_1.createRule)({
                 if (isUtilityFunction(pathArg)) {
                     return;
                 }
-                // Skip if it's a variable or other non-literal expression
-                if (!isStringLiteralOrTemplate(pathArg)) {
+                // Skip if it's a variable or other expression that hides construction
+                // behind a name rather than assembling the path inline
+                if (!isInlinePathExpression(pathArg)) {
                     return;
                 }
                 // Skip test files

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "version": "1.20.79",
+    "date": "2026-08-02T08:54:03.464Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-path-utils",
+        "changeType": "fix",
+        "issues": [
+          1613
+        ],
+        "summary": "cite a reportable example in the message (closes #1613)"
+      }
+    ]
+  },
+  {
+    "version": "1.20.78",
+    "date": "2026-08-02T08:45:25.049Z",
+    "rules": [
+      {
+        "name": "enforce-firestore-path-utils",
+        "changeType": "fix",
+        "issues": [
+          1611
+        ],
+        "summary": "report concatenated inline paths (closes #1611)"
+      },
+      {
+        "name": "enforce-realtimedb-path-utils",
+        "changeType": "fix",
+        "issues": [
+          1612
+        ],
+        "summary": "report concatenated inline paths (closes #1612)"
+      }
+    ]
+  },
   {
     "version": "1.20.77",
     "date": "2026-08-02T08:02:01.009Z",