@checkdigit/eslint-plugin 7.2.0 → 7.3.0-PR.75-aa6d

package/dist-types/agent/no-unused-service-variable.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from '@typescript-eslint/utils';
+export declare const ruleId = "no-unused-service-variable";
+declare const rule: ESLintUtils.RuleModule<'unknownError' | 'removeUnusedServiceVariables'>;
+export default rule;

package/dist-types/agent/response-reference.d.ts

@@ -0,0 +1,16 @@
+import type { MemberExpression, VariableDeclaration } from 'estree';
+import { type Scope } from 'eslint';
+/**
+ * analyze response related variables and their references
+ * the implementation is for fixture API, but it can be used for fetch API as well since the tree structure is similar
+ * @param variableDeclaration - variable declaration node
+ */
+export declare function analyzeResponseReferences(variableDeclaration: VariableDeclaration | undefined, scopeManager: Scope.ScopeManager): {
+    variable?: Scope.Variable;
+    bodyReferences: MemberExpression[];
+    headersReferences: MemberExpression[];
+    statusReferences: MemberExpression[];
+    destructuringBodyVariable?: Scope.Variable;
+    destructuringHeadersVariable?: Scope.Variable;
+    destructuringHeadersReferences?: MemberExpression[] | undefined;
+};

package/dist-types/agent/url.d.ts

@@ -0,0 +1,5 @@
+export declare const PLAIN_URL_REGEXP: RegExp;
+export declare const TOKENIZED_URL_REGEXP: RegExp;
+export declare function replaceEndpointUrlPrefixWithBasePath(url: string): string;
+export declare function replaceEndpointUrlPrefixWithDomain(url: string): string;
+export declare function addBasePathUrlDomain(url: string): string;

package/dist-types/index.d.ts

@@ -1,3 +1,5 @@
 import type { TSESLint } from '@typescript-eslint/utils';
-declare const pluginToExport: TSESLint.FlatConfig.Plugin;
-export default pluginToExport;
+declare const defaultToExport: Exclude<TSESLint.FlatConfig.Plugin, 'config'> & {
+    configs: Record<string, TSESLint.FlatConfig.Config | TSESLint.FlatConfig.Config[]>;
+};
+export default defaultToExport;

package/package.json

