@blumintinc/eslint-plugin-blumint 1.20.108 → 1.20.109

package/lib/index.js

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

package/lib/rules/firestore-transaction-reads-before-writes.js

@@ -6,6 +6,85 @@ const createRule_1 = require("../utils/createRule");
 // Define the operations that are considered reads and writes
 const READ_OPERATIONS = new Set(['get']);
 const WRITE_OPERATIONS = new Set(['set', 'update', 'delete']);
+/**
+ * Helpers that validate a property key and hand back that very key, so a call
+ * to one names exactly the method its argument names. `enforce-assert-safe-object-key`
+ * is `error` in the same recommended config and its fixer wraps computed keys in
+ * `assertSafe(...)`, which means this shape is machine-generated from ordinary
+ * `transaction[methodName]` code rather than hand-written.
+ */
+const KEY_ASSERTION_HELPERS = new Set(['assertSafe']);
+/**
+ * Strips wrappers that erase at compile time or resolve to the key itself.
+ * `k as string`, `k satisfies string`, `<string>k` and `k!` emit nothing, and
+ * `await k` yields the same key, so none of them changes which method the
+ * lookup selects.
+ *
+ * The peel repeats because the wrappers nest: `(k as any)!`.
+ */
+function unwrapErasedKey(node) {
+    let current = node;
+    for (;;) {
+        switch (current.type) {
+            case utils_1.AST_NODE_TYPES.TSAsExpression:
+            case utils_1.AST_NODE_TYPES.TSSatisfiesExpression:
+            case utils_1.AST_NODE_TYPES.TSNonNullExpression:
+            case utils_1.AST_NODE_TYPES.TSTypeAssertion:
+                current = current.expression;
+                break;
+            case utils_1.AST_NODE_TYPES.AwaitExpression:
+                current = current.argument;
+                break;
+            default:
+                return current;
+        }
+    }
+}
+/** True for `assertSafe(k)` and for a namespaced `utils.assertSafe(k)`. */
+function isKeyAssertionCall(node) {
+    const { callee } = node;
+    if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return KEY_ASSERTION_HELPERS.has(callee.name);
+    }
+    return (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.property.type === utils_1.AST_NODE_TYPES.Identifier &&
+        KEY_ASSERTION_HELPERS.has(callee.property.name));
+}
+/**
+ * Resolves the method a computed access selects: `transaction[<key>]()`.
+ *
+ * A key assertion returns its argument untouched, so reading through one is
+ * information-free — `transaction[assertSafe(k)]` must land on exactly the
+ * verdict `transaction[k]` lands on, definite name and all. Every other call
+ * may return something other than what it was handed, so its argument proves
+ * nothing about the method and the key counts as unresolved. That keeps the
+ * safety net on for any wrapper (`transaction[String(k)]`) while never minting
+ * a definite read/write verdict out of a call whose result is unknown.
+ */
+function resolveComputedKey(property) {
+    let current = unwrapErasedKey(property);
+    for (;;) {
+        if (current.type === utils_1.AST_NODE_TYPES.Literal &&
+            typeof current.value === 'string') {
+            return { kind: 'name', name: current.value };
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.Identifier) {
+            return { kind: 'unresolved' };
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.CallExpression) {
+            const [argument] = current.arguments;
+            if (!isKeyAssertionCall(current) ||
+                current.arguments.length !== 1 ||
+                argument.type === utils_1.AST_NODE_TYPES.SpreadElement) {
+                return { kind: 'unresolved' };
+            }
+            current = unwrapErasedKey(argument);
+            continue;
+        }
+        return { kind: 'opaque' };
+    }
+}
 exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
     name: 'firestore-transaction-reads-before-writes',
     meta: {
@@ -119,18 +198,19 @@ exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
                 // Normal property access: transaction.get()
                 methodName = property.name;
             }
