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

package/src/agent/no-supertest.ts

@@ -8,20 +8,9 @@
 
 import { strict as assert } from 'node:assert';
 
-import type {
-  AwaitExpression,
-  CallExpression,
-  Expression,
-  ExpressionStatement,
-  MemberExpression,
-  Node,
-  ObjectExpression,
-  ObjectPattern,
-  ReturnStatement,
-  SimpleCallExpression,
-  VariableDeclaration,
-} from 'estree';
-import { type Rule, type Scope, SourceCode } from 'eslint';
+import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import type { Scope, ScopeManager, Variable } from '@typescript-eslint/scope-manager';
+import type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
 
 import {
   getEnclosingFunction,
@@ -29,7 +18,7 @@ import {
   getEnclosingStatement,
   getParent,
   isUsedInArrayOrAsArgument,
-} from '../library/tree';
+} from '../library/ts-tree';
 import getDocumentationUrl from '../get-documentation-url';
 import { getIndentation } from '../library/format';
 import { analyzeResponseReferences } from './response-reference';
@@ -38,86 +27,91 @@ import { getResponseBodyRetrievalText, getResponseHeadersRetrievalText } from '.
 export const ruleId = 'no-supertest';
 
 interface FixtureCallInformation {
-  rootNode: AwaitExpression | ReturnStatement | VariableDeclaration | SimpleCallExpression | ExpressionStatement;
-  fixtureNode: AwaitExpression | SimpleCallExpression;
-  variableDeclaration?: VariableDeclaration;
-  variableAssignment?: ExpressionStatement;
-  requestBody?: Expression;
-  requestHeaders?: { name: Expression; value: Expression }[];
-  requestHeadersObjectLiteral?: ObjectExpression;
-  assertions?: Expression[][];
-  inlineStatementNode?: Node;
-  inlineBodyReference?: MemberExpression;
-  inlineHeadersReference?: MemberExpression;
+  rootNode:
+    | TSESTree.AwaitExpression
+    | TSESTree.ReturnStatement
+    | TSESTree.VariableDeclaration
+    | TSESTree.CallExpression
+    | TSESTree.ExpressionStatement;
+  fixtureNode: TSESTree.AwaitExpression | TSESTree.CallExpression;
+  variableDeclaration?: TSESTree.VariableDeclaration;
+  variableAssignment?: TSESTree.ExpressionStatement;
+  requestBody?: TSESTree.Expression;
+  requestHeaders?: { name: TSESTree.Expression; value: TSESTree.Expression }[];
+  requestHeadersObjectLiteral?: TSESTree.ObjectExpression;
+  assertions?: TSESTree.Expression[][];
+  inlineStatementNode?: TSESTree.Node;
+  inlineBodyReference?: TSESTree.MemberExpression;
+  inlineHeadersReference?: TSESTree.MemberExpression;
 }
 
 // recursively analyze the fixture/supertest call chain to collect information of request/response
 // eslint-disable-next-line sonarjs/cognitive-complexity
