@checkdigit/eslint-plugin 7.3.0-PR.75-d748 → 7.3.0-PR.93-561f

package/src/agent/add-base-path-const.ts

@@ -1,81 +0,0 @@
-// 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 { strict as assert } from 'node:assert';
-
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getProjectRootFolder, getSwaggerPathByIndexFile, isApiIndexFile, loadPackageJson, loadSwagger } from './file';
-
-export const ruleId = 'add-base-path-const';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addBasePathConst'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add BASE_PATH const variable.',
-    },
-    messages: {
-      addBasePathConst: 'Add BASE_PATH const variable.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      Program: (program: TSESTree.Program) => {
-        if (!isApiIndexFile(context.filename)) {
-          return;
-        }
-
-        const scope = sourceCode.getScope(program).childScopes[0];
-        assert(scope);
-
-        const foundBasePathConst = scope.variables.find((variable) => variable.name === 'BASE_PATH');
-        if (foundBasePathConst) {
-          return;
-        }
-
-        const swaggerPath = getSwaggerPathByIndexFile(context.filename);
-        const swaggerFileContents = loadSwagger(swaggerPath);
-        const baseUrlLine = swaggerFileContents
-          .split('\n')
-          .find((line) => /^\s*-\s*url:\s*\/.*$/u.test(line) || /^basePath:.*/u.test(line));
-        const baseUrl = baseUrlLine?.split(':')[1]?.trim();
-        assert(baseUrl !== undefined);
-
-        const packageRoot = getProjectRootFolder(context.filename);
-        const packageJson = JSON.parse(loadPackageJson(packageRoot)) as { name: string };
-        const serviceName = packageJson.name.split('/')[1];
-        assert(serviceName !== undefined);
-
-        const domain = `https://${serviceName}.checkdigit${baseUrl}`;
-
-        const lastImportStatement = program.body.findLast((node) => node.type === AST_NODE_TYPES.ImportDeclaration);
-        assert(lastImportStatement);
-
-        context.report({
-          messageId: 'addBasePathConst',
-          node: program,
-          fix(fixer) {
-            return fixer.insertTextAfter(lastImportStatement, `\nexport const BASE_PATH = '${domain}';\n`);
-          },
-        });
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/add-base-path-import.ts

@@ -1,69 +0,0 @@
-// 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 { strict as assert } from 'node:assert';
-
-import { AST_NODE_TYPES, ESLintUtils } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getApiIndexPathByFilename } from './file';
-
-export const ruleId = 'add-base-path-import';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addBasePathImport'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add import of BASE_PATH if it is used but not imported.',
-    },
-    messages: {
-      addBasePathImport: 'Add import of BASE_PATH.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      Program: (program) => {
-        const isBasePathUsed = sourceCode.text.includes(`$\{BASE_PATH}`);
-        if (isBasePathUsed) {
-          const topScope = sourceCode.getScope(program).childScopes[0];
-          assert(topScope);
-          if (topScope.variables.some((variable) => variable.name === 'BASE_PATH')) {
-            return;
-          }
-
-          const apiIndexPath = getApiIndexPathByFilename(context.filename);
-          if (apiIndexPath !== undefined) {
-            const lastImportStatement = program.body.findLast(
-              (statement) => statement.type === AST_NODE_TYPES.ImportDeclaration,
-            );
-            assert(lastImportStatement);
-
-            const basePathImportStatement = `\nimport { BASE_PATH } from '${apiIndexPath}';\n`;
-            context.report({
-              node: program,
-              messageId: 'addBasePathImport',
-              fix(fixer) {
-                return fixer.insertTextAfter(lastImportStatement, basePathImportStatement);
-              },
-            });
-          }
-        }
-      },
-    };
-  },
-});
-
-export default rule;

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

@@ -1,76 +0,0 @@
-// 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

@@ -1,246 +0,0 @@
-// 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: [],
-  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 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="afterAll"]': (callExpression: TSESTree.CallExpression) => {
-        afterAll = callExpression;
-      },
-      'Program:exit'(program) {
-        if (!isFixtureUsed || beforeAll === undefined) {
-          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 beforeAllFixer: ((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');
-          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, ');
-          }
-
-          // 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 to `beforeAll` block
-          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);
-              beforeAllFixer = (fixer: RuleFixer) =>
-                fixer.replaceText(
-                  fixtureResetStatement,
-                  [
-                    STATEMENT_AGENT_CREATION,
-                    STATEMENT_AGENT_REGISTER,
-                    STATEMENT_AGENT_ENABLE,
-                    STATEMENT_FIXTURE_RESET_AWAITED,
-                  ].join('\n'),
-                );
-            } else {
-              beforeAllFixer = (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 {
-            const nextToken = sourceCode.getTokenAfter(beforeAll);
-            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 ||
-            beforeAllFixer !== undefined ||
-            afterAllFixer !== undefined
-          ) {
-            context.report({
-              messageId: 'updateTestWiring',
-              node: beforeAll,
-              *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

@@ -1,197 +0,0 @@
-// 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;