@blumintinc/eslint-plugin-blumint 1.20.76 → 1.20.78

package/lib/index.js

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

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

@@ -34,6 +34,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 +77,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/lib/rules/prefer-spread-over-reassembly.js

@@ -147,23 +147,57 @@ function collectObjectForwardedFields(objectExpression, destructuredNames) {
     }
     return forwarded;
 }
-function getSingleTarget(fn) {
-    const body = fn.body;
-    // Concise arrow: `(props) => <X />`
-    if (body.type === utils_1.AST_NODE_TYPES.JSXElement) {
+/**
+ * Wrappers that exist only for the type checker: they compile away entirely, so
+ * the value they wrap is the value the function actually produces.
+ */
+const TRANSPARENT_WRAPPERS = new Set([
+    utils_1.AST_NODE_TYPES.TSAsExpression,
+    utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+    utils_1.AST_NODE_TYPES.TSNonNullExpression,
+]);
+/**
+ * Strips every type-only wrapper (`as T`, `as const`, `satisfies T`, `!`) from
+ * an expression. An assertion removes no reassembly — `{ a, b } as const` is
+ * the very same destructure-then-reassemble as `{ a, b }` — so classifying the
+ * target without stripping first turns an assertion into an accidental
+ * suppression. The loop is what handles chains such as `{...} as unknown as T`,
+ * and `enforce-object-literal-as-const` appends `as const` to exactly this
+ * shape, so wrapped literals are the common case rather than the exotic one.
+ */
+function unwrapTransparent(node) {
+    let current = node;
+    while (TRANSPARENT_WRAPPERS.has(current.type)) {
+        current = current.expression;
+    }
+    return current;
+}
+/**
+ * Classifies an already-unwrapped expression as a spread target. The fix is
+ * anchored on the node returned here — the JSX opening element or the object
+ * literal's own braces — so any wrapper stripped on the way in keeps its source
+ * text untouched.
+ */
+function classifyTarget(expression) {
+    if (expression.type === utils_1.AST_NODE_TYPES.JSXElement) {
         return {
             kind: 'jsx',
-            openingElement: body.openingElement,
-            jsxElement: body,
+            openingElement: expression.openingElement,
+            jsxElement: expression,
         };
     }
     // Concise arrow returning object literal: `({ x, y }) => ({ x, y, extra: 1 })`
     // The parser represents the parenthesized object as an ObjectExpression body.
-    if (body.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-        return { kind: 'object', expression: body };
+    if (expression.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+        return { kind: 'object', expression };
     }
+    return null;
+}
+function getSingleTarget(fn) {
+    const body = fn.body;
+    // Concise arrow: `(props) => <X />`, `({ x, y }) => ({ x, y } as const)`.
     if (body.type !== utils_1.AST_NODE_TYPES.BlockStatement) {
-        return null;
+        return classifyTarget(unwrapTransparent(body));
     }
     // Require exactly one statement in the block, which must be a return.
     if (body.body.length !== 1) {
@@ -173,30 +207,7 @@ function getSingleTarget(fn) {
     if (stmt.type !== utils_1.AST_NODE_TYPES.ReturnStatement || !stmt.argument) {
         return null;
     }
-    const arg = stmt.argument;
-    if (arg.type === utils_1.AST_NODE_TYPES.JSXElement) {
-        return {
-            kind: 'jsx',
-            openingElement: arg.openingElement,
-            jsxElement: arg,
-        };
-    }
-    // Parenthesized JSX in arrow: `(props) => (<X />)` — arg may wrap with
-    // TSAsExpression or similar. We unwrap one level of TSAsExpression / TSSatisfiesExpression.
-    if ((arg.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-        arg.type === utils_1.AST_NODE_TYPES.TSSatisfiesExpression) &&
-        arg.expression.type === utils_1.AST_NODE_TYPES.JSXElement) {
-        const jsx = arg.expression;
-        return {
-            kind: 'jsx',
-            openingElement: jsx.openingElement,
-            jsxElement: jsx,
-        };
-    }
-    if (arg.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-        return { kind: 'object', expression: arg };
-    }
-    return null;
+    return classifyTarget(unwrapTransparent(stmt.argument));
 }
 /**
  * Checks whether any of the destructured names is used anywhere in the

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,40 @@
 [
+  {
+    "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",
+    "rules": [
+      {
+        "name": "prefer-spread-over-reassembly",
+        "changeType": "fix",
+        "issues": [
+          1610
+        ],
+        "summary": "see through transparent type-assertion wrappers (closes #1610)"
+      }
+    ]
+  },
   {
     "version": "1.20.76",
     "date": "2026-08-02T07:09:34.794Z",