@checkdigit/eslint-plugin 7.5.0 → 7.6.0-PR.75-1b09

package/src/agent/agent-test-wiring.ts

@@ -0,0 +1,273 @@
+// agent/agent-test-wiring.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { strict as assert } from 'node:assert';
+
+import { AST_TOKEN_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import type { RuleFix, RuleFixer } from '@typescript-eslint/utils/ts-eslint';
+import debug from 'debug';
+
+import getDocumentationUrl from '../get-documentation-url';
+
+export const ruleId = 'agent-test-wiring';
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+const log = debug('eslint-plugin:agent:agent-test-wiring');
+
+const STATEMENT_FIXTURE_RESET = 'fixture.reset()';
+const STATEMENT_FIXTURE_RESET_AWAITED = `await ${STATEMENT_FIXTURE_RESET};`;
+const STATEMENT_AGENT_DECLARATION = 'let agent: Agent;';
+const STATEMENT_AGENT_CREATION = 'agent = await createAgent();';
+const STATEMENT_AGENT_REGISTER = 'agent.register(await fixturePlugin(fixture));';
+const STATEMENT_AGENT_ENABLE = 'agent.enable();';
+const STATEMENT_AGENT_DISPOSE = 'await agent[Symbol.asyncDispose]();';
+
+const rule: ESLintUtils.RuleModule<'updateTestWiring' | 'unknownError'> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Update test wiring.',
+    },
+    messages: {
+      updateTestWiring: 'Updating test wiring.',
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  // eslint-disable-next-line max-lines-per-function
+  create(context) {
+    log('Processing file:', context.filename);
+    const sourceCode = context.sourceCode;
+    const importDeclarations = new Map<string, TSESTree.ImportDeclaration>();
+    let isFixtureUsed = false;
+    let beforeAll: TSESTree.CallExpression | undefined;
+    let beforeEach: TSESTree.CallExpression | undefined;
+    let afterAll: TSESTree.CallExpression | undefined;
+
+    return {
+      ImportDeclaration(importDeclaration) {
+        const moduleName = importDeclaration.source.value;
+        importDeclarations.set(moduleName, importDeclaration);
+        if (
+          moduleName === '@checkdigit/fixture' &&
+          importDeclaration.specifiers.some(
+            (specifier) =>
+              specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
+              specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
+              specifier.imported.name === 'createFixture',
+          )
+        ) {
+          isFixtureUsed = true;
+        }
+      },
+      'CallExpression[callee.name="beforeAll"]': (callExpression: TSESTree.CallExpression) => {
+        beforeAll = callExpression;
+      },
+      'CallExpression[callee.name="beforeEach"]': (callExpression: TSESTree.CallExpression) => {
+        beforeEach = callExpression;
+      },
+      'CallExpression[callee.name="afterAll"]': (callExpression: TSESTree.CallExpression) => {
+        afterAll = callExpression;
+      },
+      // eslint-disable-next-line sonarjs/cognitive-complexity
+      'Program:exit'(program) {
+        if (!isFixtureUsed || (beforeAll === undefined && beforeEach === undefined)) {
+          // only update test wiring if fixture is used
+          return;
+        }
+
+        try {
+          let jestImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+          let agentImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+          let fixturePluginImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+          let agentDeclarationFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+          let beforeAllOrEachFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+          let afterAllFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+
+          const lastImportDeclaration = [...importDeclarations.values()].at(-1);
+          assert.ok(lastImportDeclaration);
+
+          // make sure that afterAll is imported from jest
+          const jestImportDeclaration = importDeclarations.get('@jest/globals');
+          assert.ok(jestImportDeclaration);
+          const importsToAdd = ['afterAll', 'beforeAll'].filter(
+            (jestHook) =>
+              !jestImportDeclaration.specifiers.some(
+                (specifier) =>
+                  specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
+                  specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
+                  specifier.imported.name === jestHook,
+              ),
+          );
+          if (importsToAdd.length > 0) {
+            const firstImportSpecifier = jestImportDeclaration.specifiers[0];
+            assert.ok(firstImportSpecifier);
+            jestImportFixer = (fixer: RuleFixer) =>
+              fixer.insertTextBefore(firstImportSpecifier, `${importsToAdd.join(', ')}, `);
+          }
+
+          // make sure that agent is imported
+          const agentImportDeclaration = importDeclarations.get('@checkdigit/agent');
+          if (!agentImportDeclaration) {
+            agentImportFixer = (fixer: RuleFixer) =>
+              fixer.insertTextAfter(
+                lastImportDeclaration,
+                `\nimport createAgent, { type Agent } from '@checkdigit/agent';`,
+              );
+          }
+
+          // make sure that fixture plugin is imported
+          const pathLets = context.filename.split('/');
+          const currentFileIndex = pathLets.length - 1;
+          const pluginFolderIndex = pathLets.lastIndexOf('src') + 1;
+          // it should be safe to assume that the test code is always at least one level deeper than the plugin folder
+          const fixturePluginImportPath = `${'../'.repeat(currentFileIndex - pluginFolderIndex)}plugin/fixture.test`;
+          if (!importDeclarations.get(fixturePluginImportPath)) {
+            fixturePluginImportFixer = (fixer: RuleFixer) =>
+              fixer.insertTextAfter(lastImportDeclaration, `\nimport fixturePlugin from '${fixturePluginImportPath}';`);
+          }
+
+          // inject agent declaration and initialization
+          if (beforeAll === undefined) {
+            // create `beforeAll` block if it doesn't exist
+            beforeAllOrEachFixer = (fixer: RuleFixer) =>
+              fixer.insertTextBefore(
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                beforeEach!,
+                [
+                  STATEMENT_AGENT_DECLARATION,
+                  `beforeAll(async () => {`,
+                  [STATEMENT_AGENT_CREATION, STATEMENT_AGENT_REGISTER, STATEMENT_AGENT_ENABLE].join('\n'),
+                  `});\n`,
+                ].join('\n'),
+              );
+          } else {
+            const beforeAllArgument = beforeAll.arguments[0];
+            assert.ok(beforeAllArgument !== undefined);
+            if (!sourceCode.getText(beforeAllArgument).includes(STATEMENT_AGENT_CREATION)) {
+              if (
+                beforeAllArgument.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression &&
+                beforeAllArgument.body.type === TSESTree.AST_NODE_TYPES.BlockStatement
+              ) {
+                const fixtureResetStatement = beforeAllArgument.body.body.find(
+                  (statement) => sourceCode.getText(statement) === STATEMENT_FIXTURE_RESET_AWAITED,
+                );
+                assert.ok(fixtureResetStatement !== undefined);
+                beforeAllOrEachFixer = (fixer: RuleFixer) =>
+                  fixer.replaceText(
+                    fixtureResetStatement,
+                    [
+                      STATEMENT_AGENT_CREATION,
+                      STATEMENT_AGENT_REGISTER,
+                      STATEMENT_AGENT_ENABLE,
+                      STATEMENT_FIXTURE_RESET_AWAITED,
+                    ].join('\n'),
+                  );
+              } else {
+                beforeAllOrEachFixer = (fixer: RuleFixer) =>
+                  fixer.replaceText(
+                    beforeAllArgument,
+                    [
+                      `async () => {`,
+                      STATEMENT_AGENT_CREATION,
+                      STATEMENT_AGENT_REGISTER,
+                      STATEMENT_AGENT_ENABLE,
+                      STATEMENT_FIXTURE_RESET_AWAITED,
+                      `}`,
+                    ].join('\n'),
+                  );
+              }
+              agentDeclarationFixer = (fixer: RuleFixer) =>
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                fixer.insertTextBefore(beforeAll!, `${STATEMENT_AGENT_DECLARATION}\n`);
+            }
+          }
+
+          // inject agent disposal to `afterAll` block
+          if (afterAll !== undefined) {
+            const afterAllArrowFunctionExpression = afterAll.arguments[0];
+            assert.ok(
+              afterAllArrowFunctionExpression !== undefined &&
+                afterAllArrowFunctionExpression.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
+            );
+            const arrowFunctionBody = afterAllArrowFunctionExpression.body;
+            assert.ok(arrowFunctionBody.type === TSESTree.AST_NODE_TYPES.BlockStatement);
+
+            const afterAllBodyText = sourceCode.getText(arrowFunctionBody);
+            if (!afterAllBodyText.includes(STATEMENT_AGENT_DISPOSE)) {
+              const lastStatement = arrowFunctionBody.body.at(-1);
+              assert.ok(lastStatement);
+              afterAllFixer = (fixer: RuleFixer) => fixer.insertTextAfter(lastStatement, STATEMENT_AGENT_DISPOSE);
+            }
+          } else {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            const nextToken = sourceCode.getTokenAfter(beforeAll ?? beforeEach!);
+            afterAllFixer = (fixer: RuleFixer) =>
+              fixer.insertTextAfter(
+                nextToken !== null && nextToken.type === AST_TOKEN_TYPES.Punctuator
+                  ? nextToken
+                  : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    beforeAll!,
+                ['', `afterAll(async () => {`, STATEMENT_AGENT_DISPOSE, `});`].join('\n'),
+              );
+          }
+
+          if (
+            jestImportFixer !== undefined ||
+            agentImportFixer !== undefined ||
+            fixturePluginImportFixer !== undefined ||
+            agentDeclarationFixer !== undefined ||
+            beforeAllOrEachFixer !== undefined ||
+            afterAllFixer !== undefined
+          ) {
+            context.report({
+              messageId: 'updateTestWiring',
+              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+              node: beforeAll ?? beforeEach!,
+              *fix(fixer) {
+                if (jestImportFixer !== undefined) {
+                  yield jestImportFixer(fixer);
+                }
+                if (agentImportFixer !== undefined) {
+                  yield agentImportFixer(fixer);
+                }
+                if (fixturePluginImportFixer !== undefined) {
+                  yield fixturePluginImportFixer(fixer);
+                }
+                if (agentDeclarationFixer !== undefined) {
+                  yield agentDeclarationFixer(fixer);
+                }
+                if (beforeAllOrEachFixer !== undefined) {
+                  yield beforeAllOrEachFixer(fixer);
+                }
+                if (afterAllFixer !== undefined) {
+                  yield afterAllFixer(fixer);
+                }
+              },
+            });
+          }
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: program,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

package/src/agent/fetch-response-body-json.ts

@@ -0,0 +1,197 @@
+// agent/fetch-response-body-json.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { strict as assert } from 'node:assert';
+
+import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+import getDocumentationUrl from '../get-documentation-url';
+import { getAncestor } from '../library/ts-tree';
+
+export const ruleId = 'fetch-response-body-json';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+interface Change {
+  enclosingFunction: TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration;
+  enclosingStatement: TSESTree.VariableDeclaration | TSESTree.ExpressionStatement | TSESTree.ReturnStatement;
+  enclosingStatementIndex: number;
+  responseBodyNode: TSESTree.MemberExpression;
+  responseVariableName: string;
+  responseBodyVariableName: string;
+  isResponseBodyVariableDeclared: boolean;
+  // replacementText: string;
+}
+
+const rule: ESLintUtils.RuleModule<'unknownError' | 'replaceBodyWithJson' | 'refactorNeeded'> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Replace "response.body" with "await response.json()".',
+    },
+    messages: {
+      refactorNeeded:
+        'Please extract the fetch call and check its reponse status code before accessing its response body.',
+      replaceBodyWithJson: 'Replace "response.body" with "await response.json()".',
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const typeChecker = parserServices.program.getTypeChecker();
+    const allChanges = new Map<TSESTree.Node, Map<string, Change[]>>();
+
+    return {
+      'MemberExpression[property.name="body"]': (responseBodyNode: TSESTree.MemberExpression) => {
+        try {
+          const responseNode = parserServices.esTreeNodeToTSNodeMap.get(responseBodyNode.object);
+          const responseType = typeChecker.getTypeAtLocation(responseNode);
+
+          const shouldReplace =
+            responseType.getProperties().some((symbol) => symbol.name === 'body') &&
+            responseType.getProperties().some((symbol) => symbol.name === 'json');
+
+          if (shouldReplace) {
+            if (responseBodyNode.object.type !== AST_NODE_TYPES.Identifier) {
+              context.report({
+                node: responseBodyNode,
+                messageId: 'refactorNeeded',
+              });
+              return;
+            }
+
+            const enclosingFunction = getAncestor(
+              responseBodyNode,
+              (node: TSESTree.Node) =>
+                node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+                node.type === AST_NODE_TYPES.FunctionExpression ||
+                node.type === AST_NODE_TYPES.FunctionDeclaration,
+            ) as TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression | TSESTree.FunctionDeclaration;
+            const enclosingStatement = getAncestor(
+              responseBodyNode,
+              (node: TSESTree.Node) =>
+                (node.type === AST_NODE_TYPES.VariableDeclaration ||
+                  node.type === AST_NODE_TYPES.ExpressionStatement ||
+                  node.type === AST_NODE_TYPES.ReturnStatement) &&
+                node.parent.type === AST_NODE_TYPES.BlockStatement,
+            ) as TSESTree.VariableDeclaration | TSESTree.ExpressionStatement | TSESTree.ReturnStatement;
+            const enclosingStatementIndex = (enclosingFunction.body as TSESTree.BlockStatement).body.indexOf(
+              enclosingStatement,
+            );
+            const responseVariableName = responseBodyNode.object.name;
+            const isResponseBodyVariableDeclared =
+              enclosingStatement.type === AST_NODE_TYPES.VariableDeclaration &&
+              enclosingStatement.declarations.some(
+                (declaration) =>
+                  declaration.init === responseBodyNode ||
+                  (declaration.init?.type === AST_NODE_TYPES.TSAsExpression &&
+                    declaration.init.expression === responseBodyNode),
+              );
+            const responseBodyVariableName = isResponseBodyVariableDeclared
+              ? (enclosingStatement.declarations.find(
+                  (declaration) =>
+                    declaration.init === responseBodyNode ||
+                    (declaration.init?.type === AST_NODE_TYPES.TSAsExpression &&
+                      declaration.init.expression === responseBodyNode),
+                )?.id as unknown as string)
+              : `${responseBodyNode.object.name}Body`;
+
+            const change: Change = {
+              enclosingFunction,
+              enclosingStatement,
+              enclosingStatementIndex,
+              responseVariableName,
+              responseBodyNode,
+              responseBodyVariableName,
+              isResponseBodyVariableDeclared,
+            };
+
+            const changesByFunction = allChanges.get(enclosingFunction) ?? new Map<string, Change[]>();
+            const changesByResponse = changesByFunction.get(responseVariableName) ?? [];
+            changesByResponse.push(change);
+            changesByFunction.set(responseVariableName, changesByResponse);
+            allChanges.set(enclosingFunction, changesByFunction);
+          }
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: responseBodyNode,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+
+      'Program:exit': () => {
+        if (allChanges.size === 0) {
+          return;
+        }
+
+        const fixes: { node: TSESTree.Node | TSESTree.Token; text: string; insert: boolean }[] = [];
+        for (const changesByFunction of allChanges.values()) {
+          for (const changesByResponse of changesByFunction.values()) {
+            const orderedChanges = changesByResponse.sort(
+              (changeA, changeB) => changeA.enclosingStatementIndex - changeB.enclosingStatementIndex,
+            );
+            const firstChange = orderedChanges[0];
+            assert(firstChange);
+
+            const {
+              responseBodyNode,
+              responseVariableName,
+              responseBodyVariableName,
+              isResponseBodyVariableDeclared,
+              enclosingStatement,
+            } = firstChange;
+
+            let remainingChanges;
+            if (!isResponseBodyVariableDeclared) {
+              fixes.push({
+                node: context.sourceCode.getTokenBefore(enclosingStatement) as TSESTree.Token,
+                text: `\nconst ${responseBodyVariableName} = await ${responseVariableName}.json();`,
+                insert: true,
+              });
+              remainingChanges = orderedChanges;
+            } else {
+              fixes.push({
+                node: responseBodyNode,
+                text: `await ${responseVariableName}.json()`,
+                insert: false,
+              });
+              remainingChanges = orderedChanges.slice(1);
+            }
+
+            for (const change of remainingChanges) {
+              fixes.push({ node: change.responseBodyNode, text: responseBodyVariableName, insert: false });
+            }
+          }
+        }
+
+        for (const fix of fixes.reverse()) {
+          context.report({
+            node: fix.node,
+            messageId: 'replaceBodyWithJson',
+            fix(fixer) {
+              return fix.insert ? fixer.insertTextAfter(fix.node, fix.text) : fixer.replaceText(fix.node, fix.text);
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

package/src/agent/fetch-response-header-getter.ts

@@ -0,0 +1,148 @@
+// agent/fetch-response-header-getter-ts.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+import getDocumentationUrl from '../get-documentation-url';
+
+export const ruleId = 'fetch-response-header-getter-ts';
+const HEADER_BUILTIN_FUNCTIONS = Object.keys(Headers.prototype);
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule: ESLintUtils.RuleModule<'unknownError' | 'useGetter'> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Use "get()" method to get header value from the headers object of the fetch response.',
+    },
+    messages: {
+      useGetter: 'Use "get()" method to get header value from the headers object of the fetch response.',
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const parserServices = ESLintUtils.getParserServices(context);
+    const typeChecker = parserServices.program.getTypeChecker();
+    const sourceCode = context.sourceCode;
+
+    return {
+      MemberExpression: (responseHeadersAccess: TSESTree.MemberExpression) => {
+        try {
+          if (
+            responseHeadersAccess.property.type === AST_NODE_TYPES.Identifier &&
+            HEADER_BUILTIN_FUNCTIONS.includes(responseHeadersAccess.property.name)
+          ) {
+            // skip Headers's built-in function calls
+            return;
+          }
+
+          const responseHeadersTsNode = parserServices.esTreeNodeToTSNodeMap.get(responseHeadersAccess.object);
+          let responseHeadersType = typeChecker.getTypeAtLocation(responseHeadersTsNode);
+          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+          responseHeadersType = responseHeadersType.isUnion() ? responseHeadersType.types[0]! : responseHeadersType;
+          const responseHeadersTypeName = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+            (responseHeadersType.symbol ?? responseHeadersType.aliasSymbol)?.escapedName;
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
+          if (responseHeadersTypeName !== 'Headers' && responseHeadersTypeName !== 'HeaderGetter') {
+            return;
+          }
+
+          let replacementText: string;
+          if (!responseHeadersAccess.computed) {
+            // e.g. headers.etag
+            replacementText = `${sourceCode.getText(responseHeadersAccess.object)}.get('${sourceCode.getText(responseHeadersAccess.property)}')`;
+          } else if (
+            responseHeadersAccess.property.type === AST_NODE_TYPES.Identifier ||
+            responseHeadersAccess.property.type === AST_NODE_TYPES.Literal ||
+            responseHeadersAccess.property.type === AST_NODE_TYPES.TemplateLiteral
+          ) {
+            replacementText = `${sourceCode.getText(responseHeadersAccess.object)}.get(${sourceCode.getText(responseHeadersAccess.property)})`;
+          } else {
+            throw new Error(`Unexpected property type: ${responseHeadersAccess.property.type}`);
+          }
+
+          context.report({
+            messageId: 'useGetter',
+            node: responseHeadersAccess.property,
+            fix(fixer) {
+              return fixer.replaceText(responseHeadersAccess, replacementText);
+            },
+          });
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: responseHeadersAccess,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+
+      // convert response.get() to response.headers.get()
+      'CallExpression[callee.property.name="get"]': (responseHeadersAccess: TSESTree.CallExpression) => {
+        try {
+          if (responseHeadersAccess.callee.type !== AST_NODE_TYPES.MemberExpression) {
+            return;
+          }
+
+          // skip request-like calls
+          if (
+            responseHeadersAccess.callee.object.type !== AST_NODE_TYPES.Identifier ||
+            responseHeadersAccess.callee.object.name === 'request'
+          ) {
+            return;
+          }
+          const responseNode = responseHeadersAccess.callee.object;
+          const responseHeadersTsNode = parserServices.esTreeNodeToTSNodeMap.get(responseNode);
+          const responseType = typeChecker.getTypeAtLocation(responseHeadersTsNode);
+          const typeName = typeChecker.typeToString(responseType);
+          if (typeName === 'InboundContext' || typeName.endsWith('RequestType')) {
+            return;
+          }
+
+          // make sure the response type has "headers" property
+          const hasHeadersProperty = responseType.getProperties().some((symbol) => symbol.name === 'headers');
+          if (!hasHeadersProperty) {
+            return;
+          }
+
+          const replacementText = `${sourceCode.getText(responseNode)}.headers`;
+          context.report({
+            messageId: 'useGetter',
+            node: responseHeadersAccess,
+            fix(fixer) {
+              return fixer.replaceText(responseNode, replacementText);
+            },
+          });
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: responseHeadersAccess,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;