@blumintinc/eslint-plugin-blumint 1.12.6 → 1.14.0

package/lib/rules/no-firestore-jest-mock.js

@@ -1,8 +1,90 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.noFirestoreJestMock = void 0;
+const path_1 = __importDefault(require("path"));
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const FIRESTORE_JEST_MOCK = 'firestore-jest-mock';
+const MOCK_FIRESTORE_TARGET = '__test-utils__/mockFirestore';
+const toPosixPath = (filePath) => filePath.replace(/\\/g, '/');
+const ensureRelativeSpecifier = (specifier) => specifier.startsWith('.') ? specifier : `./${specifier}`;
+const isWindowsDrivePath = (filePath) => /^[A-Za-z]:[\\/]/.test(filePath);
+const isValidRelativePath = (relativePath) => !path_1.default.isAbsolute(relativePath) && !isWindowsDrivePath(relativePath);
+const buildReplacementPath = (sourceFilePath, cwd) => {
+    const absoluteFilename = path_1.default.isAbsolute(sourceFilePath)
+        ? sourceFilePath
+        : path_1.default.join(cwd, sourceFilePath);
+    const targetPath = path_1.default.join(cwd, MOCK_FIRESTORE_TARGET);
+    const relativePath = path_1.default.relative(path_1.default.dirname(absoluteFilename), targetPath);
+    if (!isValidRelativePath(relativePath)) {
+        return '';
+    }
+    return ensureRelativeSpecifier(toPosixPath(relativePath));
+};
+const findVariableDeclarator = (node) => {
+    const { parent } = node;
+    if (parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        return parent;
+    }
+    if (parent?.type === utils_1.AST_NODE_TYPES.AwaitExpression &&
+        parent.parent?.type === utils_1.AST_NODE_TYPES.VariableDeclarator) {
+        return parent.parent;
+    }
+    return null;
+};
+const buildDestructuringFix = (fixer, pattern) => {
+    if (pattern.properties.length !== 1) {
+        return null;
+    }
+    const [property] = pattern.properties;
+    if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+        return null;
+    }
+    if (property.value.type === utils_1.AST_NODE_TYPES.AssignmentPattern) {
+        return null;
+    }
+    if (property.value.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        return null;
+    }
+    const localName = property.value.name;
+    const replacement = localName === 'mockFirestore'
+        ? '{ mockFirestore }'
+        : `{ mockFirestore: ${localName} }`;
+    return fixer.replaceText(pattern, replacement);
+};
+const constructImportStatement = (localName, replacementPath) => {
+    const binding = localName === 'mockFirestore'
+        ? 'mockFirestore'
+        : `mockFirestore as ${localName}`;
+    return `import { ${binding} } from '${replacementPath}';`;
+};
+const getSingleValueImportSpecifier = (node) => {
+    const valueSpecifiers = node.specifiers.filter((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind !== 'type');
+    const hasTypeSpecifiers = node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportSpecifier &&
+        specifier.importKind === 'type');
+    const hasUnsupportedSpecifier = node.specifiers.some((specifier) => specifier.type === utils_1.AST_NODE_TYPES.ImportDefaultSpecifier ||
+        specifier.type === utils_1.AST_NODE_TYPES.ImportNamespaceSpecifier);
+    if (valueSpecifiers.length !== 1 ||
+        hasTypeSpecifiers ||
+        hasUnsupportedSpecifier) {
+        return null;
+    }
+    return valueSpecifiers[0];
+};
+const buildImportDeclarationFix = (node, replacementPath) => {
+    if (!replacementPath) {
+        return null;
+    }
+    const specifier = getSingleValueImportSpecifier(node);
+    if (!specifier) {
+        return null;
+    }
+    return constructImportStatement(specifier.local.name, replacementPath);
+};
 exports.noFirestoreJestMock = (0, createRule_1.createRule)({
     name: 'no-firestore-jest-mock',
     meta: {
@@ -14,38 +96,72 @@ exports.noFirestoreJestMock = (0, createRule_1.createRule)({
         fixable: 'code',
         schema: [],
         messages: {
-            noFirestoreJestMock: 'Do not import from firestore-jest-mock. Use mockFirestore from the centralized mock utility instead.',
+            noFirestoreJestMock: 'What\'s wrong: This test imports "{{moduleName}}" directly → Why it matters: it bypasses the centralized mockFirestore helper that mirrors production schema and keeps seeding/cleanup consistent, which leads to inconsistent data and flaky tests → How to fix: import { mockFirestore } from "{{replacementPath}}" instead.',
         },
     },
     defaultOptions: [],
     create(context) {
-        const filename = context.getFilename();
+        const sourceFilePath = context.getFilename();
         // Only apply rule to test files
-        if (!filename.endsWith('.test.ts')) {
+        if (!sourceFilePath.endsWith('.test.ts')) {
             return {};
         }
+        const cwd = typeof context.getCwd === 'function' ? context.getCwd() : process.cwd();
+        const replacementPath = buildReplacementPath(sourceFilePath, cwd);
+        const messageReplacementPath = replacementPath ||
+            ensureRelativeSpecifier(toPosixPath(MOCK_FIRESTORE_TARGET));
+        const reportData = {
+            moduleName: FIRESTORE_JEST_MOCK,
+            replacementPath: messageReplacementPath,
+        };
         return {
             ImportDeclaration(node) {
                 // Skip type imports completely
                 if (node.importKind === 'type') {
                     return;
                 }
-                if (node.source.value === 'firestore-jest-mock') {
+                if (node.source.value === FIRESTORE_JEST_MOCK) {
                     context.report({
                         node,
                         messageId: 'noFirestoreJestMock',
+                        data: reportData,
                         fix: (fixer) => {
-                            return fixer.replaceText(node, `import { mockFirestore } from '../../../../../__test-utils__/mockFirestore';`);
+                            const replacementImport = buildImportDeclarationFix(node, replacementPath);
+                            if (!replacementImport) {
+                                return null;
+                            }
+                            return fixer.replaceText(node, replacementImport);
                         },
                     });
                 }
             },
             ImportExpression(node) {
                 if (node.source.type === utils_1.AST_NODE_TYPES.Literal &&
-                    node.source.value === 'firestore-jest-mock') {
+                    node.source.value === FIRESTORE_JEST_MOCK) {
+                    const variableDeclarator = findVariableDeclarator(node);
                     context.report({
                         node,
                         messageId: 'noFirestoreJestMock',
+                        data: reportData,
+                        fix: (fixer) => {
+                            if (!replacementPath) {
+                                return null;
+                            }
+                            if (!variableDeclarator) {
+                                return null;
+                            }
+                            if (variableDeclarator.id.type !== utils_1.AST_NODE_TYPES.ObjectPattern) {
+                                return null;
+                            }
+                            const destructuringFix = buildDestructuringFix(fixer, variableDeclarator.id);
+                            if (!destructuringFix) {
+                                return null;
+                            }
+                            return [
+                                fixer.replaceText(node.source, `'${replacementPath}'`),
+                                destructuringFix,
+                            ];
+                        },
                     });
                 }
             },
@@ -58,10 +174,11 @@ exports.noFirestoreJestMock = (0, createRule_1.createRule)({
                     node.callee.property.name === 'mock' &&
                     node.arguments.length > 0 &&
                     node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                    node.arguments[0].value === 'firestore-jest-mock') {
+                    node.arguments[0].value === FIRESTORE_JEST_MOCK) {
                     context.report({
                         node,
                         messageId: 'noFirestoreJestMock',
+                        data: reportData,
                     });
                 }
                 // Check for require('firestore-jest-mock')
@@ -69,10 +186,11 @@ exports.noFirestoreJestMock = (0, createRule_1.createRule)({
                     node.callee.name === 'require' &&
                     node.arguments.length > 0 &&
                     node.arguments[0].type === utils_1.AST_NODE_TYPES.Literal &&
-                    node.arguments[0].value === 'firestore-jest-mock') {
+                    node.arguments[0].value === FIRESTORE_JEST_MOCK) {
                     context.report({
                         node,
                         messageId: 'noFirestoreJestMock',
+                        data: reportData,
                     });
                 }
             },

package/lib/rules/no-firestore-object-arrays.js

@@ -13,44 +13,162 @@ const PRIMITIVE_TYPES = new Set([
     'undefined',
     'GeoPoint',
 ]);
+const UNKNOWN_FIELD_LABEL = '<unknown field>';
 const isInFirestoreTypesDirectory = (filename) => {
-    return filename.includes('functions/src/types/firestore');
+    if (!filename || filename === '<input>')
+        return false;
+    const normalized = filename.replace(/\\/g, '/');
+    if (normalized.includes('/node_modules/') || normalized.includes('/dist/')) {
+        return false;
+    }
+    // Match typical mono/multi-repo layouts
+    return normalized.includes('/types/firestore/');
 };
-const isObjectType = (node) => {
-    switch (node.type) {
-        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
-            return true;
-        case utils_1.AST_NODE_TYPES.TSTypeReference:
-            if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
-                const typeName = node.typeName.name;
-                return !PRIMITIVE_TYPES.has(typeName);
+const getRightmostIdentifierName = (name) => {
+    let cur = name;
+    // Walk rightwards until we reach an Identifier
+    while (cur.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        cur = cur.right;
+    }
+    return cur.name;
+};
+const isArrayGenericReference = (node) => {
+    return (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+        (node.typeName.name === 'Array' || node.typeName.name === 'ReadonlyArray'));
+};
+const isParenthesizedType = (node) => {
+    if (!node || typeof node !== 'object')
+        return false;
+    const candidate = node;
+    return (candidate.type === 'TSParenthesizedType' &&
+        candidate.typeAnnotation !== undefined);
+};
+const unwrapArrayElementType = (node) => {
+    let current = node;
+    // Fixpoint loop: peel wrappers in any order until none remain
+    // Cap unwrap iterations to prevent accidental non-terminating edits if new cases are added.
+    // Wrappers are finite; 10 is generous but safe.
+    for (let i = 0; i < 10; i++) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+            current.operator === 'readonly') {
+            current = current
+                .typeAnnotation;
+            continue;
+        }
+        if (isParenthesizedType(current)) {
+            const paren = current;
+            current = paren.typeAnnotation;
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.TSArrayType) {
+            current = current.elementType;
+            continue;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+            isArrayGenericReference(current) &&
+            current.typeParameters &&
+            current.typeParameters.params.length > 0) {
+            current = current.typeParameters.params[0];
+            continue;
+        }
+        break;
+    }
+    return current;
+};
+const literalToString = (node) => {
+    if (!node || node.type !== utils_1.AST_NODE_TYPES.Literal)
+        return null;
+    const value = node.value;
+    if (typeof value === 'string' ||
+        typeof value === 'number' ||
+        typeof value === 'bigint') {
+        return String(value);
+    }
+    return null;
+};
+/**
+ * Derives a field label for diagnostics by walking ancestors.
+ * Prefers TSPropertySignature keys and returns identifier or string/number/bigint literal keys when present.
+ * Falls back to the surrounding TSTypeAliasDeclaration or TSInterfaceDeclaration name when no property key is available.
+ * This ensures declaration-level array aliases (for example, `type Foo = Object[]`) surface a meaningful label and avoid unlabeled diagnostics.
+ * Returns a placeholder when resolution fails so downstream messaging remains readable.
+ */
+const getFieldName = (node) => {
+    let current = node;
+    while (current) {
+        if (current.type === utils_1.AST_NODE_TYPES.TSPropertySignature) {
+            const key = current.key;
+            if (key.type === utils_1.AST_NODE_TYPES.Identifier)
+                return key.name;
+            const literalKey = literalToString(key);
+            if (literalKey !== null)
+                return literalKey;
+            const computedKey = key;
+            if (computedKey.type === 'TSComputedPropertyName' &&
+                computedKey.expression) {
+                const expr = computedKey.expression;
+                if (expr.type === utils_1.AST_NODE_TYPES.Identifier)
+                    return expr.name;
+                const literalExpr = literalToString(expr);
+                if (literalExpr !== null)
+                    return literalExpr;
             }
-            else if (node.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
-                // Handle namespace.Type cases
-                return true;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+            const id = current.id;
+            if (id.type === utils_1.AST_NODE_TYPES.Identifier) {
+                return id.name;
             }
-            return true;
-        case utils_1.AST_NODE_TYPES.TSIntersectionType:
-        case utils_1.AST_NODE_TYPES.TSUnionType:
-            return node.types.some(isObjectType);
-        case utils_1.AST_NODE_TYPES.TSMappedType:
-        case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
-            return true;
-        default:
+        }
+        current = current.parent;
+    }
+    return UNKNOWN_FIELD_LABEL;
+};
+// Determine whether this type node appears in a Firestore model type context
+// i.e., within an interface or type alias declaration, and not within variable/function annotations
+const isInModelTypeContext = (node) => {
+    let current = node.parent;
+    while (current) {
+        // Hard stop for non-type declaration contexts
+        if (current.type === utils_1.AST_NODE_TYPES.VariableDeclarator ||
+            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.MethodDefinition ||
+            current.type === utils_1.AST_NODE_TYPES.TSMethodSignature ||
+            current.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+            current.type === utils_1.AST_NODE_TYPES.TSParameterProperty) {
             return false;
+        }
+        if (current.type === utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration ||
+            current.type === utils_1.AST_NODE_TYPES.TSInterfaceDeclaration) {
+            return true;
+        }
+        current = current.parent;
     }
+    return false;
 };
 exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
     name: 'no-firestore-object-arrays',
     meta: {
         type: 'problem',
         docs: {
-            description: 'Disallow arrays of objects in Firestore type definitions to optimize performance and avoid unnecessary fetches',
+            description: 'Disallow arrays of object types in Firestore models. Prefer Record maps keyed by id with an index field, or subcollections/arrays of IDs.',
             recommended: 'warn',
+            requiresTypeChecking: false,
         },
         schema: [],
         messages: {
-            noObjectArrays: 'Arrays of objects are not recommended in Firestore. Use subcollections, arrays of IDs, or structured maps (Record<string, T>) instead.',
+            noObjectArrays: [
+                // What's wrong
+                "What's wrong: {{fieldName}} stores an array of objects in a Firestore document.",
+                // Why it matters
+                'Why it matters: Firestore cannot query inside object arrays, and updating one item rewrites the whole array; concurrent writes can overwrite each other and lose data.',
+                // How to fix
+                'How to fix: Store items as Record<string, T> keyed by id with an index field for ordering (use toMap/toArr helpers), or move items into a subcollection or store only an array of IDs.',
+            ].join('\n'),
         },
     },
     defaultOptions: [],
@@ -58,25 +176,277 @@ exports.noFirestoreObjectArrays = (0, createRule_1.createRule)({
         if (!isInFirestoreTypesDirectory(context.getFilename())) {
             return {};
         }
+        const sourceCode = context.sourceCode;
+        // Collect alias/interface/enum information within this file to refine object vs primitive classification
+        const aliasNameToType = new Map();
+        const interfaceNames = new Set();
+        const enumNames = new Set();
+        const visitNode = (n) => {
+            switch (n.type) {
+                case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration: {
+                    aliasNameToType.set(n.id.name, n.typeAnnotation);
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration: {
+                    interfaceNames.add(n.id.name);
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.TSEnumDeclaration: {
+                    enumNames.add(n.id.name);
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.ExportNamedDeclaration: {
+                    if (n.declaration)
+                        visitNode(n.declaration);
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.ExportDefaultDeclaration: {
+                    if (n.declaration) {
+                        visitNode(n.declaration);
+                    }
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.TSExportAssignment: {
+                    if (n.expression) {
+                        visitNode(n.expression);
+                    }
+                    break;
+                }
+                case utils_1.AST_NODE_TYPES.TSModuleDeclaration: {
+                    const body = n.body || null;
+                    if (body && body.type === utils_1.AST_NODE_TYPES.TSModuleBlock) {
+                        for (const stmt of body.body) {
+                            visitNode(stmt);
+                        }
+                    }
+                    else if (body && body.type === utils_1.AST_NODE_TYPES.TSModuleDeclaration) {
+                        visitNode(body);
+                    }
+                    break;
+                }
+                default: {
+                    // Only traverse a shallow subset we care about
+                    break;
+                }
+            }
+        };
+        for (const stmt of sourceCode.ast.body) {
+            visitNode(stmt);
+        }
+        const seenAlias = new Set();
+        const visitingAliases = new Set();
+        const isPrimitiveLikeAlias = (name, recursionDepth) => {
+            if (seenAlias.has(name))
+                return true;
+            if (recursionDepth > 50)
+                return false;
+            if (PRIMITIVE_TYPES.has(name))
+                return true;
+            if (enumNames.has(name))
+                return true; // enums are non-object primitives for our purposes
+            const aliased = aliasNameToType.get(name);
+            if (!aliased)
+                return false;
+            if (visitingAliases.has(name)) {
+                return false;
+            }
+            visitingAliases.add(name);
+            seenAlias.add(name);
+            // Determine if the alias ultimately resolves to only primitive-like/literal types
+            const node = aliased;
+            const result = isPrimitiveLikeTypeNode(node, recursionDepth + 1);
+            visitingAliases.delete(name);
+            if (result) {
+                seenAlias.add(name);
+            }
+            else {
+                // Remove optimistic marking when resolution fails
+                seenAlias.delete(name);
+            }
+            return result;
+        };
+        const isPrimitiveLikeTypeNode = (node, recursionDepth = 0) => {
+            if (recursionDepth > 25) {
+                return false;
+            }
+            if (isParenthesizedType(node)) {
+                const paren = node;
+                return isPrimitiveLikeTypeNode(paren.typeAnnotation, recursionDepth + 1);
+            }
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSStringKeyword:
+                case utils_1.AST_NODE_TYPES.TSNumberKeyword:
+                case utils_1.AST_NODE_TYPES.TSBooleanKeyword:
+                case utils_1.AST_NODE_TYPES.TSNullKeyword:
+                case utils_1.AST_NODE_TYPES.TSUndefinedKeyword:
+                case utils_1.AST_NODE_TYPES.TSNeverKeyword:
+                    return true;
+                case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+                    return false;
+                case utils_1.AST_NODE_TYPES.TSLiteralType:
+                    return true; // string/number/boolean literals
+                case utils_1.AST_NODE_TYPES.TSTypeReference: {
+                    // Allow known primitive-like references and enums or primitive-like aliases
+                    const ref = node;
+                    if (ref.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                        const name = ref.typeName.name;
+                        if (PRIMITIVE_TYPES.has(name) || enumNames.has(name))
+                            return true;
+                        if (seenAlias.has(name))
+                            return true;
+                        return isPrimitiveLikeAlias(name, recursionDepth + 1);
+                    }
+                    if (ref.typeName.type === utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                        const name = getRightmostIdentifierName(ref.typeName);
+                        if (PRIMITIVE_TYPES.has(name) || enumNames.has(name))
+                            return true;
+                        if (seenAlias.has(name))
+                            return true;
+                        return isPrimitiveLikeAlias(name, recursionDepth + 1);
+                    }
+                    return false;
+                }
+                case utils_1.AST_NODE_TYPES.TSUnionType: {
+                    return node.types.every((t) => isPrimitiveLikeTypeNode(t, recursionDepth + 1));
+                }
+                case utils_1.AST_NODE_TYPES.TSTypeOperator: {
+                    // Treat keyof/unique symbol/etc as primitive-like to avoid false positives
+                    if (node.operator !== 'readonly')
+                        return true;
+                    return isPrimitiveLikeTypeNode(node
+                        .typeAnnotation, recursionDepth + 1);
+                }
+                case utils_1.AST_NODE_TYPES.TSTemplateLiteralType: {
+                    // Template literal types behave like strings
+                    return true;
+                }
+                default:
+                    return false;
+            }
+        };
+        const isObjectType = (node) => {
+            if (isParenthesizedType(node)) {
+                const paren = node;
+                return isObjectType(paren.typeAnnotation);
+            }
+            switch (node.type) {
+                case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+                    return true;
+                case utils_1.AST_NODE_TYPES.TSTypeReference: {
+                    const tn = node.typeName;
+                    if (tn.type !== utils_1.AST_NODE_TYPES.Identifier &&
+                        tn.type !== utils_1.AST_NODE_TYPES.TSQualifiedName) {
+                        // Unsupported reference (e.g., ThisType) — do not assume object to avoid false positives
+                        return false;
+                    }
+                    const refName = tn.type === utils_1.AST_NODE_TYPES.Identifier
+                        ? tn.name
+                        : getRightmostIdentifierName(tn);
+                    if (PRIMITIVE_TYPES.has(refName))
+                        return false;
+                    if (interfaceNames.has(refName))
+                        return true;
+                    if (enumNames.has(refName))
+                        return false;
+                    if (aliasNameToType.has(refName)) {
+                        return !isPrimitiveLikeAlias(refName, 0);
+                    }
+                    // Unknown reference: do not assume object to avoid false positives
+                    return false;
+                }
+                case utils_1.AST_NODE_TYPES.TSIntersectionType:
+                case utils_1.AST_NODE_TYPES.TSUnionType:
+                    return node.types.some(isObjectType);
+                case utils_1.AST_NODE_TYPES.TSMappedType:
+                    return true;
+                case utils_1.AST_NODE_TYPES.TSIndexedAccessType:
+                    // Treat indexed access as object-like to align with existing tests
+                    return true;
+                case utils_1.AST_NODE_TYPES.TSTypeOperator:
+                    if (node.operator === 'readonly') {
+                        return isObjectType(node
+                            .typeAnnotation);
+                    }
+                    return false;
+                case utils_1.AST_NODE_TYPES.TSAnyKeyword:
+                case utils_1.AST_NODE_TYPES.TSUnknownKeyword:
+                    return true;
+                default:
+                    return false;
+            }
+        };
+        const skipReadonlyAndParens = (parent) => {
+            let currentParent = parent;
+            while (currentParent) {
+                if (currentParent.type === utils_1.AST_NODE_TYPES.TSTypeOperator &&
+                    currentParent.operator === 'readonly') {
+                    currentParent = currentParent.parent;
+                    continue;
+                }
+                if (isParenthesizedType(currentParent)) {
+                    const paren = currentParent;
+                    currentParent = paren.parent;
+                    continue;
+                }
+                break;
+            }
+            return currentParent;
+        };
+        const isImmediatelyWrappedByArraySyntax = (node) => {
+            const parent = skipReadonlyAndParens(node.parent);
+            if (!parent)
+                return false;
+            if (parent.type === utils_1.AST_NODE_TYPES.TSArrayType)
+                return true;
+            if (parent.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
+                isArrayGenericReference(parent))
+                return true;
+            return false;
+        };
         return {
             TSArrayType(node) {
-                if (isObjectType(node.elementType)) {
+                // Only consider arrays within model type/interface declarations
+                if (!isInModelTypeContext(node)) {
+                    return;
+                }
+                if (isImmediatelyWrappedByArraySyntax(node)) {
+                    return;
+                }
+                const base = unwrapArrayElementType(node.elementType);
+                if (isObjectType(base)) {
                     context.report({
                         node,
                         messageId: 'noObjectArrays',
+                        data: {
+                            fieldName: getFieldName(node),
+                        },
                     });
                 }
             },
             TSTypeReference(node) {
-                // Handle Array<T> and ReadonlyArray<T> syntax
-                const typeName = node.typeName.name;
-                if ((typeName === 'Array' || typeName === 'ReadonlyArray') &&
+                if (node.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
+                    (node.typeName.name === 'Array' ||
+                        node.typeName.name === 'ReadonlyArray') &&
                     node.typeParameters) {
-                    const elementType = node.typeParameters.params[0];
-                    if (isObjectType(elementType)) {
+                    // Only consider arrays within model type/interface declarations
+                    if (!isInModelTypeContext(node)) {
+                        return;
+                    }
+                    if (isImmediatelyWrappedByArraySyntax(node)) {
+                        return;
+                    }
+                    const elementType = node.typeParameters.params[0] ?? null;
+                    if (!elementType)
+                        return;
+                    const base = unwrapArrayElementType(elementType);
+                    if (isObjectType(base)) {
                         context.report({
                             node,
                             messageId: 'noObjectArrays',
+                            data: {
+                                fieldName: getFieldName(node),
+                            },
                         });
                     }
                 }

package/lib/rules/no-handler-suffix.d.ts

@@ -0,0 +1,12 @@
+type Options = [
+    {
+        ignoreClassMethods?: boolean;
+        ignoreInterfaceImplementations?: boolean;
+        interfaceAllowlist?: string[];
+        allowNames?: string[];
+        allowPatterns?: string[];
+        allowFilePatterns?: string[];
+    }
+];
+export declare const noHandlerSuffix: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"handlerSuffix", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export {};