@blumintinc/eslint-plugin-blumint 1.13.0 → 1.14.0

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

@@ -21,7 +21,7 @@ exports.enforceGlobalConstants = (0, createRule_1.createRule)({
     },
     defaultOptions: [],
     create(context) {
-        const sourceCode = context.getSourceCode();
+        const sourceCode = context.sourceCode;
         function isHookName(name) {
             return /^use[A-Z]/.test(name);
         }

package/lib/rules/enforce-identifiable-firestore-type.js

@@ -5,8 +5,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.enforceIdentifiableFirestoreType = void 0;
 const utils_1 = require("@typescript-eslint/utils");
-const createRule_1 = require("../utils/createRule");
 const path_1 = __importDefault(require("path"));
+const createRule_1 = require("../utils/createRule");
+const TRANSPARENT_TYPE_NAMES = new Set(['Readonly', 'Resolve']);
 exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
     name: 'enforce-identifiable-firestore-type',
     meta: {
@@ -63,94 +64,143 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
             TSTypeAliasDeclaration(node) {
                 if (node.id.name === folderName) {
                     hasExpectedType = true;
-                    // Find Identifiable in type's dependencies
+                    const findTypeAliasAnnotation = (typeName) => {
+                        let scope = context.getScope();
+                        while (scope) {
+                            const variable = scope.variables.find((variableNode) => variableNode.name === typeName);
+                            if (variable) {
+                                const definition = variable.defs.find((definition) => definition.node.type ===
+                                    utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
+                                if (definition &&
+                                    definition.node.type ===
+                                        utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration &&
+                                    definition.node.typeAnnotation) {
+                                    return definition.node.typeAnnotation;
+                                }
+                            }
+                            scope = scope.upper;
+                        }
+                        return null;
+                    };
+                    const isParenthesizedType = (node) => node?.type === 'TSParenthesizedType';
+                    const isReadonlyTypeOperator = (node) => node?.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                        node.operator === 'readonly';
+                    const unwrapTransparentType = (typeNode) => {
+                        let current = typeNode;
+                        while (current) {
+                            if (isParenthesizedType(current)) {
+                                const parenthesized = current;
+                                current = parenthesized.typeAnnotation ?? null;
+                                continue;
+                            }
+                            if (isReadonlyTypeOperator(current)) {
+                                current = current.typeAnnotation ?? null;
+                                continue;
+                            }
+                            break;
+                        }
+                        return current ?? null;
+                    };
                     const findIdentifiable = (type, checkedTypes = new Set()) => {
-                        if (!type)
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
                             return false;
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                            const typeName = type.typeName.name;
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = resolvedType.typeName.name;
                             if (typeName === 'Identifiable') {
                                 return true;
                             }
-                            if (!checkedTypes.has(typeName)) {
-                                checkedTypes.add(typeName);
-                                // Look for the type in all scopes
-                                const scope = context.getScope();
-                                const variable = scope.variables.find((v) => v.name === typeName);
-                                if (variable) {
-                                    const def = variable.defs.find((d) => d.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
-                                    if (def &&
-                                        'typeAnnotation' in def.node &&
-                                        def.node.typeAnnotation) {
-                                        return findIdentifiable(def.node.typeAnnotation, checkedTypes);
-                                    }
-                                }
-                                // Try looking in the parent scope
-                                if (scope.upper) {
-                                    const parentVariable = scope.upper.variables.find((v) => v.name === typeName);
-                                    if (parentVariable) {
-                                        const def = parentVariable.defs.find((d) => d.node.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration);
-                                        if (def &&
-                                            'typeAnnotation' in def.node &&
-                                            def.node.typeAnnotation) {
-                                            return findIdentifiable(def.node.typeAnnotation, checkedTypes);
-                                        }
-                                    }
-                                }
+                            if (TRANSPARENT_TYPE_NAMES.has(typeName) &&
+                                resolvedType.typeParameters?.params?.some((param) => findIdentifiable(param, checkedTypes))) {
+                                return true;
+                            }
+                            if (checkedTypes.has(typeName)) {
+                                return false;
                             }
+                            checkedTypes.add(typeName);
+                            const aliasAnnotation = findTypeAliasAnnotation(typeName);
+                            return findIdentifiable(aliasAnnotation, checkedTypes);
                         }
-                        else if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            // For intersection types, check each part
-                            return type.types.some((part) => findIdentifiable(part, checkedTypes));
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => findIdentifiable(part, new Set(checkedTypes)));
                         }
                         return false;
                     };
-                    // Check if type extends Identifiable
-                    const checkIdentifiableExtension = (type) => {
-                        if (!type)
-                            return false;
-                        return findIdentifiable(type);
-                    };
                     // Check if type has id: string field
-                    const checkIdField = (type) => {
-                        // Check for id: string field in type literal
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
-                            return type.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+                    const checkIdField = (type, visitedTypes = new Set()) => {
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
+                            return false;
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                            return resolvedType.members.some((member) => member.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
                                 member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
                                 member.key.name === 'id' &&
                                 member.typeAnnotation?.typeAnnotation.type ===
                                     utils_1.AST_NODE_TYPES.TSStringKeyword);
                         }
-                        // Check intersection types
-                        if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
-                            return type.types.some(checkIdField);
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => checkIdField(part, new Set(visitedTypes)));
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+                            if (resolvedType.typeName.type !== utils_1.AST_NODE_TYPES.Identifier) {
+                                return false;
+                            }
+                            const typeName = resolvedType.typeName.name;
+                            if (typeName === 'Identifiable') {
+                                return true;
+                            }
+                            if (TRANSPARENT_TYPE_NAMES.has(typeName) &&
+                                resolvedType.typeParameters?.params?.some((param) => checkIdField(param, visitedTypes))) {
+                                return true;
+                            }
+                            if (visitedTypes.has(typeName)) {
+                                return false;
+                            }
+                            visitedTypes.add(typeName);
+                            const referencedType = findTypeAliasAnnotation(typeName);
+                            return checkIdField(referencedType, visitedTypes);
                         }
                         return false;
                     };
                     // Check if type is wrapped in a utility type
                     const isUtilityType = (type) => {
+                        if (!type) {
+                            return false;
+                        }
                         return (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
                             type.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
                             type.typeName.name === 'Resolve');
                     };
                     // Recursively check the type and its parameters
-                    const checkType = (type) => {
-                        // Check if type extends Identifiable
-                        if (checkIdentifiableExtension(type)) {
+                    const checkType = (type, visitedTypes = new Set()) => {
+                        const resolvedType = unwrapTransparentType(type);
+                        if (!resolvedType) {
+                            return false;
+                        }
+                        if (findIdentifiable(resolvedType)) {
                             return true;
                         }
-                        // Check if type has id: string field (only for utility types)
-                        if (isUtilityType(type) &&
-                            checkIdField(type.typeParameters.params[0])) {
+                        if (isUtilityType(resolvedType) &&
+                            resolvedType.typeParameters?.params?.[0] &&
+                            checkIdField(resolvedType.typeParameters.params[0])) {
                             return true;
                         }
-                        // Check if type is wrapped in a utility type
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                            type.typeParameters?.params?.[0]) {
-                            return checkType(type.typeParameters.params[0]);
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            resolvedType.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                            const typeName = resolvedType.typeName.name;
+                            if (visitedTypes.has(typeName)) {
+                                return false;
+                            }
+                            visitedTypes.add(typeName);
+                            const aliasAnnotation = findTypeAliasAnnotation(typeName);
+                            return checkType(aliasAnnotation, visitedTypes);
+                        }
+                        if (resolvedType.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
+                            return resolvedType.types.some((part) => checkType(part, new Set(visitedTypes)));
                         }
-                        // For direct type definitions, require extending Identifiable
                         return false;
                     };
                     typeHasIdentifiable = checkType(node.typeAnnotation);

package/lib/rules/enforce-memoize-async.js

@@ -90,7 +90,7 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     messageId: 'requireMemoize',
                     fix(fixer) {
                         const fixes = [];
-                        const sourceCode = context.getSourceCode();
+                        const sourceCode = context.sourceCode;
                         const decoratorIdent = memoizeNamespace
                             ? `${memoizeNamespace}.Memoize`
                             : memoizeAlias;
@@ -122,11 +122,7 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                         const insertionTarget = node.decorators && node.decorators.length > 0
                             ? node.decorators[0]
                             : node;
-                        const insertionStart = insertionTarget.range
-                            ? insertionTarget.range[0]
-                            : node.range
-                                ? node.range[0]
-                                : 0;
+                        const insertionStart = insertionTarget.range?.[0] ?? node.range?.[0] ?? 0;
                         const text = sourceCode.text;
                         const lineStart = text.lastIndexOf('\n', insertionStart - 1) + 1;
                         const leadingWhitespace = text.slice(lineStart, insertionStart).match(/^[ \t]*/)?.[0] ?? '';

package/lib/rules/enforce-memoize-getters.js

@@ -42,7 +42,7 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            requireMemoizeGetter: 'Private getters should be decorated with @Memoize() to preserve instance state and avoid redundant instantiation. Import Memoize from "@blumintinc/typescript-memoize".',
+            requireMemoizeGetter: 'Private getter "{{name}}" should use @Memoize() so repeated accesses reuse the same instance instead of re-instantiating and losing internal state. Add @Memoize() and import Memoize from "@blumintinc/typescript-memoize" to avoid redundant setup work.',
         },
     },
     defaultOptions: [],
@@ -52,17 +52,28 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
         if (!/\.tsx?$/i.test(filename)) {
             return {};
         }
+        const sourceCode = context.getSourceCode();
         let hasMemoizeImport = false;
         let memoizeAlias = 'Memoize';
+        let memoizeNamespace = null;
+        let hasNamedImport = false;
         let scheduledImportFix = false;
         return {
             ImportDeclaration(node) {
                 if (MEMOIZE_MODULES.has(String(node.source.value))) {
-                    const spec = node.specifiers.find((s) => s.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
-                        s.imported.name === 'Memoize');
-                    if (spec) {
-                        hasMemoizeImport = true;
-                        memoizeAlias = spec.local?.name ?? 'Memoize';
+                    for (const spec of node.specifiers) {
+                        if (spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                            spec.imported.name === 'Memoize') {
+                            hasMemoizeImport = true;
+                            hasNamedImport = true;
+                            memoizeAlias = spec.local.name;
+                        }
+                        else if (spec.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier) {
+                            hasMemoizeImport = true;
+                            if (!hasNamedImport) {
+                                memoizeNamespace = spec.local.name;
+                            }
+                        }
                     }
                 }
             },
@@ -76,16 +87,29 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                 // enforce only "private" accessibility (undefined => public)
                 if (node.accessibility !== 'private')
                     return;
-                // Already memoized?
-                const hasDecorator = node.decorators?.some((d) => isMemoizeDecorator(d, memoizeAlias));
+                const decoratorAliases = memoizeAlias === 'Memoize' ? ['Memoize'] : ['Memoize', memoizeAlias];
+                const hasDecorator = node.decorators?.some((decorator) => decoratorAliases.some((alias) => isMemoizeDecorator(decorator, alias)));
                 if (hasDecorator)
                     return;
+                const propertyName = node.computed
+                    ? '[computed]'
+                    : sourceCode.getText(node.key);
                 context.report({
                     node,
                     messageId: 'requireMemoizeGetter',
+                    data: { name: propertyName },
                     fix(fixer) {
                         const fixes = [];
-                        const sourceCode = context.getSourceCode();
+                        const getDecoratorIdent = () => {
+                            if (hasNamedImport) {
+                                return memoizeAlias;
+                            }
+                            if (memoizeNamespace) {
+                                return `${memoizeNamespace}.Memoize`;
+                            }
+                            return memoizeAlias;
+                        };
+                        const decoratorIdent = getDecoratorIdent();
                         // Insert import if needed, at the top alongside other imports
                         if (!hasMemoizeImport && !scheduledImportFix) {
                             const programBody = sourceCode.ast.body;
@@ -106,12 +130,12 @@ exports.enforceMemoizeGetters = (0, createRule_1.createRule)({
                             scheduledImportFix = true;
                         }
                         // Insert decorator above the getter (or before the first decorator), preserving indentation
-                        const indent = ' '.repeat(node.loc.start.column);
-                        const lineStart = node.range
-                            ? sourceCode.text.lastIndexOf('\n', node.range[0] - 1) + 1
-                            : 0;
-                        const insertPosition = Math.max(0, lineStart);
-                        fixes.push(fixer.insertTextBeforeRange([insertPosition, insertPosition], `${indent}@${memoizeAlias}()\n`));
+                        const insertionTarget = node.decorators?.[0] ?? node;
+                        const insertionStart = insertionTarget.range[0];
+                        const text = sourceCode.text;
+                        const lineStart = text.lastIndexOf('\n', insertionStart - 1) + 1;
+                        const leadingWhitespace = text.slice(lineStart, insertionStart).match(/^[ \t]*/)?.[0] ?? '';
+                        fixes.push(fixer.insertTextBeforeRange([lineStart, lineStart], `${leadingWhitespace}@${decoratorIdent}()\n`));
                         return fixes;
                     },
                 });