@@ -1,96 +1 @@
-{
-  "name": "@checkdigit/eslint-plugin",
-  "version": "7.2.0",
-  "description": "Check Digit eslint plugins",
-  "keywords": [
-    "eslint",
-    "eslintplugin"
-  ],
-  "homepage": "https://github.com/checkdigit/eslint-plugin#readme",
-  "bugs": {
-    "url": "https://github.com/checkdigit/eslint-plugin/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/checkdigit/eslint-plugin"
-  },
-  "license": "MIT",
-  "author": "Check Digit, LLC",
-  "sideEffects": false,
-  "type": "module",
-  "exports": {
-    ".": {
-      "types": "./dist-types/index.d.ts",
-      "import": "./dist-mjs/index.mjs",
-      "default": "./dist-mjs/index.mjs"
-    }
-  },
-  "files": [
-    "src",
-    "dist-types",
-    "dist-mjs",
-    "!src/**/test/**",
-    "!src/**/*.test.ts",
-    "!src/**/*.spec.ts",
-    "!dist-types/**/test/**",
-    "!dist-types/**/*.test.d.ts",
-    "!dist-types/**/*.spec.d.ts",
-    "!dist-mjs/**/test/**",
-    "!dist-mjs/**/*.test.mjs",
-    "!dist-mjs/**/*.spec.mjs",
-    "SECURITY.md"
-  ],
-  "scripts": {
-    "build:dist-mjs": "rimraf dist-mjs && npx builder --type=module --sourceMap --outDir=dist-mjs && node dist-mjs/index.mjs",
-    "build:dist-types": "rimraf dist-types && npx builder --type=types --outDir=dist-types",
-    "ci:compile": "tsc --noEmit",
-    "ci:coverage": "NODE_OPTIONS=\"--disable-warning ExperimentalWarning --experimental-vm-modules\" jest --coverage=true",
-    "ci:lint": "npm run lint",
-    "ci:style": "npm run prettier",
-    "ci:test": "NODE_OPTIONS=\"--disable-warning ExperimentalWarning --experimental-vm-modules\" jest --coverage=false",
-    "lint": "eslint --max-warnings 0 .",
-    "lint:fix": "eslint --max-warnings 0 --fix .",
-    "prepare": "",
-    "prepublishOnly": "npm run build:dist-types && npm run build:dist-mjs",
-    "prettier": "prettier --ignore-path .gitignore --list-different .",
-    "prettier:fix": "prettier --ignore-path .gitignore --write .",
-    "test": "npm run ci:compile && npm run ci:test && npm run ci:lint && npm run ci:style"
-  },
-  "prettier": "@checkdigit/prettier-config",
-  "jest": {
-    "preset": "@checkdigit/jest-config"
-  },
-  "dependencies": {
-    "@typescript-eslint/type-utils": "^8.10.0",
-    "@typescript-eslint/utils": "^8.10.0",
-    "ts-api-utils": "^1.3.0"
-  },
-  "devDependencies": {
-    "@checkdigit/jest-config": "^6.0.2",
-    "@checkdigit/prettier-config": "^5.5.1",
-    "@checkdigit/typescript-config": "^8.0.0",
-    "@eslint/js": "^9.13.0",
-    "@types/eslint": "^9.6.1",
-    "@types/eslint-config-prettier": "^6.11.3",
-    "@typescript-eslint/parser": "^8.10.0",
-    "@typescript-eslint/rule-tester": "^8.10.0",
-    "eslint": "^9.13.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-import-resolver-typescript": "^3.6.3",
-    "eslint-plugin-eslint-plugin": "^6.2.0",
-    "eslint-plugin-import": "^2.31.0",
-    "eslint-plugin-no-only-tests": "^3.3.0",
-    "eslint-plugin-no-secrets": "^1.0.2",
-    "eslint-plugin-node": "^11.1.0",
-    "eslint-plugin-sonarjs": "1.0.4",
-    "http-status-codes": "^2.3.0",
-    "rimraf": "^6.0.1",
-    "typescript-eslint": "^8.10.0"
-  },
-  "peerDependencies": {
-    "eslint": ">=9 <10"
-  },
-  "engines": {
-    "node": ">=20.17"
-  }
-}
+{"name":"@checkdigit/eslint-plugin","version":"7.3.0-PR.75-aa6d","description":"Check Digit eslint plugins","keywords":["eslint","eslintplugin"],"homepage":"https://github.com/checkdigit/eslint-plugin#readme","bugs":{"url":"https://github.com/checkdigit/eslint-plugin/issues"},"repository":{"type":"git","url":"https://github.com/checkdigit/eslint-plugin"},"license":"MIT","author":"Check Digit, LLC","sideEffects":false,"type":"module","exports":{".":{"types":"./dist-types/index.d.ts","import":"./dist-mjs/index.mjs","default":"./dist-mjs/index.mjs"}},"files":["src","dist-types","dist-mjs","!src/**/test/**","!src/**/*.test.ts","!src/**/*.spec.ts","!dist-types/**/test/**","!dist-types/**/*.test.d.ts","!dist-types/**/*.spec.d.ts","!dist-mjs/**/test/**","!dist-mjs/**/*.test.mjs","!dist-mjs/**/*.spec.mjs","SECURITY.md"],"scripts":{"build:dist-mjs":"rimraf dist-mjs && npx builder --type=module --sourceMap --outDir=dist-mjs && node dist-mjs/index.mjs","build:dist-types":"rimraf dist-types && npx builder --type=types --outDir=dist-types","ci:compile":"tsc --noEmit","ci:coverage":"NODE_OPTIONS=\"--disable-warning ExperimentalWarning --experimental-vm-modules\" jest --coverage=true","ci:lint":"npm run lint","ci:style":"npm run prettier","ci:test":"NODE_OPTIONS=\"--disable-warning ExperimentalWarning --experimental-vm-modules\" jest --coverage=false","lint":"eslint --max-warnings 0 .","lint:fix":"eslint --max-warnings 0 --fix .","prepare":"","prepublishOnly":"npm run build:dist-types && npm run build:dist-mjs","prettier":"prettier --ignore-path .gitignore --list-different .","prettier:fix":"prettier --ignore-path .gitignore --write .","test":"npm run ci:compile && npm run ci:test && npm run ci:lint && npm run ci:style"},"prettier":"@checkdigit/prettier-config","jest":{"preset":"@checkdigit/jest-config"},"dependencies":{"@typescript-eslint/type-utils":"8.10.0","@typescript-eslint/utils":"8.10.0","debug":"^4.3.7","ts-api-utils":"^1.3.0"},"devDependencies":{"@checkdigit/jest-config":"^6.0.2","@checkdigit/prettier-config":"^5.5.1","@checkdigit/typescript-config":"^8.0.0","@eslint/js":"^9.13.0","@types/debug":"^4.1.12","@types/eslint":"^9.6.1","@types/eslint-config-prettier":"^6.11.3","@typescript-eslint/parser":"8.10.0","@typescript-eslint/rule-tester":"8.10.0","eslint":"^9.13.0","eslint-config-prettier":"^9.1.0","eslint-import-resolver-typescript":"^3.6.3","eslint-plugin-eslint-plugin":"^6.2.0","eslint-plugin-import":"^2.31.0","eslint-plugin-no-only-tests":"^3.3.0","eslint-plugin-no-secrets":"^1.0.2","eslint-plugin-node":"^11.1.0","eslint-plugin-sonarjs":"1.0.4","http-status-codes":"^2.3.0","rimraf":"^6.0.1","typescript-eslint":"8.10.0"},"peerDependencies":{"eslint":">=9 <10"},"engines":{"node":">=20.17"}}

