@blumintinc/eslint-plugin-blumint 1.13.0 → 1.15.0

package/lib/rules/enforce-f-extension-for-entry-points.js

@@ -0,0 +1,283 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enforceFExtensionForEntryPoints = void 0;
+const utils_1 = require("@typescript-eslint/utils");
+const createRule_1 = require("../utils/createRule");
+const path_1 = __importDefault(require("path"));
+const ASTHelpers_1 = require("../utils/ASTHelpers");
+const DEFAULT_ENTRY_POINTS = [
+    'onCall',
+    'onCallVaripotent',
+    'onRequest',
+    'onQueueTask',
+    'onWebhook',
+    'sequentialDocumentWritten',
+    'onDocumentWritten',
+    'onDocumentCreated',
+    'onDocumentDeleted',
+    'onDocumentUpdated',
+    'onSchedule',
+    'onValueWritten',
+    'onValueCreated',
+    'onValueUpdated',
+    'onValueDeleted',
+    'sequentialValueWritten',
+    'sequentialValueCreated',
+    'sequentialValueUpdated',
+    'sequentialValueDeleted',
+];
+/**
+ * Entry points must be defined at the top level because Firebase deployment
+ * discovers and registers them by evaluating the module scope. Nested definitions
+ * inside functions or classes won't be discovered during the deployment process.
+ */
+function isTopLevel(node) {
+    let current = node.parent;
+    while (current) {
+        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 ||
+            current.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.ClassExpression ||
+            current.type === utils_1.AST_NODE_TYPES.MethodDefinition) {
+            return false;
+        }
+        current = current.parent;
+    }
+    return true;
+}
+/**
+ * Checks if a node directly defines an entry point as a function or variable declaration.
+ * This exempts wrapper implementation files (e.g., functions/src/v2/) but intentionally
+ * does not exempt re-export files (e.g., `const myCall = onCall; export { myCall }`).
+ * Re-export files that also invoke entry points must still follow the .f.ts naming convention
+ * and will be flagged by the CallExpression handler.
+ *
+ * This function specifically checks AST node types FunctionDeclaration and
+ * VariableDeclaration but does not catch ExportSpecifiers used in re-exports.
+ */
+function isNodeDefiningEntryPoint(node, entryPoints) {
+    // Handle function declaration: export function onCall() {}
+    if (node.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+        node.id &&
+        entryPoints.has(node.id.name)) {
+        return true;
+    }
+    // Handle variable declaration: export const onCall = ...
+    if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
+        return node.declarations.some((decl) => decl.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+            entryPoints.has(decl.id.name));
+    }
+    return false;
+}
+/**
+ * Obtains the scope for a node in an ESLint 9+ compatible way.
+ *
+ * Note: In ESLint 8, falls back to context.getScope() which returns the scope
+ * of the currently visited node—only call this from within visitor handlers
+ * for the target node.
+ */
+function getScopeForNode(context, node) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    if (isEslint9OrLater(sourceCode)) {
+        return getEslint9Scope(sourceCode, node);
+    }
+    return context.getScope();
+}
+/**
+ * Checks if the current environment is ESLint 9 or later.
+ */
+function isEslint9OrLater(sourceCode) {
+    return typeof sourceCode.getScope === 'function';
+}
+/**
+ * Gets the scope for a node using the ESLint 9+ SourceCode.getScope() method.
+ */
+function getEslint9Scope(sourceCode, node) {
+    return sourceCode.getScope(node);
+}
+/**
+ * Gets the import definition for a given name in the current scope.
+ */
+function getImportDef(context, calleeName, node) {
+    const scope = getScopeForNode(context, node);
+    const variable = ASTHelpers_1.ASTHelpers.findVariableInScope(scope, calleeName);
+    if (!variable) {
+        return null;
+    }
+    return variable.defs.find((def) => def.type === 'ImportBinding') ?? null;
+}
+/**
+ * Checks if the import comes from an allowed Firebase or internal wrapper source.
+ */
+function isFromAllowedSource(importDef) {
+    if (!importDef || !importDef.parent) {
+        return false;
+    }
+    const importDeclaration = importDef.parent;
+    if (importDeclaration.type !== utils_1.AST_NODE_TYPES.ImportDeclaration) {
+        return false;
+    }
+    const source = importDeclaration.source.value;
+    return (source.startsWith('firebase-functions') ||
+        /(^|\/)v2(\/|$)/.test(source) ||
+        /(^|\/)util\/webhook(\/|$)/.test(source));
+}
+/**
+ * Helper function to extract name from import specifier.
+ */
+function getNameFromImportSpecifier(node) {
+    const { imported } = node;
+    if (imported.type === utils_1.AST_NODE_TYPES.Identifier) {
+        return imported.name;
+    }
+    // Handle Literal imports (string-named imports in ESLint 8+)
+    const importedNode = imported;
+    if (importedNode.type === utils_1.AST_NODE_TYPES.Literal &&
+        typeof importedNode.value === 'string') {
+        return importedNode.value;
+    }
+    return undefined;
+}
+/**
+ * Helper function to extract name from module path.
+ */
+function getNameFromModulePath(importDeclaration, entryPoints) {
+    const modulePath = importDeclaration.source.value;
+    // Extract the module name from the path.
+    // Example: '../../v2/https/onCall' -> 'onCall'
+    const match = modulePath.match(/[/\\]([^/\\]+)$/);
+    const segment = (match ? match[1] : modulePath).replace(/\.[jt]sx?$/, '');
+    return entryPoints.has(segment) ? segment : undefined;
+}
+/**
+ * Resolves the original name of the imported function, handling aliases and default imports.
+ */
+function getOriginalName(importDef, calleeName, entryPoints) {
+    if (!importDef || !importDef.node) {
+        return calleeName;
+    }
+    // Handle named imports: import { onCall as myCall } from ...
+    if (importDef.node.type === utils_1.AST_NODE_TYPES.ImportSpecifier) {
+        return getNameFromImportSpecifier(importDef.node) ?? calleeName;
+    }
+    // Handle default imports: import onCall from '../../v2/https/onCall'
+    // or namespace imports: import * as onCall from '../../v2/https/onCall'
+    if (importDef.node.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        importDef.node.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+        return (getNameFromModulePath(importDef.parent, entryPoints) ?? calleeName);
+    }
+    return calleeName;
+}
+exports.enforceFExtensionForEntryPoints = (0, createRule_1.createRule)({
+    name: 'enforce-f-extension-for-entry-points',
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce .f.ts extension for entry points',
+            recommended: 'error',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    entryPoints: {
+                        type: 'array',
+                        items: { type: 'string' },
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            requireFExtension: 'File "{{fileName}}" contains a Firebase Cloud Function entry point "{{entryPoint}}" but lacks the ".f.ts" extension. ' +
+                'Entry points must use ".f.ts" to clearly mark the public function surface to avoid accidental export/name collisions, ' +
+                'unintended exposure of internal implementation during deployment, confusion during imports/tests, and maintenance bugs. ' +
+                'Rename this file to "{{suggestedName}}" to mark it as a public entry point.',
+        },
+    },
+    defaultOptions: [{ entryPoints: DEFAULT_ENTRY_POINTS }],
+    create(context, [options]) {
+        const filePath = context.filename ??
+            context.getFilename();
+        const fileName = path_1.default.basename(filePath);
+        const entryPoints = new Set(options.entryPoints?.length ? options.entryPoints : DEFAULT_ENTRY_POINTS);
+        // Only apply to files under functions/src/
+        const normalizedPath = filePath.replace(/\\/g, '/');
+        if (!normalizedPath.includes('/functions/src/') &&
+            !normalizedPath.startsWith('functions/src/')) {
+            return {};
+        }
+        // Exclude test files and declaration files
+        if (/\.(test|spec)\.tsx?$|\.d\.ts$/.test(fileName)) {
+            return {};
+        }
+        // Only apply to .ts and .tsx files, but not files already using .f.ts or .f.tsx
+        const isTsOrTsx = /\.tsx?$/.test(fileName);
+        const isFExtension = /\.f\.tsx?$/.test(fileName);
+        if (!isTsOrTsx || isFExtension) {
+            return {};
+        }
+        let isDefiningEntryPoint = false;
+        let reported = false;
+        return {
+            ExportNamedDeclaration(node) {
+                if (isDefiningEntryPoint || !node.declaration) {
+                    return;
+                }
+                if (isNodeDefiningEntryPoint(node.declaration, entryPoints)) {
+                    isDefiningEntryPoint = true;
+                }
+            },
+            ExportDefaultDeclaration(node) {
+                if (isDefiningEntryPoint) {
+                    return;
+                }
+                if (isNodeDefiningEntryPoint(node.declaration, entryPoints)) {
+                    isDefiningEntryPoint = true;
+                }
+            },
+            CallExpression(node) {
+                if (reported || isDefiningEntryPoint) {
+                    return;
+                }
+                // We only care about simple identifier calls (e.g., onCall())
+                if (node.callee.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                    return;
+                }
+                const calleeName = node.callee.name;
+                // Optimization: Early return if it's not a top-level call
+                if (!isTopLevel(node)) {
+                    return;
+                }
+                // Variable lookup logic and import source validation
+                const importDef = getImportDef(context, calleeName, node);
+                if (!importDef || !isFromAllowedSource(importDef)) {
+                    return;
+                }
+                // Entry point checking
+                const originalName = getOriginalName(importDef, calleeName, entryPoints);
+                if (!entryPoints.has(originalName)) {
+                    return;
+                }
+                reported = true;
+                const suggestedName = fileName.replace(/\.tsx?$/, '.f$&');
+                context.report({
+                    node,
+                    messageId: 'requireFExtension',
+                    data: {
+                        fileName,
+                        entryPoint: calleeName === originalName
+                            ? calleeName
+                            : `${calleeName} (${originalName})`,
+                        suggestedName,
+                    },
+                });
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-f-extension-for-entry-points.js.map

package/lib/rules/enforce-fieldpath-syntax-in-docsetter.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceFieldPathSyntaxInDocSetter = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const getMethodName_1 = require("../utils/getMethodName");
 exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
     name: 'enforce-fieldpath-syntax-in-docsetter',
     meta: {
@@ -16,11 +17,12 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            enforceFieldPathSyntax: 'Use FieldPath syntax (dot notation) for nested fields in DocSetter. Instead of `{ roles: { contributor: value } }`, use `{ "roles.contributor": value }`.',
+            enforceFieldPathSyntax: 'What’s wrong: DocSetter {{methodName}} receives nested object data under "{{topLevelKey}}". → Why it matters: Firestore treats that nested map as a whole sub-document write, so partial updates can overwrite sibling fields you did not include. → How to fix: Flatten nested properties into FieldPath (dot) keys before passing documentData (e.g., "{{exampleFieldPath}}") so only the intended leaves are written.',
         },
     },
     defaultOptions: [],
     create(context) {
+        const sourceCode = context.getSourceCode();
         // Track DocSetter variables
         const docSetterVariables = new Set();
         // Helper function to check if a node is a DocSetter method call
@@ -51,45 +53,14 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
             return (prop.type === utils_1.AST_NODE_TYPES.SpreadElement ||
                 (prop.type === utils_1.AST_NODE_TYPES.Property && prop.computed === true));
         }
-        // Helper function to check if an object has nested objects (excluding arrays)
-        function hasNestedObjects(node, prefix = '') {
-            for (const property of node.properties) {
-                // Skip spread elements
-                if (property.type === utils_1.AST_NODE_TYPES.SpreadElement) {
-                    continue;
-                }
-                if (property.type !== utils_1.AST_NODE_TYPES.Property) {
-                    continue;
-                }
-                // Skip computed properties (dynamic keys)
-                if (property.computed) {
-                    continue;
-                }
-                const isNumericKey = property.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    (typeof property.key.value === 'number' ||
-                        (typeof property.key.value === 'string' &&
-                            /^\d+$/.test(property.key.value)));
-                // Allow top-level numeric keys (treated like array indexes)
-                if (prefix === '' && isNumericKey) {
-                    continue;
-                }
-                const value = property.value;
-                // Skip if the property key is already using dot notation
-                if (property.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof property.key.value === 'string' &&
-                    property.key.value.includes('.')) {
-                    continue;
-                }
-                // Check if the value is an object (but not an array)
-                if (value.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                    // Skip nested objects that contain spread elements or computed properties
-                    const hasSpreadOrComputed = value.properties.some((prop) => isSpreadOrComputed(prop));
-                    if (!hasSpreadOrComputed) {
-                        return true;
-                    }
-                }
-            }
-            return false;
+        function isNumericKey(property) {
+            return (property.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                (typeof property.key.value === 'number' ||
+                    (typeof property.key.value === 'string' &&
+                        /^\d+$/.test(property.key.value))));
+        }
+        function hasRootNumericKey(node) {
+            return node.properties.some((property) => property.type === utils_1.AST_NODE_TYPES.Property && isNumericKey(property));
         }
         // Helper function to flatten nested objects into FieldPath syntax
         function flattenObject(obj, sourceCode, prefix = '') {
@@ -127,11 +98,8 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
                     // Skip other key types
                     continue;
                 }
-                const isNumericKey = property.key.type === utils_1.AST_NODE_TYPES.Literal &&
-                    (typeof property.key.value === 'number' ||
-                        (typeof property.key.value === 'string' &&
-                            /^\d+$/.test(property.key.value)));
-                if (prefix === '' && isNumericKey) {
+                const numericKey = isNumericKey(property);
+                if (prefix === '' && numericKey) {
                     continue;
                 }
                 const fullKey = prefix ? `${prefix}.${key}` : key;
@@ -152,11 +120,13 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
             return key.includes('.') || !/^(?:[$_A-Za-z][$\w]*)$/u.test(key);
         }
         // Helper function to convert an object to FieldPath syntax
-        function convertToFieldPathSyntax(node, sourceCode) {
+        function convertToFieldPathSyntax(node, sourceCode, preflattened) {
             const idProperty = node.properties.find((prop) => prop.type === utils_1.AST_NODE_TYPES.Property &&
                 prop.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                 prop.key.name === 'id');
-            const flattenedProperties = flattenObject(node, sourceCode);
+            const flattenedProperties = {
+                ...(preflattened ?? flattenObject(node, sourceCode)),
+            };
             if (idProperty && idProperty.type === utils_1.AST_NODE_TYPES.Property) {
                 delete flattenedProperties['id'];
             }
@@ -175,6 +145,72 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
             result += '}';
             return result;
         }
+        function getPropertyKeyText(property) {
+            if (property.key.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return property.key.name;
+            }
+            if (property.key.type === utils_1.AST_NODE_TYPES.Literal &&
+                (typeof property.key.value === 'string' ||
+                    typeof property.key.value === 'number')) {
+                return String(property.key.value);
+            }
+            return undefined;
+        }
+        function getFirstNestedObjectProperty(node, keyPredicate) {
+            for (const property of node.properties) {
+                if (isSpreadOrComputed(property)) {
+                    continue;
+                }
+                if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+                    continue;
+                }
+                const propertyKeyText = getPropertyKeyText(property);
+                if (!propertyKeyText) {
+                    continue;
+                }
+                if (keyPredicate && !keyPredicate(propertyKeyText)) {
+                    continue;
+                }
+                // Root-level numeric keys typically model array-style buckets rather than
+                // Firestore document fields, so ignore them when identifying nested objects
+                if (node.parent?.type !== utils_1.AST_NODE_TYPES.Property &&
+                    isNumericKey(property)) {
+                    continue;
+                }
+                if (property.value.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    continue;
+                }
+                const hasSpreadOrComputed = property.value.properties.some((prop) => isSpreadOrComputed(prop));
+                if (hasSpreadOrComputed) {
+                    continue;
+                }
+                return property;
+            }
+            return undefined;
+        }
+        function extractViolationDetails(firstArg, sourceCode) {
+            const firstNestedPropertyWithoutDots = getFirstNestedObjectProperty(firstArg, (key) => !key.includes('.'));
+            const firstNestedProperty = firstNestedPropertyWithoutDots ||
+                getFirstNestedObjectProperty(firstArg);
+            if (!firstNestedProperty) {
+                return null;
+            }
+            const propertyKeyText = getPropertyKeyText(firstNestedProperty);
+            const exampleFieldPathFromProperty = propertyKeyText &&
+                flattenObject(firstNestedProperty.value, sourceCode, propertyKeyText);
+            const flattenedProperties = flattenObject(firstArg, sourceCode);
+            const exampleFieldPath = (exampleFieldPathFromProperty &&
+                Object.keys(exampleFieldPathFromProperty).find((key) => key.includes('.'))) ??
+                (propertyKeyText &&
+                    Object.keys(flattenedProperties).find((key) => key.startsWith(`${propertyKeyText}.`))) ??
+                Object.keys(flattenedProperties).find((key) => key.includes('.')) ??
+                'field.nested';
+            return {
+                topLevelKey: propertyKeyText ?? 'nested field',
+                exampleFieldPath,
+                flattenedProperties,
+            };
+        }
         return {
             // Track DocSetter variable declarations
             VariableDeclarator(node) {
@@ -192,16 +228,30 @@ exports.enforceFieldPathSyntaxInDocSetter = (0, createRule_1.createRule)({
                 }
                 // Check if the first argument is an object literal
                 const firstArg = node.arguments[0];
-                if (firstArg?.type !== utils_1.AST_NODE_TYPES.ObjectExpression ||
-                    !hasNestedObjects(firstArg)) {
+                if (firstArg?.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                    return;
+                }
+                if (hasRootNumericKey(firstArg)) {
+                    return;
+                }
+                const violationDetails = extractViolationDetails(firstArg, sourceCode);
+                if (!violationDetails) {
                     return;
                 }
                 // Report and fix the issue
+                const callee = node.callee;
                 context.report({
                     node: firstArg,
                     messageId: 'enforceFieldPathSyntax',
+                    data: {
+                        methodName: `${(0, getMethodName_1.getMemberExpressionName)(callee, sourceCode, {
+                            computedFallbackToText: false,
+                        }) || 'set'}()`,
+                        topLevelKey: violationDetails.topLevelKey,
+                        exampleFieldPath: violationDetails.exampleFieldPath,
+                    },
                     fix(fixer) {
-                        const newText = convertToFieldPathSyntax(firstArg, context.getSourceCode());
+                        const newText = convertToFieldPathSyntax(firstArg, sourceCode, violationDetails.flattenedProperties);
                         return fixer.replaceText(firstArg, newText);
                     },
                 });

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

@@ -24,8 +24,20 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
         },
         schema: [],
         messages: {
-            missingGeneric: '{{ type }} must specify a generic type argument for type safety. Instead of `const docRef = doc(collection)`, use `const docRef = doc<YourType>(collection)`.',
-            invalidGeneric: '{{ type }} must not use "any" or "{}" as generic type argument. Define a proper interface/type for your document: `interface UserDoc { name: string; age: number; }` and use it: `const docRef = doc<UserDoc>(collection)`.',
+            missingGeneric: [
+                "What's wrong: {{ type }} is missing its document schema generic (the document data type).",
+                '',
+                'Why it matters: Without the generic, Firestore references fall back to loose DocumentData, so TypeScript cannot catch field typos or missing required properties before they reach Firestore.',
+                '',
+                'How to fix: Add the document interface/type as the generic (e.g., const ref: {{ type }}<UserDoc> = ... or doc<UserDoc>(collection)).',
+            ].join('\n'),
+            invalidGeneric: [
+                'What\'s wrong: {{ type }} uses "any" or an empty object ({}) in its schema generic.',
+                '',
+                'Why it matters: This erases the document schema and disables TypeScript checks on Firestore reads and writes, so malformed payloads and missing fields can pass silently.',
+                '',
+                'How to fix: Define a concrete interface/type for the document (e.g., interface UserDoc { name: string }) and use it as the generic instead of "any" or {}.',
+            ].join('\n'),
         },
     },
     defaultOptions: [],
@@ -61,7 +73,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         }
                         // Prevent infinite recursion
                         typeCache.set(typeName, false);
-                        const program = context.getSourceCode().ast;
+                        const program = context.sourceCode.ast;
                         const interfaceDecl = program.body.find((n) => n.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration &&
                             n.id.name === typeName);
                         if (interfaceDecl) {

package/lib/rules/enforce-firestore-facade.js

@@ -94,7 +94,7 @@ exports.enforceFirestoreFacade = (0, createRule_1.createRule)({
         const firestoreTransactionVariables = new Set();
         const docSetterVariables = new Set();
         const batchManagerVariables = new Set();
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         const clearFirestoreTrackingFor = (name) => {
             firestoreDocRefVariables.delete(name);
             firestoreCollectionVariables.delete(name);
@@ -149,7 +149,9 @@ exports.enforceFirestoreFacade = (0, createRule_1.createRule)({
                 return true;
             }
             if (target.type === utils_1.AST_NODE_TYPES.Identifier &&
-                (target.name === 'transaction' || target.name === 'tx' || target.name === 't')) {
+                (target.name === 'transaction' ||
+                    target.name === 'tx' ||
+                    target.name === 't')) {
                 firestoreTransactionVariables.add(varName);
                 return true;
             }

package/lib/rules/enforce-firestore-set-merge.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceFirestoreSetMerge = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const ASTHelpers_1 = require("../utils/ASTHelpers");
 exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
     name: 'enforce-firestore-set-merge',
     meta: {
@@ -93,9 +94,7 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                             return true;
                         }
                         // Check if it's a Firestore document reference by looking at imports
-                        const program = context
-                            .getAncestors()
-                            .find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
+                        const program = ASTHelpers_1.ASTHelpers.getAncestors(context, node).find((node) => node.type === utils_1.AST_NODE_TYPES.Program);
                         if (program) {
                             for (const node of program.body) {
                                 if (node.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
@@ -212,7 +211,7 @@ exports.enforceFirestoreSetMerge = (0, createRule_1.createRule)({
                         node,
                         messageId: 'preferSetMerge',
                         fix(fixer) {
-                            const newText = convertUpdateToSetMerge(node, context.getSourceCode());
+                            const newText = convertUpdateToSetMerge(node, context.sourceCode);
                             return fixer.replaceText(node, newText);
                         },
                     });

package/lib/rules/enforce-global-constants.js

@@ -9,19 +9,19 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
     meta: {
         type: 'suggestion',
         docs: {
-            description: 'Enforce using global static constants instead of useMemo with empty dependency arrays for object literals, and extract inline destructuring defaults in React components/hooks to global constants',
+            description: 'Enforce global static constants for React components/hooks',
             recommended: 'error',
         },
         fixable: 'code',
         schema: [],
         messages: {
-            useGlobalConstant: 'Use a global static constant instead of useMemo with an empty dependency array for object literals',
-            extractDefaultToGlobalConstant: 'Extract inline default value to a module-level constant for stable reference',
+            useGlobalConstant: 'Object literal returned from useMemo with empty dependencies creates a new reference every render without providing memoization benefits → this wastes memory and misleads readers into thinking the value is computed → move the object to a module-level constant (e.g., const OPTIONS = { ... } as const;).',
+            extractDefaultToGlobalConstant: 'Inline default value in destructuring creates a new reference on every render → this causes unnecessary re-renders in child components due to unstable identity → extract the default to a module-level constant (e.g., const DEFAULT_OPTIONS = { ... } as const;).',
         },
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         function isHookName(name) {
             return /^use[A-Z]/.test(name);
         }

package/lib/rules/enforce-id-capitalization.js

@@ -19,7 +19,7 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            enforceIdCapitalization: 'Use "ID" instead of "id" in user-facing text for better readability',
+            enforceIdCapitalization: 'Found lowercase "id" in user-facing text → "ID" (capitalized) is the standard abbreviation for "identifier" and improves readability in UI labels and messages → replace lowercase "id" with uppercase "ID" in displayed labels and messages.',
         },
     },
     defaultOptions: [],