-            else if (callee.computed &&
-                property.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof property.value === 'string') {
-                // Computed property access with string literal: transaction['get']
-                methodName = property.value;
-            }
-            else if (callee.computed &&
-                property.type === utils_1.AST_NODE_TYPES.Identifier) {
-                // Computed property access with variable: transaction[methodName]
-                // This is tricky to analyze statically. For now, we'll be conservative
-                // and assume it could be any method. We'll handle this in the caller.
-                return { isRead: true, isWrite: true, methodName: null }; // Could be either - let caller decide
+            else if (callee.computed) {
+                // Computed property access: transaction['get'], transaction[methodName],
+                // transaction[assertSafe(methodName)]. A key that survives resolution
+                // as a definite string names the method; one that cannot be resolved
+                // could be any method, so it is answered conservatively and the caller
+                // decides.
+                const resolved = resolveComputedKey(property);
+                if (resolved.kind === 'unresolved') {
+                    return { isRead: true, isWrite: true, methodName: null };
+                }
+                if (resolved.kind === 'name') {
+                    methodName = resolved.name;
+                }
             }
             if (!methodName) {
                 return { isRead: false, isWrite: false, methodName: null };
@@ -154,7 +234,14 @@ exports.firestoreTransactionReadsBeforeWrites = (0, createRule_1.createRule)({
                 if (callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                     return `${objectName}[${callee.property.name}]`;
                 }
-                return `${objectName}[computed]`;
+                // A wrapped key such as assertSafe(methodName) is quoted verbatim so
+                // the message names text that exists in the file and can be searched
+                // for, rather than the resolved key the reader never wrote.
+                const keyText = context
+                    .getSourceCode()
+                    .getText(callee.property)
+                    .replace(/\s+/g, ' ');
+                return `${objectName}[${keyText}]`;
             }
             if (callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
                 return `${objectName}.${callee.property.name}`;

package/lib/rules/no-redundant-usecallback-wrapper.js

@@ -3,6 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRedundantUseCallbackWrapper = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const LATEST_CALLBACK_MODULE = 'use-latest-callback';
+const LATEST_CALLBACK_HOOK = 'useLatestCallback';
 function isHookLikeName(name) {
     return name.startsWith('use');
 }
@@ -100,7 +102,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
             },
         ],
         messages: {
-            redundantWrapper: 'useCallback is wrapping memoized callback "{{callbackName}}", adding a redundant dependency array without improving stability. Pass the hook/context callback directly so React keeps the original stable reference and avoids wrapper allocations and dependency drift.',
+            // The wrapper is named rather than hardcoded: the rule reports
+            // `useLatestCallback` too, which has no dependency array, so a message
+            // asserting one would describe code the reader cannot find.
+            redundantWrapper: '{{wrapper}} is wrapping memoized callback "{{callbackName}}", adding a redundant memoization layer without improving stability. Pass the hook/context callback directly so React keeps the original stable reference and avoids wrapper allocations and dependency drift.',
         },
     },
     defaultOptions: [{}],
@@ -109,10 +114,59 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
         const knownHooks = new Set(option.memoizedHookNames ?? []);
         const assumeAllUseAreMemoized = option.assumeAllUseAreMemoized === true;
         const sourceCode = context.sourceCode;
+        // Every callee that memoizes the callback handed to it. `useLatestCallback`
+        // belongs here because `use-latest-callback` — 'error' in the same
+        // recommended config, and fixable — rewrites every `useCallback(fn, deps)`
+        // into `useLatestCallback(fn)`. The wrapper it produces is the very
+        // construct this rule objects to, still allocating a fresh arrow around an
+        // already stable callback, so without this entry one `eslint --fix` renames
+        // the violation out of view while leaving it byte-for-byte intact — and the
+        // config mandating that spelling means it is also written by hand (#1726).
+        const wrapperNames = new Set(['useCallback', LATEST_CALLBACK_HOOK]);
+        /**
+         * The wrapper's name if this callee is one, else null. Reading the name
+         * rather than a boolean lets the report say which wrapper it found, since
+         * the local binding need not be spelled `useLatestCallback` at all.
+         */
+        const wrapperNameOf = (callee) => {
+            if (callee.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return wrapperNames.has(callee.name) ? callee.name : null;
+            }
+            // Namespaced spelling, e.g. React.useCallback
+            if (callee.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                !callee.computed &&
+                callee.property.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return wrapperNames.has(callee.property.name)
+                    ? callee.property.name
+                    : null;
+            }
+            return null;
+        };
         // Track identifiers coming from hook-like calls
         const hookReturnObjects = new Set(); // variables assigned to a hook call result (object or function)
         const hookReturnProps = new Set(); // properties destructured from a hook call result
         return {
+            ImportDeclaration(node) {
+                // The module's sole export is the hook, so its DEFAULT specifier binds
+                // it under whatever local name the file chose — a shape a set of bare
+                // hook names cannot see. `use-latest-callback`'s own fixer picks that
+                // name with `freeImportName`, falling back to `useLatestCallback2` when
+                // `useLatestCallback` is already taken in the file, so the alias is
+                // authored by the sibling fixer rather than being hypothetical.
+                if (node.source.value !== LATEST_CALLBACK_MODULE ||
+                    (node.importKind && node.importKind !== 'value')) {
+                    return;
+                }
+                for (const specifier of node.specifiers) {
+                    if (specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+                        (specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            specifier.importKind !== 'type' &&
+                            specifier.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
+                            specifier.imported.name === LATEST_CALLBACK_HOOK)) {
+                        wrapperNames.add(specifier.local.name);
+                    }
+                }
+            },
             VariableDeclarator(node) {
                 if (!node.init)
                     return;
@@ -145,17 +199,13 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                 }
             },
             CallExpression(node) {
-                // Detect useCallback wrappers (including React.useCallback)
+                // Detect memoization wrappers (including React.useCallback and the
+                // useLatestCallback spelling the config's own fixer produces)
                 const calleeNode = unwrapChainExpression(node.callee);
                 if (!calleeNode)
                     return;
-                const isUseCallback = (calleeNode.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    calleeNode.name === 'useCallback') ||
-                    (calleeNode.type === utils_1.AST_NODE_TYPES.MemberExpression &&
-                        !calleeNode.computed &&
-                        calleeNode.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        calleeNode.property.name === 'useCallback');
-                if (isUseCallback && node.arguments.length >= 1) {
+                const wrapper = wrapperNameOf(calleeNode);
+                if (wrapper && node.arguments.length >= 1) {
                     const arg = node.arguments[0];
                     const unwrappedArg = unwrapChainExpression(arg);
                     // Case 1: useCallback(memoizedFn, ...) or useCallback(ctx.memoized, ...)
@@ -173,7 +223,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                 context.report({
                                     node,
                                     messageId: 'redundantWrapper',
-                                    data: { callbackName: sourceCode.getText(unwrappedArg) },
+                                    data: {
+                                        wrapper,
+                                        callbackName: sourceCode.getText(unwrappedArg),
+                                    },
                                     fix: (fixer) => fixer.replaceText(node, replaceText),
                                 });
                             }
@@ -182,7 +235,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                 context.report({
                                     node,
                                     messageId: 'redundantWrapper',
-                                    data: { callbackName: sourceCode.getText(unwrappedArg) },
+                                    data: {
+                                        wrapper,
+                                        callbackName: sourceCode.getText(unwrappedArg),
+                                    },
                                 });
                             }
                         }
@@ -214,7 +270,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                             context.report({
                                                 node,
                                                 messageId: 'redundantWrapper',
-                                                data: { callbackName: sourceCode.getText(callee) },
+                                                data: {
+                                                    wrapper,
+                                                    callbackName: sourceCode.getText(callee),
+                                                },
                                                 fix: (fixer) => fixer.replaceText(node, replaceText),
                                             });
                                         }
