@blumintinc/eslint-plugin-blumint 1.9.1 → 1.11.0

package/lib/rules/enforce-callable-types.js

@@ -8,14 +8,14 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
     meta: {
         type: 'problem',
         docs: {
-            description: 'Enforce Params and Response type exports in callable functions',
+            description: 'Enforce Props and Response type exports in callable functions',
             recommended: 'error',
         },
         schema: [],
         messages: {
-            missingParamsType: 'Missing Params type export in callable function file',
+            missingPropsType: 'Missing Props type export in callable function file',
             missingResponseType: 'Missing Response type export in callable function file',
-            unusedParamsType: 'Params type is exported but not used in the callable function',
+            unusedPropsType: 'Props type is exported but not used in the callable function',
             unusedResponseType: 'Response type is exported but not used in the callable function',
         },
     },
@@ -28,18 +28,18 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
             filename.includes('/callable/scripts/')) {
             return {};
         }
-        let hasParamsExport = false;
+        let hasPropsExport = false;
         let hasResponseExport = false;
         let hasCallableFunction = false;
-        let paramsTypeUsed = false;
+        let propsTypeUsed = false;
         let responseTypeUsed = false;
         return {
             // Check for type exports
             ExportNamedDeclaration(node) {
                 if (node.declaration?.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration) {
                     const typeName = node.declaration.id.name;
-                    if (typeName === 'Params') {
-                        hasParamsExport = true;
+                    if (typeName === 'Props') {
+                        hasPropsExport = true;
                     }
                     else if (typeName === 'Response') {
                         hasResponseExport = true;
@@ -56,8 +56,8 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
             // Check for type usage in function parameters and return types
             TSTypeReference(node) {
                 if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                    if (node.typeName.name === 'Params') {
-                        paramsTypeUsed = true;
+                    if (node.typeName.name === 'Props') {
+                        propsTypeUsed = true;
                     }
                     else if (node.typeName.name === 'Response') {
                         responseTypeUsed = true;
@@ -68,16 +68,16 @@ exports.enforceCallableTypes = (0, createRule_1.createRule)({
                 if (!hasCallableFunction) {
                     return;
                 }
-                if (!hasParamsExport) {
+                if (!hasPropsExport) {
                     context.report({
                         loc: { line: 1, column: 0 },
-                        messageId: 'missingParamsType',
+                        messageId: 'missingPropsType',
                     });
                 }
-                else if (!paramsTypeUsed) {
+                else if (!propsTypeUsed) {
                     context.report({
                         loc: { line: 1, column: 0 },
-                        messageId: 'unusedParamsType',
+                        messageId: 'unusedPropsType',
                     });
                 }
                 if (!hasResponseExport) {

package/lib/rules/enforce-callback-memo.js

@@ -43,8 +43,10 @@ exports.default = (0, createRule_1.createRule)({
         function hasJSXWithFunction(node) {
             if (node.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement) {
                 return node.openingElement.attributes.some((attr) => {
-                    if (attr.type === utils_1.TSESTree.AST_NODE_TYPES.JSXAttribute && attr.value) {
-                        if (attr.value.type === utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
+                    if (attr.type === utils_1.TSESTree.AST_NODE_TYPES.JSXAttribute &&
+                        attr.value) {
+                        if (attr.value.type ===
+                            utils_1.TSESTree.AST_NODE_TYPES.JSXExpressionContainer) {
                             return containsFunction(attr.value.expression);
                         }
                     }
@@ -80,7 +82,8 @@ exports.default = (0, createRule_1.createRule)({
                 expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement) &&
                 (containsFunction(expression) || hasJSXWithFunction(expression))) {
                 // Skip reporting if this is a JSX element and we already reported an inline function
-                if (expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement && hasJSXWithFunction(expression)) {
+                if (expression.type === utils_1.TSESTree.AST_NODE_TYPES.JSXElement &&
+                    hasJSXWithFunction(expression)) {
                     return;
                 }
                 context.report({

package/lib/rules/enforce-centralized-mock-firestore.js

@@ -157,7 +157,7 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                             // Find all the lines that need to be removed
                             const linesToRemove = new Set();
                             // Process all nodes that need to be removed
-                            mockFirestoreNodes.forEach(node => {
+                            mockFirestoreNodes.forEach((node) => {
                                 const startLine = sourceCode.getLocFromIndex(node.range[0]).line - 1;
                                 const endLine = sourceCode.getLocFromIndex(node.range[1]).line - 1;
                                 if (node.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclaration) {
@@ -186,21 +186,21 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                             // Replace custom mockFirestore references with the standard one
                             const replacements = [];
                             // Add replacements for custom mockFirestore names
-                            customMockFirestoreCallExpressions.forEach(node => {
+                            customMockFirestoreCallExpressions.forEach((node) => {
                                 if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier) {
                                     replacements.push([
                                         node.callee.range[0],
                                         node.callee.name,
-                                        'mockFirestore'
+                                        'mockFirestore',
                                     ]);
                                 }
                             });
                             // Add replacements for this.mockFirestore
-                            thisExpressions.forEach(expr => {
+                            thisExpressions.forEach((expr) => {
                                 replacements.push([
                                     expr.range[0],
                                     sourceCode.getText(expr),
-                                    'mockFirestore'
+                                    'mockFirestore',
                                 ]);
                             });
                             // Sort replacements in reverse order to avoid range issues
@@ -214,7 +214,9 @@ exports.enforceCentralizedMockFirestore = (0, createRule_1.createRule)({
                                         fixedText.substring(pos + oldText.length);
                             }
                             // Filter out the lines to remove
-                            const fixedLines = fixedText.split('\n').filter((_, i) => !linesToRemove.has(i));
+                            const fixedLines = fixedText
+                                .split('\n')
+                                .filter((_, i) => !linesToRemove.has(i));
                             // Add the import statement at the beginning
                             if (!hasCentralizedImport) {
                                 fixedLines.unshift(importLine);

package/lib/rules/enforce-css-media-queries.js

@@ -59,9 +59,8 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
                 if (node.parent &&
                     node.parent.type === utils_1.AST_NODE_TYPES.ImportDeclaration &&
                     node.imported.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (
                     // Check for useMediaQuery from @mui/material
-                    (node.parent.source.value === '@mui/material' &&
+                    ((node.parent.source.value === '@mui/material' &&
                         node.imported.name === 'useMediaQuery') ||
                         // Check for useMobile from any source
                         node.imported.name === 'useMobile')) {
@@ -74,7 +73,8 @@ exports.enforceCssMediaQueries = (0, createRule_1.createRule)({
             // Check for useMediaQuery and useMobile calls
             CallExpression(node) {
                 if (node.callee.type === utils_1.AST_NODE_TYPES.Identifier &&
-                    (node.callee.name === 'useMediaQuery' || node.callee.name === 'useMobile')) {
+                    (node.callee.name === 'useMediaQuery' ||
+                        node.callee.name === 'useMobile')) {
                     context.report({
                         node,
                         messageId: 'enforceCssMediaQueries',

package/lib/rules/enforce-dynamic-file-naming.d.ts

@@ -0,0 +1,3 @@
+export declare const RULE_NAME = "enforce-dynamic-file-naming";
+declare const _default: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"requireDynamicExtension" | "requireDisableDirective", [], import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export default _default;

package/lib/rules/enforce-dynamic-file-naming.js

@@ -0,0 +1,82 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RULE_NAME = void 0;
+const createRule_1 = require("../utils/createRule");
+const path_1 = __importDefault(require("path"));
+exports.RULE_NAME = 'enforce-dynamic-file-naming';
+exports.default = (0, createRule_1.createRule)({
+    name: exports.RULE_NAME,
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Enforce .dynamic.ts(x) file naming when @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports rule is disabled',
+            recommended: 'error',
+        },
+        schema: [],
+        messages: {
+            requireDynamicExtension: 'Files with disabled @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports rule must use .dynamic.ts(x) extension',
+            requireDisableDirective: 'Files with .dynamic.ts(x) extension must have at least one @blumintinc/blumint/enforce-dynamic-imports or @blumintinc/blumint/require-dynamic-firebase-imports disable directive',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        // Get the file path and name
+        const filePath = context.getFilename();
+        const fileName = path_1.default.basename(filePath);
+        // Check if the file is a TypeScript file (ends with .ts or .tsx)
+        // Ignore files with other extensions like .test.ts, .deprecated.ts, etc.
+        const isTypeScriptFile = /^[^.]+\.tsx?$/.test(fileName);
+        // Check if the file has .dynamic.ts or .dynamic.tsx extension
+        const hasDynamicExtension = /\.dynamic\.tsx?$/.test(fileName);
+        // Skip if not a TypeScript file or has other extensions
+        if (!isTypeScriptFile && !hasDynamicExtension) {
+            return {};
+        }
+        // Track if we found a disable directive for enforce-dynamic-imports
+        let foundDisableDirective = false;
+        return {
+            Program() {
+                // Get the source code
+                const sourceCode = context.getSourceCode();
+                const comments = sourceCode.getAllComments();
+                // Check all comments for disable directives
+                for (const comment of comments) {
+                    const commentText = comment.value.trim();
+                    // Check for inline disable directive for either rule
+                    if ((commentText.includes('eslint-disable-next-line') ||
+                        commentText.includes('ednl')) &&
+                        (commentText.includes('@blumintinc/blumint/enforce-dynamic-imports') ||
+                            commentText.includes('@blumintinc/blumint/require-dynamic-firebase-imports'))) {
+                        foundDisableDirective = true;
+                        break;
+                    }
+                    // Check for block disable directive for either rule
+                    if (commentText.includes('eslint-disable ') &&
+                        (commentText.includes('@blumintinc/blumint/enforce-dynamic-imports') ||
+                            commentText.includes('@blumintinc/blumint/require-dynamic-firebase-imports'))) {
+                        foundDisableDirective = true;
+                        break;
+                    }
+                }
+                // If we found a disable directive but the file doesn't have .dynamic extension
+                if (foundDisableDirective && !hasDynamicExtension) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'requireDynamicExtension',
+                    });
+                }
+                // If the file has .dynamic extension but no disable directive
+                if (hasDynamicExtension && !foundDisableDirective) {
+                    context.report({
+                        loc: { line: 1, column: 0 },
+                        messageId: 'requireDisableDirective',
+                    });
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=enforce-dynamic-file-naming.js.map

package/lib/rules/enforce-dynamic-imports.js

@@ -63,7 +63,7 @@ exports.default = (0, createRule_1.createRule)({
                     }
                     // Check if all specifiers are type imports
                     if (node.specifiers.length > 0 &&
-                        node.specifiers.every(spec => (spec.type === 'ImportSpecifier' && spec.importKind === 'type'))) {
+                        node.specifiers.every((spec) => spec.type === 'ImportSpecifier' && spec.importKind === 'type')) {
                         return;
                     }
                 }

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

@@ -119,19 +119,22 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                     return true;
                 }
                 // Variable declarations with type annotations
-                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator && current.id.typeAnnotation) {
+                if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                    current.id.typeAnnotation) {
                     nodeCache.set(node, true);
                     return true;
                 }
                 // Class property definitions with type annotations
-                if (current.type === utils_1.AST_NODE_TYPES.PropertyDefinition && current.typeAnnotation) {
+                if (current.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
+                    current.typeAnnotation) {
                     nodeCache.set(node, true);
                     return true;
                 }
                 // Return statements in functions with return type annotations
                 if (current.type === utils_1.AST_NODE_TYPES.ReturnStatement) {
                     const func = current.parent?.parent;
-                    if (func?.type === utils_1.AST_NODE_TYPES.FunctionDeclaration && func.returnType) {
+                    if (func?.type === utils_1.AST_NODE_TYPES.FunctionDeclaration &&
+                        func.returnType) {
                         nodeCache.set(node, true);
                         return true;
                     }
@@ -146,7 +149,8 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                             if (classNode) {
                                 const property = classNode.body.body.find((member) => member.type === utils_1.AST_NODE_TYPES.PropertyDefinition &&
                                     member.key.type === utils_1.AST_NODE_TYPES.Identifier &&
-                                    member.key.name === left.property.name);
+                                    member.key.name ===
+                                        left.property.name);
                                 if (property?.typeAnnotation) {
                                     nodeCache.set(node, true);
                                     return true;
@@ -202,7 +206,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'missingGeneric',
-                            data: { type: typeName }
+                            data: { type: typeName },
                         });
                         return;
                     }
@@ -212,7 +216,7 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'invalidGeneric',
-                            data: { type: typeName }
+                            data: { type: typeName },
                         });
                     }
                 }
@@ -231,14 +235,14 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'missingGeneric',
-                            data: { type: 'DocumentReference' }
+                            data: { type: 'DocumentReference' },
                         });
                     }
                     else if (hasInvalidType(typeAnnotation.params[0])) {
                         context.report({
                             node,
                             messageId: 'invalidGeneric',
-                            data: { type: 'DocumentReference' }
+                            data: { type: 'DocumentReference' },
                         });
                     }
                 }
@@ -252,14 +256,14 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'missingGeneric',
-                            data: { type: 'CollectionReference' }
+                            data: { type: 'CollectionReference' },
                         });
                     }
                     else if (hasInvalidType(typeAnnotation.params[0])) {
                         context.report({
                             node,
                             messageId: 'invalidGeneric',
-                            data: { type: 'CollectionReference' }
+                            data: { type: 'CollectionReference' },
                         });
                     }
                 }
@@ -272,14 +276,14 @@ exports.enforceFirestoreDocRefGeneric = (0, createRule_1.createRule)({
                         context.report({
                             node,
                             messageId: 'missingGeneric',
-                            data: { type: 'CollectionGroup' }
+                            data: { type: 'CollectionGroup' },
                         });
                     }
                     else if (hasInvalidType(typeAnnotation.params[0])) {
                         context.report({
                             node,
                             messageId: 'invalidGeneric',
-                            data: { type: 'CollectionGroup' }
+                            data: { type: 'CollectionGroup' },
                         });
                     }
                 }

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

@@ -19,7 +19,9 @@ const isFirestoreMethodCall = (node) => {
     if (isIdentifier(object)) {
         const name = object.name;
         // Skip if it's a facade instance
-        if (name.includes('Fetcher') || name.includes('Setter') || name.includes('Tx')) {
+        if (name.includes('Fetcher') ||
+            name.includes('Setter') ||
+            name.includes('Tx')) {
             return false;
         }
         // Check for batch or transaction
@@ -39,7 +41,8 @@ const isFirestoreMethodCall = (node) => {
             const callee = current.callee;
             if (isMemberExpression(callee)) {
                 const property = callee.property;
-                if (isIdentifier(property) && (property.name === 'doc' || property.name === 'collection')) {
+                if (isIdentifier(property) &&
+                    (property.name === 'doc' || property.name === 'collection')) {
                     foundDocOrCollection = true;
                     break;
                 }
@@ -60,7 +63,8 @@ const isFirestoreMethodCall = (node) => {
     if (!foundDocOrCollection && isIdentifier(object)) {
         const name = object.name;
         // If the variable name contains 'doc' or 'ref', it's likely a Firestore reference
-        if (name.toLowerCase().includes('doc') || name.toLowerCase().includes('ref')) {
+        if (name.toLowerCase().includes('doc') ||
+            name.toLowerCase().includes('ref')) {
             return true;
         }
     }

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

@@ -30,7 +30,8 @@ exports.enforceFirestorePathUtils = (0, createRule_1.createRule)({
             return FIRESTORE_METHODS.has(property.name);
         }
         function isStringLiteralOrTemplate(node) {
-            return (node.type === utils_1.AST_NODE_TYPES.Literal && typeof node.value === 'string' ||
+            return ((node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') ||
                 node.type === utils_1.AST_NODE_TYPES.TemplateLiteral);
         }
         function isUtilityFunction(node) {
@@ -64,7 +65,9 @@ exports.enforceFirestorePathUtils = (0, createRule_1.createRule)({
                 }
                 // Skip test files
                 const filename = context.getFilename();
-                if (filename.includes('__tests__') || filename.includes('.test.') || filename.includes('.spec.')) {
+                if (filename.includes('__tests__') ||
+                    filename.includes('.test.') ||
+                    filename.includes('.spec.')) {
                     return;
                 }
                 context.report({

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

@@ -61,6 +61,55 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
                 node.parent.id === node) {
                 return true;
             }
+            // Check if the node is in an object property context
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.Property &&
+                node.parent.value === node) {
+                // Check if this is a property in an object pattern (destructuring)
+                let currentNode = node.parent;
+                while (currentNode.parent) {
+                    if (currentNode.parent.type === utils_1.AST_NODE_TYPES.ObjectPattern) {
+                        return true;
+                    }
+                    currentNode = currentNode.parent;
+                }
+            }
+            // Check if the node is in a property assignment context
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return true;
+            }
+            // Check if the node is in a property access context
+            if (node.parent && node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression) {
+                return true;
+            }
+            // Check if the node is a string literal used for property access
+            // This handles cases like obj['id'] or OverwolfGame['id']
+            if (node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.parent.computed === true &&
+                node.parent.property === node) {
+                return true;
+            }
+            // Check if the node is a string literal in a type definition context
+            // This handles cases like Pick<Type, 'id' | 'name'>
+            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof node.value === 'string') {
+                let currentNode = node;
+                while (currentNode.parent) {
+                    // Check for TypeScript type contexts
+                    if (currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeReference ||
+                        currentNode.parent.type ===
+                            utils_1.AST_NODE_TYPES.TSTypeParameterInstantiation ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSUnionType ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSIntersectionType ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration ||
+                        currentNode.parent.type === utils_1.AST_NODE_TYPES.TSTypeLiteral) {
+                        return true;
+                    }
+                    currentNode = currentNode.parent;
+                }
+            }
             return false;
         }
         /**
@@ -72,6 +121,16 @@ exports.enforceIdCapitalization = (0, createRule_1.createRule)({
             // Skip checking if the node is in an excluded context
             if (isExcludedContext(node))
                 return;
+            // Check if this is a variable declaration with a string literal containing 'id'
+            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
+                node.parent &&
+                node.parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                node.parent.init === node &&
+                node.parent.id.type === utils_1.AST_NODE_TYPES.Identifier &&
+                node.parent.id.name.toLowerCase().includes('id')) {
+                // Skip checking variable assignments where the variable name contains 'id'
+                return;
+            }
             // Reset the regex lastIndex to ensure consistent behavior
             idRegex.lastIndex = 0;
             // Check if the string contains "id" as a standalone word

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

@@ -67,7 +67,8 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                     const findIdentifiable = (type, checkedTypes = new Set()) => {
                         if (!type)
                             return false;
-                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference && type.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        if (type.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                            type.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
                             const typeName = type.typeName.name;
                             if (typeName === 'Identifiable') {
                                 return true;
@@ -76,19 +77,23 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                                 checkedTypes.add(typeName);
                                 // Look for the type in all scopes
                                 const scope = context.getScope();
-                                const variable = scope.variables.find(v => v.name === typeName);
+                                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) {
+                                    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);
+                                    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) {
+                                        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);
                                         }
                                     }
@@ -97,7 +102,7 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                         }
                         else if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
                             // For intersection types, check each part
-                            return type.types.some(part => findIdentifiable(part, checkedTypes));
+                            return type.types.some((part) => findIdentifiable(part, checkedTypes));
                         }
                         return false;
                     };
@@ -114,7 +119,8 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                             return type.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);
+                                member.typeAnnotation?.typeAnnotation.type ===
+                                    utils_1.AST_NODE_TYPES.TSStringKeyword);
                         }
                         // Check intersection types
                         if (type.type === utils_1.AST_NODE_TYPES.TSIntersectionType) {
@@ -135,7 +141,8 @@ exports.enforceIdentifiableFirestoreType = (0, createRule_1.createRule)({
                             return true;
                         }
                         // Check if type has id: string field (only for utility types)
-                        if (isUtilityType(type) && checkIdField(type.typeParameters.params[0])) {
+                        if (isUtilityType(type) &&
+                            checkIdField(type.typeParameters.params[0])) {
                             return true;
                         }
                         // Check if type is wrapped in a utility type

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

@@ -24,7 +24,7 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
         return {
             ImportDeclaration(node) {
                 if (node.source.value === 'typescript-memoize') {
-                    const memoizeSpecifier = node.specifiers.find(spec => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+                    const memoizeSpecifier = node.specifiers.find((spec) => spec.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
                         spec.imported.name === 'Memoize');
                     if (memoizeSpecifier) {
                         hasMemoizeImport = true;
@@ -46,7 +46,7 @@ exports.enforceMemoizeAsync = (0, createRule_1.createRule)({
                     return;
                 }
                 // Check if method already has @Memoize decorator
-                const hasDecorator = node.decorators?.some(decorator => {
+                const hasDecorator = node.decorators?.some((decorator) => {
                     if (decorator.expression.type !== utils_1.AST_NODE_TYPES.CallExpression) {
                         return false;
                     }