package/src/agent/add-url-domain.ts

@@ -0,0 +1,76 @@
+// agent/add-url-domain.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';
+import { addBasePathUrlDomain } from './url';
+
+export const ruleId = 'add-url-domain';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule: ESLintUtils.RuleModule<'addDomain' | 'unknownError'> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Add HTTP domain to the BASE_PATH like url constant variable.',
+    },
+    messages: {
+      addDomain: 'Add HTTP domain to the BASE_PATH like url constant variable.',
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      'VariableDeclarator[id.name=/^([A-Z]+_)*BASE_PATH$/]': (basePathDeclarator: TSESTree.VariableDeclarator) => {
+        try {
+          if (
+            basePathDeclarator.init === null ||
+            (basePathDeclarator.init.type !== AST_NODE_TYPES.Literal &&
+              basePathDeclarator.init.type !== AST_NODE_TYPES.TemplateLiteral)
+          ) {
+            return;
+          }
+
+          const urlText = sourceCode.getText(basePathDeclarator.init);
+          const replacement = addBasePathUrlDomain(urlText);
+
+          if (replacement !== urlText) {
+            context.report({
+              messageId: 'addDomain',
+              node: basePathDeclarator.init,
+              fix(fixer) {
+                return fixer.replaceText(basePathDeclarator.init as TSESTree.Node, replacement);
+              },
+            });
+          }
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: basePathDeclarator,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

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

@@ -0,0 +1,204 @@
+// 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 getDocumentationUrl from '../get-documentation-url';
+
+export const ruleId = 'agent-test-wiring';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+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: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const importDeclarations = new Map<string, TSESTree.ImportDeclaration>();
+    let beforeAllCallExpression: TSESTree.CallExpression | undefined;
+    let afterAllCallExpression: TSESTree.CallExpression | undefined;
+
+    return {
+      ImportDeclaration(importDeclaration) {
+        const moduleName = importDeclaration.source.value;
+        importDeclarations.set(moduleName, importDeclaration);
+      },
+      'CallExpression[callee.name="beforeAll"]': (callExpression: TSESTree.CallExpression) => {
+        beforeAllCallExpression = callExpression;
+      },
+      'CallExpression[callee.name="afterAll"]': (callExpression: TSESTree.CallExpression) => {
+        afterAllCallExpression = callExpression;
+      },
+      'Program:exit'(program) {
+        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 beforeAllFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+          let afterAllFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
+
+          const lastImportDeclaration = [...importDeclarations.values()].at(-1);
+          assert.ok(lastImportDeclaration);
+
+          const jestImportDeclaration = importDeclarations.get('@jest/globals');
+          if (
+            jestImportDeclaration &&
+            !jestImportDeclaration.specifiers.some(
+              (specifier) =>
+                specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
+                specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
+                specifier.imported.name === 'afterAll',
+            )
+          ) {
+            const firstImportSpecifier = jestImportDeclaration.specifiers[0];
+            assert.ok(firstImportSpecifier);
+            jestImportFixer = (fixer: RuleFixer) => fixer.insertTextBefore(firstImportSpecifier, 'afterAll, ');
+          }
+
+          const agentImportDeclaration = importDeclarations.get('@checkdigit/agent');
+          if (!agentImportDeclaration) {
+            agentImportFixer = (fixer: RuleFixer) =>
+              fixer.insertTextAfter(
+                lastImportDeclaration,
+                `\nimport createAgent, { type Agent } from '@checkdigit/agent';`,
+              );
+          }
+
+          const fixturePluginImportDeclaration = importDeclarations.get('../../plugin/fixture.test');
+          if (!fixturePluginImportDeclaration) {
+            fixturePluginImportFixer = (fixer: RuleFixer) =>
+              fixer.insertTextAfter(lastImportDeclaration, `\nimport fixturePlugin from '../../plugin/fixture.test';`);
+          }
+
+          if (beforeAllCallExpression !== undefined) {
+            const beforeAllArrowFunctionExpression = beforeAllCallExpression.arguments[0];
+            assert.ok(
+              beforeAllArrowFunctionExpression !== undefined &&
+                beforeAllArrowFunctionExpression.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
+            );
+            const arrowFunctionBody = beforeAllArrowFunctionExpression.body;
+            assert.ok(arrowFunctionBody.type === TSESTree.AST_NODE_TYPES.BlockStatement);
+
+            const targetStatement = arrowFunctionBody.body.find(
+              (statement) => sourceCode.getText(statement) === 'await fixture.reset();',
+            );
+            if (targetStatement !== undefined) {
+              const beforeAllBodyText = sourceCode.getText(arrowFunctionBody);
+              if (!beforeAllBodyText.includes('agent = await createAgent();')) {
+                beforeAllFixer = (fixer: RuleFixer) =>
+                  fixer.replaceText(
+                    targetStatement,
+                    [
+                      'agent = await createAgent();',
+                      'agent.register(await fixturePlugin(fixture));',
+                      'agent.enable();',
+                      'await fixture.reset();',
+                    ].join('\n'),
+                  );
+                agentDeclarationFixer = (fixer: RuleFixer) =>
+                  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                  fixer.insertTextBefore(beforeAllCallExpression!, 'let agent: Agent;\n');
+              }
+            }
+          }
+
+          if (afterAllCallExpression !== undefined) {
+            const afterAllArrowFunctionExpression = afterAllCallExpression.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('await agent[Symbol.asyncDispose]();')) {
+              const lastStatement = arrowFunctionBody.body.at(-1);
+              assert.ok(lastStatement);
+              afterAllFixer = (fixer: RuleFixer) =>
+                fixer.insertTextAfter(lastStatement, 'await agent[Symbol.asyncDispose]();');
+            }
+          } else if (beforeAllCallExpression !== undefined) {
+            const nextToken = sourceCode.getTokenAfter(beforeAllCallExpression);
+            afterAllFixer = (fixer: RuleFixer) =>
+              fixer.insertTextAfter(
+                nextToken !== null && nextToken.type === AST_TOKEN_TYPES.Punctuator
+                  ? nextToken
+                  : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                    beforeAllCallExpression!,
+                `\nafterAll(async () => {
+  await agent[Symbol.asyncDispose]();
+});`,
+              );
+          }
+
+          if (
+            jestImportFixer !== undefined ||
+            agentImportFixer !== undefined ||
+            fixturePluginImportFixer !== undefined ||
+            agentDeclarationFixer !== undefined ||
+            beforeAllFixer !== undefined ||
+            afterAllFixer !== undefined
+          ) {
+            context.report({
+              messageId: 'updateTestWiring',
+              node: program,
+              *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 (beforeAllFixer !== undefined) {
+                  yield beforeAllFixer(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,77 @@
+// 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 { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+
+import getDocumentationUrl from '../get-documentation-url';
+
+export const ruleId = 'fetch-response-body-json';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule: ESLintUtils.RuleModule<'unknownError' | 'replaceBodyWithJson'> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Replace "response.body" with "await response.json()".',
+    },
+    messages: {
+      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 sourceCode = context.sourceCode;
+
+    return {
+      'MemberExpression[property.name="body"]': (responseBody: TSESTree.MemberExpression) => {
+        try {
+          const responseNode = parserServices.esTreeNodeToTSNodeMap.get(responseBody.object);
+          const responseType = typeChecker.getTypeAtLocation(responseNode);
+
+          const shouldReplace =
+            responseType.getProperties().some((symbol) => symbol.name === 'body') &&
+            responseType.getProperties().some((symbol) => symbol.name === 'json');
+
+          if (shouldReplace) {
+            const responseText = sourceCode.getText(responseBody.object);
+            const needAwait = responseBody.parent.type !== AST_NODE_TYPES.ReturnStatement;
+            const replacementText = needAwait ? `(await ${responseText}.json())` : `${responseText}.json()`;
+
+            context.report({
+              messageId: 'replaceBodyWithJson',
+              node: responseBody,
+              fix(fixer) {
+                return fixer.replaceText(responseBody, replacementText);
+              },
+            });
+          }
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: responseBody,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+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;