@@ -223,7 +282,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                             context.report({
                                                 node,
                                                 messageId: 'redundantWrapper',
-                                                data: { callbackName: sourceCode.getText(callee) },
+                                                data: {
+                                                    wrapper,
+                                                    callbackName: sourceCode.getText(callee),
+                                                },
                                             });
                                         }
                                     }
@@ -272,7 +334,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                                     context.report({
                                                         node,
                                                         messageId: 'redundantWrapper',
-                                                        data: { callbackName: sourceCode.getText(callee) },
+                                                        data: {
+                                                            wrapper,
+                                                            callbackName: sourceCode.getText(callee),
+                                                        },
                                                         fix: (fixer) => fixer.replaceText(node, replaceText),
                                                     });
                                                 }
@@ -281,7 +346,10 @@ exports.noRedundantUseCallbackWrapper = (0, createRule_1.createRule)({
                                                     context.report({
                                                         node,
                                                         messageId: 'redundantWrapper',
-                                                        data: { callbackName: sourceCode.getText(callee) },
+                                                        data: {
+                                                            wrapper,
+                                                            callbackName: sourceCode.getText(callee),
+                                                        },
                                                     });
                                                 }
                                             }

package/lib/rules/require-server-timestamp-for-firestore-dates.js

@@ -91,20 +91,60 @@ function typeAnnotationReferencesFirestoreType(typeAnnotation, firestoreTypeName
     const names = collectTypeReferenceNames(typeAnnotation);
     return names.some((n) => firestoreTypeNames.has(n));
 }