-function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInformation, sourceCode: SourceCode) {
+function analyzeFixtureCall(call: TSESTree.CallExpression, results: FixtureCallInformation, sourceCode: SourceCode) {
   const parent = getParent(call);
   assert.ok(parent, 'parent should exist for fixture/supertest call node');
 
   let nextCall;
-  if (parent.type === 'ReturnStatement') {
+  if (parent.type === AST_NODE_TYPES.ReturnStatement) {
     // direct return, no variable declaration or await
     results.fixtureNode = call;
     results.rootNode = parent;
   } else if (
-    parent.type === 'ArrayExpression' ||
-    parent.type === 'CallExpression' ||
-    parent.type === 'ArrowFunctionExpression'
+    parent.type === AST_NODE_TYPES.ArrayExpression ||
+    parent.type === AST_NODE_TYPES.CallExpression ||
+    parent.type === AST_NODE_TYPES.ArrowFunctionExpression
   ) {
     // direct return, no variable declaration or await
     results.fixtureNode = call;
     results.rootNode = call;
-  } else if (parent.type === 'AwaitExpression') {
+  } else if (parent.type === AST_NODE_TYPES.AwaitExpression) {
     results.fixtureNode = call;
     const enclosingStatement = getEnclosingStatement(parent);
     assert.ok(enclosingStatement);
     const awaitParent = getParent(parent);
-    if (awaitParent?.type === 'MemberExpression') {
+    if (awaitParent?.type === AST_NODE_TYPES.MemberExpression) {
       results.rootNode = parent;
       results.inlineStatementNode = enclosingStatement;
-      if (awaitParent.property.type === 'Identifier' && awaitParent.property.name === 'body') {
+      if (awaitParent.property.type === AST_NODE_TYPES.Identifier && awaitParent.property.name === 'body') {
         results.inlineBodyReference = awaitParent;
       }
       if (
-        awaitParent.property.type === 'Identifier' &&
+        awaitParent.property.type === AST_NODE_TYPES.Identifier &&
         (awaitParent.property.name === 'header' || awaitParent.property.name === 'headers')
       ) {
         results.inlineHeadersReference = awaitParent;
       }
-    } else if (enclosingStatement.type === 'VariableDeclaration') {
+    } else if (enclosingStatement.type === AST_NODE_TYPES.VariableDeclaration) {
       results.variableDeclaration = enclosingStatement;
       results.rootNode = enclosingStatement;
     } else if (
-      enclosingStatement.type === 'ExpressionStatement' &&
-      enclosingStatement.expression.type === 'AssignmentExpression'
+      enclosingStatement.type === AST_NODE_TYPES.ExpressionStatement &&
+      enclosingStatement.expression.type === AST_NODE_TYPES.AssignmentExpression
     ) {
       results.variableAssignment = enclosingStatement;
       results.rootNode = enclosingStatement;
     } else {
       results.rootNode = parent;
     }
-  } else if (parent.type === 'MemberExpression' && parent.property.type === 'Identifier') {
+  } else if (parent.type === AST_NODE_TYPES.MemberExpression && parent.property.type === AST_NODE_TYPES.Identifier) {
     if (parent.property.name === 'expect') {
       // supertest assertions
       const assertionCall = getParent(parent);
-      assert.ok(assertionCall && assertionCall.type === 'CallExpression');
-      results.assertions = [...(results.assertions ?? []), assertionCall.arguments as Expression[]];
+      assert.ok(assertionCall && assertionCall.type === AST_NODE_TYPES.CallExpression);
+      results.assertions = [...(results.assertions ?? []), assertionCall.arguments as TSESTree.Expression[]];
       nextCall = assertionCall;
     } else if (parent.property.name === 'send') {
       // request body
       const sendRequestBodyCall = getParent(parent);
-      assert.ok(sendRequestBodyCall && sendRequestBodyCall.type === 'CallExpression');
-      results.requestBody = sendRequestBodyCall.arguments[0] as Expression;
+      assert.ok(sendRequestBodyCall && sendRequestBodyCall.type === AST_NODE_TYPES.CallExpression);
+      results.requestBody = sendRequestBodyCall.arguments[0] as TSESTree.Expression;
       nextCall = sendRequestBodyCall;
     } else if (parent.property.name === 'set') {
       // request headers
       const setRequestHeaderCall = getParent(parent);
-      assert.ok(setRequestHeaderCall && setRequestHeaderCall.type === 'CallExpression');
-      const [arg1, arg2] = setRequestHeaderCall.arguments as [Expression, Expression];
-      if (arg1.type === 'ObjectExpression') {
+      assert.ok(setRequestHeaderCall && setRequestHeaderCall.type === AST_NODE_TYPES.CallExpression);
+      const [arg1, arg2] = setRequestHeaderCall.arguments as [TSESTree.Expression, TSESTree.Expression];
+      if (arg1.type === AST_NODE_TYPES.ObjectExpression) {
         results.requestHeadersObjectLiteral = arg1;
       } else {
         results.requestHeaders = [...(results.requestHeaders ?? []), { name: arg1, value: arg2 }];
@@ -137,7 +131,7 @@ function createResponseAssertions(
   fixtureCallInformation: FixtureCallInformation,
   sourceCode: SourceCode,
   responseVariableName: string,
-  destructuringResponseHeadersVariable: Scope.Variable | undefined,
+  destructuringResponseHeadersVariable: Variable | undefined,
 ) {
   let statusAssertion: string | undefined;
   const nonStatusAssertions: string[] = [];
@@ -146,20 +140,20 @@ function createResponseAssertions(
       const [assertionArgument] = expectArguments;
       assert.ok(assertionArgument);
       if (
-        (assertionArgument.type === 'MemberExpression' &&
-          assertionArgument.object.type === 'Identifier' &&
+        (assertionArgument.type === AST_NODE_TYPES.MemberExpression &&
+          assertionArgument.object.type === AST_NODE_TYPES.Identifier &&
           assertionArgument.object.name === 'StatusCodes') ||
-        assertionArgument.type === 'Literal' ||
+        assertionArgument.type === AST_NODE_TYPES.Literal ||
         sourceCode.getText(assertionArgument).includes('StatusCodes.')
       ) {
         // status code assertion
         statusAssertion = `assert.equal(${responseVariableName}.status, ${sourceCode.getText(assertionArgument)})`;
-      } else if (assertionArgument.type === 'ArrowFunctionExpression') {
+      } else if (assertionArgument.type === AST_NODE_TYPES.ArrowFunctionExpression) {
         // callback assertion using arrow function
         let functionBody = sourceCode.getText(assertionArgument.body);
 
         const [originalResponseArgument] = assertionArgument.params;
-        assert.ok(originalResponseArgument?.type === 'Identifier');
+        assert.ok(originalResponseArgument?.type === AST_NODE_TYPES.Identifier);
         const originalResponseArgumentName = originalResponseArgument.name;
         if (originalResponseArgumentName !== responseVariableName) {
           functionBody = functionBody.replace(
@@ -168,12 +162,15 @@ function createResponseAssertions(
           );
         }
         nonStatusAssertions.push(`assert.doesNotThrow(()=>${functionBody})`);
-      } else if (assertionArgument.type === 'Identifier') {
+      } else if (assertionArgument.type === AST_NODE_TYPES.Identifier) {
         // callback assertion using function reference
         nonStatusAssertions.push(
           `assert.doesNotThrow(()=>${sourceCode.getText(assertionArgument)}(${responseVariableName}))`,
         );
-      } else if (assertionArgument.type === 'ObjectExpression' || assertionArgument.type === 'CallExpression') {
+      } else if (
+        assertionArgument.type === AST_NODE_TYPES.ObjectExpression ||
+        assertionArgument.type === AST_NODE_TYPES.CallExpression
+      ) {
         // body deep equal assertion
         nonStatusAssertions.push(
           `assert.deepEqual(await ${responseVariableName}.json(), ${sourceCode.getText(assertionArgument)})`,
@@ -189,7 +186,7 @@ function createResponseAssertions(
         destructuringResponseHeadersVariable !== undefined
           ? destructuringResponseHeadersVariable.name
           : `${responseVariableName}.headers`;
-      if (headerValue.type === 'Literal' && headerValue.value instanceof RegExp) {
+      if (headerValue.type === AST_NODE_TYPES.Literal && headerValue.value instanceof RegExp) {
         nonStatusAssertions.push(
           `assert.ok(${headersReference}.get(${sourceCode.getText(headerName)}).match(${sourceCode.getText(headerValue)}))`,
         );
@@ -207,21 +204,22 @@ function createResponseAssertions(
 }
 
 function getResponseVariableNameToUse(
-  scopeManager: Scope.ScopeManager,
+  scopeManager: ScopeManager,
   fixtureCallInformation: FixtureCallInformation,
-  scopeVariablesMap: Map<Scope.Scope, string[]>,
+  scopeVariablesMap: Map<Scope, string[]>,
 ) {
   if (fixtureCallInformation.variableAssignment) {
     assert.ok(
-      fixtureCallInformation.variableAssignment.expression.type === 'AssignmentExpression' &&
-        fixtureCallInformation.variableAssignment.expression.left.type === 'Identifier',
+      fixtureCallInformation.variableAssignment.expression.type === AST_NODE_TYPES.AssignmentExpression &&
+        fixtureCallInformation.variableAssignment.expression.left.type === AST_NODE_TYPES.Identifier,
     );
     return fixtureCallInformation.variableAssignment.expression.left.name;
   }
 
   if (fixtureCallInformation.variableDeclaration) {
     const firstDeclaration = fixtureCallInformation.variableDeclaration.declarations[0];
-    if (firstDeclaration && firstDeclaration.id.type === 'Identifier') {
+    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+    if (firstDeclaration !== undefined && firstDeclaration.id.type === AST_NODE_TYPES.Identifier) {
       return firstDeclaration.id.name;
     }
   }
@@ -250,12 +248,15 @@ function getResponseVariableNameToUse(
   return responseVariableNameToUse;
 }
 
-function isResponseBodyRedefinition(responseBodyReference: MemberExpression): boolean {
+function isResponseBodyRedefinition(responseBodyReference: TSESTree.MemberExpression): boolean {
   const parent = getParent(responseBodyReference);
-  return parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier';
+  return parent?.type === AST_NODE_TYPES.VariableDeclarator && parent.id.type === AST_NODE_TYPES.Identifier;
 }
 
-const rule: Rule.RuleModule = {
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule: ESLintUtils.RuleModule<'unknownError' | 'preferNativeFetch'> = createRule({
+  name: ruleId,
   meta: {
     type: 'suggestion',
     docs: {
@@ -269,46 +270,42 @@ const rule: Rule.RuleModule = {
     fixable: 'code',
     schema: [],
   },
+  defaultOptions: [],
   // eslint-disable-next-line max-lines-per-function
   create(context) {
     const sourceCode = context.sourceCode;
     const scopeManager = sourceCode.scopeManager;
-    const scopeVariablesMap = new Map<Scope.Scope, string[]>();
+    assert.ok(scopeManager !== null);
+    const scopeVariablesMap = new Map<Scope, string[]>();
 
     return {
       // eslint-disable-next-line max-lines-per-function
       'CallExpression[callee.property.name="expect"]': (
-        supertestCall: CallExpression,
+        supertestCall: TSESTree.CallExpression,
         // eslint-disable-next-line sonarjs/cognitive-complexity
       ) => {
-        assert.ok(supertestCall.callee.type === 'MemberExpression');
-        if (
-          supertestCall.callee.object.type === 'CallExpression' &&
-          supertestCall.callee.object.callee.type === 'MemberExpression' &&
-          supertestCall.callee.object.callee.property.type === 'Identifier' &&
-          supertestCall.callee.object.callee.property.name === 'expect'
-        ) {
-          // skip nested expect calls, only focus on the top level
-          return;
-        }
         try {
-          if (isUsedInArrayOrAsArgument(supertestCall) || getEnclosingFunction(supertestCall)?.async === false) {
-            // skip and leave it to "fetch-then" rule to handle it because no "await" can be used here
+          assert.ok(supertestCall.callee.type === AST_NODE_TYPES.MemberExpression);
+          if (
+            supertestCall.callee.object.type !== AST_NODE_TYPES.CallExpression ||
+            (supertestCall.callee.object.callee.type === AST_NODE_TYPES.MemberExpression &&
+              supertestCall.callee.object.callee.property.type === AST_NODE_TYPES.Identifier &&
+              supertestCall.callee.object.callee.property.name === 'expect')
+          ) {
+            // skip nested expect calls, only focus on the top level
             return;
           }
 
-          assert.ok(supertestCall.type === 'CallExpression');
-          const fixtureFunction = supertestCall.callee.object;
-          if (fixtureFunction.type !== 'CallExpression') {
+          if (isUsedInArrayOrAsArgument(supertestCall) || getEnclosingFunction(supertestCall)?.async === false) {
+            // skip and leave it to "fetch-then" rule to handle it because no "await" can be used here
             return;
           }
 
           const indentation = getIndentation(supertestCall, sourceCode);
 
           const fixtureCallInformation = {} as FixtureCallInformation;
+          const fixtureFunction = supertestCall.callee.object;
           analyzeFixtureCall(fixtureFunction, fixtureCallInformation, sourceCode);
-          sourceCode.getText(fixtureCallInformation.fixtureNode);
-          sourceCode.getText(fixtureCallInformation.rootNode);
           fixtureCallInformation.assertions?.flat().map((ass) => sourceCode.getText(ass));
 
           const {
@@ -335,7 +332,7 @@ const rule: Rule.RuleModule = {
           const isResponseHeadersVariableRedefinitionNeeded =
             (destructuringResponseHeadersVariable !== undefined &&
               // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-              (destructuringResponseHeadersVariable as ObjectPattern).type === 'ObjectPattern') ||
+              (destructuringResponseHeadersVariable as TSESTree.ObjectPattern).type === AST_NODE_TYPES.ObjectPattern) ||
             fixtureCallInformation.inlineHeadersReference !== undefined;
           const redefineResponseHeadersVariableName = `${responseVariableNameToUse}Headers`;
 
@@ -352,7 +349,7 @@ const rule: Rule.RuleModule = {
                 ...(destructuringResponseBodyVariable
                   ? [
                       // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                      `${fixtureCallInformation.variableDeclaration?.kind ?? 'const'} ${(destructuringResponseBodyVariable as ObjectPattern).type === 'ObjectPattern' ? sourceCode.getText(destructuringResponseBodyVariable as ObjectPattern) : (destructuringResponseBodyVariable as Scope.Variable).name} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`,
+                      `${fixtureCallInformation.variableDeclaration?.kind ?? 'const'} ${(destructuringResponseBodyVariable as TSESTree.ObjectPattern).type === AST_NODE_TYPES.ObjectPattern ? sourceCode.getText(destructuringResponseBodyVariable as TSESTree.ObjectPattern) : (destructuringResponseBodyVariable as Variable).name} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`,
                     ]
                   : isResponseBodyVariableRedefinitionNeeded
                     ? [
@@ -362,15 +359,16 @@ const rule: Rule.RuleModule = {
                 // eslint-disable-next-line no-nested-ternary
                 ...(destructuringResponseHeadersVariable
                   ? // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                    (destructuringResponseHeadersVariable as ObjectPattern).type === 'ObjectPattern'
-                    ? (destructuringResponseHeadersVariable as ObjectPattern).properties.map((property) => {
-                        assert.ok(property.type === 'Property');
-                        assert.equal(property.value.type, 'Identifier');
+                    (destructuringResponseHeadersVariable as TSESTree.ObjectPattern).type ===
+                    AST_NODE_TYPES.ObjectPattern
+                    ? (destructuringResponseHeadersVariable as TSESTree.ObjectPattern).properties.map((property) => {
+                        assert.ok(property.type === AST_NODE_TYPES.Property);
+                        assert.ok(property.value.type === AST_NODE_TYPES.Identifier);
                         // eslint-disable-next-line sonarjs/no-nested-template-literals
-                        return `${fixtureCallInformation.variableDeclaration?.kind ?? 'const'} ${property.value.name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}.get(${property.key.type === 'Literal' ? sourceCode.getText(property.key) : `'${sourceCode.getText(property.key)}'`})`;
+                        return `${fixtureCallInformation.variableDeclaration?.kind ?? 'const'} ${property.value.name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}.get(${property.key.type === AST_NODE_TYPES.Literal ? sourceCode.getText(property.key) : `'${sourceCode.getText(property.key)}'`})`;
                       })
                     : [
-                        `${fixtureCallInformation.variableDeclaration?.kind ?? 'const'} ${(destructuringResponseHeadersVariable as Scope.Variable).name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}`,
+                        `${fixtureCallInformation.variableDeclaration?.kind ?? 'const'} ${(destructuringResponseHeadersVariable as Variable).name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}`,
                       ]
                   : isResponseHeadersVariableRedefinitionNeeded
                     ? [
@@ -384,7 +382,7 @@ const rule: Rule.RuleModule = {
             fixtureCallInformation,
             sourceCode,
             responseVariableNameToUse,
-            destructuringResponseHeadersVariable as Scope.Variable | undefined,
+            destructuringResponseHeadersVariable as Variable | undefined,
           );
 
           // add variable declaration if needed
@@ -442,12 +440,12 @@ const rule: Rule.RuleModule = {
                 const parent = getParent(responseHeadersReference);
                 assert.ok(parent);
                 let headerName;
-                if (parent.type === 'MemberExpression') {
+                if (parent.type === AST_NODE_TYPES.MemberExpression) {
                   const headerNameNode = parent.property;
                   headerName = parent.computed
                     ? sourceCode.getText(headerNameNode)
                     : `'${sourceCode.getText(headerNameNode)}'`;
-                } else if (parent.type === 'CallExpression') {
+                } else if (parent.type === AST_NODE_TYPES.CallExpression) {
                   const headerNameNode = parent.arguments[0];
                   headerName = sourceCode.getText(headerNameNode);
                 }
@@ -458,7 +456,7 @@ const rule: Rule.RuleModule = {
               // convert response.statusCode to response.status
               for (const responseStatusReference of responseStatusReferences) {
                 if (
-                  responseStatusReference.property.type === 'Identifier' &&
+                  responseStatusReference.property.type === AST_NODE_TYPES.Identifier &&
                   responseStatusReference.property.name === 'statusCode'
                 ) {
                   yield fixer.replaceText(responseStatusReference.property, `status`);
@@ -467,7 +465,7 @@ const rule: Rule.RuleModule = {
 
               // handle direct return statement without await, e.g. "return fixture.api.get(...);"
               if (
-                fixtureCallInformation.rootNode.type === 'ReturnStatement' &&
+                fixtureCallInformation.rootNode.type === AST_NODE_TYPES.ReturnStatement &&
                 fixtureCallInformation.assertions !== undefined
               ) {
                 yield fixer.insertTextAfter(
@@ -492,6 +490,6 @@ const rule: Rule.RuleModule = {
       },
     };
   },
-};
+});
 
 export default rule;

package/src/agent/response-reference.ts

@@ -7,11 +7,12 @@
  */
 
 import { strict as assert } from 'node:assert';
-import type { MemberExpression, ObjectPattern, VariableDeclaration } from 'estree';
-import { type Scope } from 'eslint';
+
 import debug from 'debug';
 
-import { getParent } from '../library/tree';
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
+import type { ScopeManager, Variable } from '@typescript-eslint/scope-manager';
+import { getParent } from '../library/ts-tree';
 
 const log = debug('eslint-plugin:response-reference');
 
@@ -21,25 +22,25 @@ const log = debug('eslint-plugin:response-reference');
  * @param variableDeclaration - variable declaration node
  */
 export function analyzeResponseReferences(
-  variableDeclaration: VariableDeclaration | undefined,
-  scopeManager: Scope.ScopeManager,
+  variableDeclaration: TSESTree.VariableDeclaration | undefined,
+  scopeManager: ScopeManager,
 ): {
-  variable?: Scope.Variable;
-  bodyReferences: MemberExpression[];
-  headersReferences: MemberExpression[];
-  statusReferences: MemberExpression[];
-  destructuringBodyVariable?: Scope.Variable | ObjectPattern;
-  destructuringHeadersVariable?: Scope.Variable | ObjectPattern;
-  destructuringHeadersReferences?: MemberExpression[] | undefined;
+  variable?: Variable;
+  bodyReferences: TSESTree.MemberExpression[];
+  headersReferences: TSESTree.MemberExpression[];
+  statusReferences: TSESTree.MemberExpression[];
+  destructuringBodyVariable?: Variable | TSESTree.ObjectPattern;
+  destructuringHeadersVariable?: Variable | TSESTree.ObjectPattern;
+  destructuringHeadersReferences?: TSESTree.MemberExpression[] | undefined;
 } {
   const results: {
-    variable?: Scope.Variable;
-    bodyReferences: MemberExpression[];
-    headersReferences: MemberExpression[];
-    statusReferences: MemberExpression[];
-    destructuringBodyVariable?: Scope.Variable | ObjectPattern;
-    destructuringHeadersVariable?: Scope.Variable | ObjectPattern;
-    destructuringHeadersReferences?: MemberExpression[] | undefined;
+    variable?: Variable;
+    bodyReferences: TSESTree.MemberExpression[];
+    headersReferences: TSESTree.MemberExpression[];
+    statusReferences: TSESTree.MemberExpression[];
+    destructuringBodyVariable?: Variable | TSESTree.ObjectPattern;
+    destructuringHeadersVariable?: Variable | TSESTree.ObjectPattern;
+    destructuringHeadersReferences?: TSESTree.MemberExpression[] | undefined;
   } = {
     bodyReferences: [],
     headersReferences: [],
@@ -55,7 +56,7 @@ export function analyzeResponseReferences(
     assert.ok(identifier);
     const identifierParent = getParent(identifier);
     assert.ok(identifierParent);
-    if (identifierParent.type === 'VariableDeclarator') {
+    if (identifierParent.type === AST_NODE_TYPES.VariableDeclarator) {
       // e.g. const response = ...
       results.variable = responseVariable;
       const responseReferences = responseVariable.references.map((responseReference) =>
@@ -63,34 +64,36 @@ export function analyzeResponseReferences(
       );
       // e.g. response.body
       results.bodyReferences = responseReferences.filter(
-        (node): node is MemberExpression =>
-          node?.type === 'MemberExpression' && node.property.type === 'Identifier' && node.property.name === 'body',
+        (node): node is TSESTree.MemberExpression =>
+          node?.type === AST_NODE_TYPES.MemberExpression &&
+          node.property.type === AST_NODE_TYPES.Identifier &&
+          node.property.name === 'body',
       );
       // e.g. response.headers / response.header / response.get()
       results.headersReferences = responseReferences.filter(
-        (node): node is MemberExpression =>
-          node?.type === 'MemberExpression' &&
-          node.property.type === 'Identifier' &&
+        (node): node is TSESTree.MemberExpression =>
+          node?.type === AST_NODE_TYPES.MemberExpression &&
+          node.property.type === AST_NODE_TYPES.Identifier &&
           (node.property.name === 'header' || node.property.name === 'headers' || node.property.name === 'get'),
       );
       // e.g. response.status / response.statusCode
       results.statusReferences = responseReferences.filter(
-        (node): node is MemberExpression =>
-          node?.type === 'MemberExpression' &&
-          node.property.type === 'Identifier' &&
+        (node): node is TSESTree.MemberExpression =>
+          node?.type === AST_NODE_TYPES.MemberExpression &&
+          node.property.type === AST_NODE_TYPES.Identifier &&
           (node.property.name === 'status' || node.property.name === 'statusCode'),
       );
     } else if (
       // body reference through destruction/renaming, e.g. "const { body } = ..."
-      identifierParent.type === 'Property' &&
-      identifierParent.key.type === 'Identifier' &&
+      identifierParent.type === AST_NODE_TYPES.Property &&
+      identifierParent.key.type === AST_NODE_TYPES.Identifier &&
       identifierParent.key.name === 'body'
     ) {
       results.destructuringBodyVariable = responseVariable;
     } else if (
       // header reference through destruction/renaming, e.g. "const { headers } = ..."
-      identifierParent.type === 'Property' &&
-      identifierParent.key.type === 'Identifier' &&
+      identifierParent.type === AST_NODE_TYPES.Property &&
+      identifierParent.key.type === AST_NODE_TYPES.Identifier &&
       identifierParent.key.name === 'headers'
     ) {
       results.destructuringHeadersVariable = responseVariable;
@@ -98,23 +101,27 @@ export function analyzeResponseReferences(
         .map((reference) => reference.identifier)
         .map(getParent)
         .filter(
-          (parent): parent is MemberExpression =>
-            parent?.type === 'MemberExpression' &&
-            parent.property.type === 'Identifier' &&
+          (parent): parent is TSESTree.MemberExpression =>
+            parent?.type === AST_NODE_TYPES.MemberExpression &&
+            parent.property.type === AST_NODE_TYPES.Identifier &&
             parent.property.name !== 'get' &&
-            getParent(parent)?.type !== 'CallExpression',
+            getParent(parent)?.type !== AST_NODE_TYPES.CallExpression,
         );
-    } else if (identifierParent.type === 'Property') {
+    } else if (identifierParent.type === AST_NODE_TYPES.Property) {
       const parent = getParent(identifierParent);
-      if (parent?.type === 'ObjectPattern') {
+      if (parent?.type === AST_NODE_TYPES.ObjectPattern) {
         // body reference through nested destruction, e.g. "const { body: {bodyPropertyName: renamedBodyPropertyName}, headers: {headerPropertyName: renamedHeaderPropertyName} } = ..."
         const parent2 = getParent(parent);
-        if (parent2?.type === 'Property' && parent2.key.type === 'Identifier' && parent2.key.name === 'body') {
+        if (
+          parent2?.type === AST_NODE_TYPES.Property &&
+          parent2.key.type === AST_NODE_TYPES.Identifier &&
+          parent2.key.name === 'body'
+        ) {
           results.destructuringBodyVariable = parent;
         }
         if (
-          parent2?.type === 'Property' &&
-          parent2.key.type === 'Identifier' &&
+          parent2?.type === AST_NODE_TYPES.Property &&
+          parent2.key.type === AST_NODE_TYPES.Identifier &&
           (parent2.key.name === 'header' || parent2.key.name === 'headers')
         ) {
           results.destructuringHeadersVariable = parent;