+/**
+ * True for the assertion wrappers that leave the underlying expression intact:
+ * `x as T` and `x satisfies T`.
+ */
+function isCastExpression(node) {
+    return (node.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
+        node.type ===
+            utils_1.AST_NODE_TYPES
+                .TSSatisfiesExpression);
+}
 /**
  * Returns the inner expression, unwrapping TSAsExpression / TSSatisfiesExpression
  * chains, so we can inspect what lies under a cast.
  */
 function unwrapCast(node) {
     let current = node;
-    while (current.type === utils_1.AST_NODE_TYPES.TSAsExpression ||
-        current.type ===
-            utils_1.AST_NODE_TYPES
-                .TSSatisfiesExpression) {
+    while (isCastExpression(current)) {
         current = current.expression;
     }
     return current;
 }
+/**
+ * True when some `as` cast in the wrapper chain targets a Firestore type. Those
+ * casts are the TSAsExpression visitor's own entry point, so the annotation- and
+ * return-type-driven visitors must stand down on them or the same `new Date()`
+ * is reported twice.
+ */
+function castChainTargetsFirestoreType(node, firestoreTypeNames) {
+    let current = node;
+    while (isCastExpression(current)) {
+        const cast = current;
+        if (cast.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
+            typeAnnotationReferencesFirestoreType(cast.typeAnnotation, firestoreTypeNames)) {
+            return true;
+        }
+        current = cast.expression;
+    }
+    return false;
+}
+/**
+ * Resolves an expression in a Firestore-typed position to the object literal it
+ * ultimately denotes, seeing through `as const` and other assertion wrappers.
+ * A wrapper is a syntactic no-op — `{ createdAt: new Date() } as const` still
+ * stamps the document with the client clock — so it must not hide the object.
+ * Returns null when the chain is already owned by the TSAsExpression visitor.
+ */
+function resolveObjectLiteral(node, firestoreTypeNames) {
+    if (!node)
+        return null;
+    if (castChainTargetsFirestoreType(node, firestoreTypeNames))
+        return null;
+    const inner = unwrapCast(node);
+    return inner.type === utils_1.AST_NODE_TYPES.ObjectExpression ? inner : null;
+}
 /**
  * Checks whether an expression is `new Date(...)` (possibly wrapped in casts).
  */
@@ -343,19 +383,22 @@ exports.requireServerTimestampForFirestoreDates = (0, createRule_1.createRule)({
             VariableDeclarator(node) {
                 if (firestoreTypeNames.size === 0)
                     return;
-                // Pattern: const x: FirestoreType = { ... }
+                // Pattern: const x: FirestoreType = { ... }, including when the literal
+                // is wrapped in `as const` or another assertion.
                 const typeAnnotation = node.id.typeAnnotation?.typeAnnotation;
-                if (typeAnnotation &&
-                    typeAnnotationReferencesFirestoreType(typeAnnotation, firestoreTypeNames) &&
-                    node.init &&
-                    node.init.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    // Exempt local render seeds handed to React state, never written to
-                    // Firestore — being typed as a Firestore doc is not a write.
-                    if (context.getDeclaredVariables(node).some(isLocalRenderSeedVariable)) {
-                        return;
-                    }
-                    reportNewDatesInObject(node.init, context);
+                if (!typeAnnotation ||
+                    !typeAnnotationReferencesFirestoreType(typeAnnotation, firestoreTypeNames)) {
+                    return;
                 }
+                const object = resolveObjectLiteral(node.init, firestoreTypeNames);
+                if (!object)
+                    return;
+                // Exempt local render seeds handed to React state, never written to
+                // Firestore — being typed as a Firestore doc is not a write.
+                if (context.getDeclaredVariables(node).some(isLocalRenderSeedVariable)) {
+                    return;
+                }
+                reportNewDatesInObject(object, context);
             },
             // Pattern: { ... } as FirestoreType  or  { ... } satisfies FirestoreType
             TSAsExpression(node) {
@@ -384,21 +427,24 @@ exports.requireServerTimestampForFirestoreDates = (0, createRule_1.createRule)({
             ArrowFunctionExpression(node) {
                 if (firestoreTypeNames.size === 0)
                     return;
-                if (node.body.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                if (node.body.type === utils_1.AST_NODE_TYPES.BlockStatement)
                     return;
                 const returnType = node.returnType?.typeAnnotation;
-                if (returnType &&
-                    typeAnnotationReferencesFirestoreType(returnType, firestoreTypeNames)) {
-                    reportNewDatesInObject(node.body, context);
+                if (!returnType ||
+                    !typeAnnotationReferencesFirestoreType(returnType, firestoreTypeNames)) {
+                    return;
+                }
+                const object = resolveObjectLiteral(node.body, firestoreTypeNames);
+                if (object) {
+                    reportNewDatesInObject(object, context);
                 }
             },
             // Return statements in functions with explicit Firestore return type annotation
             ReturnStatement(node) {
                 if (firestoreTypeNames.size === 0)
                     return;
-                if (!node.argument)
-                    return;
-                if (node.argument.type !== utils_1.AST_NODE_TYPES.ObjectExpression)
+                const object = resolveObjectLiteral(node.argument, firestoreTypeNames);
+                if (!object)
                     return;
                 // Walk up to find the enclosing function and check its return type
                 let ancestor = node.parent;
@@ -409,7 +455,7 @@ exports.requireServerTimestampForFirestoreDates = (0, createRule_1.createRule)({
                         const returnType = ancestor.returnType?.typeAnnotation;
                         if (returnType &&
                             typeAnnotationReferencesFirestoreType(returnType, firestoreTypeNames)) {
-                            reportNewDatesInObject(node.argument, context);
+                            reportNewDatesInObject(object, context);
                         }
                         break;
                     }

package/package.json

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

package/release-manifest.json

@@ -1,4 +1,34 @@
 [
+  {
+    "version": "1.20.109",
+    "date": "2026-08-05T07:42:30.150Z",
+    "rules": [
+      {
+        "name": "firestore-transaction-reads-before-writes",
+        "changeType": "fix",
+        "issues": [
+          1728
+        ],
+        "summary": "resolve a call-wrapped computed key (closes #1728)"
+      },
+      {
+        "name": "no-redundant-usecallback-wrapper",
+        "changeType": "fix",
+        "issues": [
+          1726
+        ],
+        "summary": "see the useLatestCallback spelling (closes #1726)"
+      },
+      {
+        "name": "require-server-timestamp-for-firestore-dates",
+        "changeType": "fix",
+        "issues": [
+          1727
+        ],
+        "summary": "look through cast wrappers (closes #1727)"
+      }
+    ]
+  },
   {
     "version": "1.20.108",
     "date": "2026-08-05T05:55:32.346Z",