@checkdigit/eslint-plugin 6.6.0-PR.75-f33d → 6.6.0-PR.75-9891

package/src/fixture/concurrent-promises.ts

@@ -0,0 +1,242 @@
+// fixture/concurrent-promises.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import type { CallExpression, Expression, SimpleCallExpression } from 'estree';
+import { type Rule, SourceCode } from 'eslint';
+import { strict as assert } from 'node:assert';
+import getDocumentationUrl from '../get-documentation-url';
+import { getIndentation } from '../ast/format';
+import { getParent } from '../ast/tree';
+import { isValidPropertyName } from './variable';
+import { replaceEndpointUrlPrefixWithBasePath } from './url';
+
+export const ruleId = 'concurrent-promises';
+
+interface FixtureCallInformation {
+  fixtureNode: SimpleCallExpression;
+  requestBody?: Expression;
+  requestHeaders?: { name: Expression; value: Expression }[];
+  assertions?: Expression[][];
+}
+
+// recursively analyze the fixture/supertest call chain to collect information of request/response
+function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInformation, sourceCode: SourceCode) {
+  const parent = getParent(call);
+  if (!parent) {
+    return;
+  }
+
+  let nextCall;
+  if (parent.type === 'ArrayExpression') {
+    results.fixtureNode = call;
+  } else if (parent.type === 'MemberExpression' && parent.property.type === '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[]];
+      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;
+      nextCall = sendRequestBodyCall;
+    } else if (parent.property.name === 'set') {
+      // request headers
+      const setRequestHeaderCall = getParent(parent);
+      assert.ok(setRequestHeaderCall && setRequestHeaderCall.type === 'CallExpression');
+      const [name, value] = setRequestHeaderCall.arguments as [Expression, Expression];
+      results.requestHeaders = [...(results.requestHeaders ?? []), { name, value }];
+      nextCall = setRequestHeaderCall;
+    }
+  } else {
+    throw new Error(`Unexpected expression in fixture/supertest call ${sourceCode.getText(parent)}.`);
+  }
+  if (nextCall) {
+    analyzeFixtureCall(nextCall, results, sourceCode);
+  }
+}
+
+// eslint-disable-next-line sonarjs/cognitive-complexity
+function createResponseAssertions(
+  fixtureCallInformation: FixtureCallInformation,
+  sourceCode: SourceCode,
+  responseVariableName: string,
+) {
+  let statusAssertion: string | undefined;
+  const nonStatusAssertions: string[] = [];
+  for (const expectArguments of fixtureCallInformation.assertions ?? []) {
+    if (expectArguments.length === 1) {
+      const [assertionArgument] = expectArguments;
+      assert.ok(assertionArgument);
+      if (
+        (assertionArgument.type === 'MemberExpression' &&
+          assertionArgument.object.type === 'Identifier' &&
+          assertionArgument.object.name === 'StatusCodes') ||
+        assertionArgument.type === 'Literal' ||
+        sourceCode.getText(assertionArgument).includes('StatusCodes.')
+      ) {
+        // status code assertion
+        statusAssertion = `assert.equal(${responseVariableName}.status, ${sourceCode.getText(assertionArgument)})`;
+      } else if (assertionArgument.type === 'ArrowFunctionExpression') {
+        // callback assertion using arrow function
+        let functionBody = sourceCode.getText(assertionArgument.body);
+
+        const [originalResponseArgument] = assertionArgument.params;
+        assert.ok(originalResponseArgument?.type === 'Identifier');
+        const originalResponseArgumentName = originalResponseArgument.name;
+        if (originalResponseArgumentName !== responseVariableName) {
+          functionBody = functionBody.replace(
+            new RegExp(`\\b${originalResponseArgumentName}\\b`, 'ug'),
+            responseVariableName,
+          );
+        }
+        nonStatusAssertions.push(`assert.ok(${functionBody})`);
+      } else if (assertionArgument.type === 'Identifier') {
+        // callback assertion using function reference
+        nonStatusAssertions.push(`assert.ok(${sourceCode.getText(assertionArgument)}(${responseVariableName}))`);
+      } else if (assertionArgument.type === 'ObjectExpression' || assertionArgument.type === 'CallExpression') {
+        // body deep equal assertion
+        nonStatusAssertions.push(
+          `assert.deepEqual(await ${responseVariableName}.json(), ${sourceCode.getText(assertionArgument)})`,
+        );
+      } else {
+        throw new Error(`Unexpected Supertest assertion argument: ".expect(${sourceCode.getText(assertionArgument)})`);
+      }
+    } else if (expectArguments.length === 2) {
+      // header assertion
+      const [headerName, headerValue] = expectArguments;
+      assert.ok(headerName && headerValue);
+      const headersReference = `${responseVariableName}.headers`;
+      if (headerValue.type === 'Literal' && headerValue.value instanceof RegExp) {
+        nonStatusAssertions.push(
+          `assert.ok(${headersReference}.get(${sourceCode.getText(headerName)}).match(${sourceCode.getText(headerValue)}))`,
+        );
+      } else {
+        nonStatusAssertions.push(
+          `assert.equal(${headersReference}.get(${sourceCode.getText(headerName)}), ${sourceCode.getText(headerValue)})`,
+        );
+      }
+    }
+  }
+  return {
+    statusAssertion,
+    nonStatusAssertions,
+  };
+}
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Prefer native fetch API over customized fixture API.',
+      url: getDocumentationUrl(ruleId),
+    },
+    messages: {
+      preferNativeFetch: 'Prefer native fetch API over customized fixture API.',
+      unknownError:
+        'Unknown error occurred in file "{{fileName}}": {{ error }}. Please manually convert the fixture API call to fetch API call.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  // eslint-disable-next-line max-lines-per-function
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      // eslint-disable-next-line max-lines-per-function
+      'CallExpression[callee.object.name="Promise"] > ArrayExpression CallExpression[callee.object.object.name="fixture"][callee.object.property.name="api"]':
+        (fixtureCall: CallExpression) => {
+          try {
+            assert.ok(fixtureCall.type === 'CallExpression');
+            const fixtureFunction = fixtureCall.callee; // e.g. fixture.api.get
+            assert.ok(fixtureFunction.type === 'MemberExpression');
+            const indentation = getIndentation(fixtureCall, sourceCode);
+
+            const [urlArgumentNode] = fixtureCall.arguments; // e.g. `/sample-service/v1/ping`
+            assert.ok(urlArgumentNode !== undefined);
+
+            const fixtureCallInformation = {} as FixtureCallInformation;
+            analyzeFixtureCall(fixtureCall, fixtureCallInformation, sourceCode);
+
+            // convert url from `/sample-service/v1/ping` to `${BASE_PATH}/ping`
+            const originalUrlArgumentText = sourceCode.getText(urlArgumentNode);
+            const fetchUrlArgumentText = replaceEndpointUrlPrefixWithBasePath(originalUrlArgumentText);
+
+            // fetch request argument
+            const methodNode = fixtureFunction.property; // get/put/etc.
+            assert.ok(methodNode.type === 'Identifier');
+            const fetchRequestArgumentLines = [
+              '{',
+              `  method: '${methodNode.name.toUpperCase()}',`,
+              ...(fixtureCallInformation.requestBody
+                ? [`  body: JSON.stringify(${sourceCode.getText(fixtureCallInformation.requestBody)}),`]
+                : []),
+              ...(fixtureCallInformation.requestHeaders
+                ? [
+                    `  headers: {`,
+                    ...fixtureCallInformation.requestHeaders.map(
+                      ({ name, value }) =>
+                        // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, no-nested-ternary, sonarjs/no-nested-template-literals
+                        `    ${name.type === 'Literal' ? (isValidPropertyName(name.value) ? name.value : `'${name.value}'`) : `[${sourceCode.getText(name)}]`}: ${sourceCode.getText(value)},`,
+                    ),
+                    `  },`,
+                  ]
+                : []),
+              '}',
+            ].join(`\n${indentation}`);
+
+            const responseVariableNameToUse = 'res';
+            const { statusAssertion, nonStatusAssertions } = createResponseAssertions(
+              fixtureCallInformation,
+              sourceCode,
+              responseVariableNameToUse,
+            );
+
+            // add variable declaration if needed
+            const disableLintComment = '// eslint-disable-next-line @checkdigit/no-promise-instance-method';
+            const fetchCallText = `fetch(${fetchUrlArgumentText}, ${fetchRequestArgumentLines})`;
+            const appendingAssignmentAndAssertionText = [
+              ...(statusAssertion !== undefined ? [statusAssertion] : []),
+              ...nonStatusAssertions,
+            ].join(`;\n${indentation}`);
+            const replacementText = [
+              disableLintComment,
+              `${fetchCallText}.then((${responseVariableNameToUse}) => {`,
+              appendingAssignmentAndAssertionText === '' ? '' : `  ${appendingAssignmentAndAssertionText};`,
+              `  return ${responseVariableNameToUse};`,
+              `})`,
+            ].join(`\n${indentation}`);
+
+            context.report({
+              node: fixtureCall,
+              messageId: 'preferNativeFetch',
+              fix(fixer) {
+                return fixer.replaceText(fixtureCallInformation.fixtureNode, replacementText);
+              },
+            });
+          } catch (error) {
+            // eslint-disable-next-line no-console
+            console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+            context.report({
+              node: fixtureCall,
+              messageId: 'unknownError',
+              data: {
+                fileName: context.filename,
+                error: error instanceof Error ? error.toString() : JSON.stringify(error),
+              },
+            });
+          }
+        },
+    };
+  },
+};
+
+export default rule;

package/src/fixture/fetch-header-getter.ts

@@ -0,0 +1,90 @@
+// fixture/no-fixture.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import type { Identifier, MemberExpression, VariableDeclarator } from 'estree';
+import type { Rule } from 'eslint';
+import { analyzeResponseReferences } from './response-reference';
+import { strict as assert } from 'node:assert';
+import getDocumentationUrl from '../get-documentation-url';
+import { getParent } from '../ast/tree';
+
+export const ruleId = 'fetch-header-getter';
+
+const rule: Rule.RuleModule = {
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Make sure getter is used to access response headers.',
+      url: getDocumentationUrl(ruleId),
+    },
+    messages: {
+      shouldUseHeaderGetter: 'Getter should be used to access response headers.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const scopeManager = sourceCode.scopeManager;
+
+    return {
+      'VariableDeclarator[init.argument.callee.name="fetch"]': (fetchCall: VariableDeclarator) => {
+        const variableDeclaration = getParent(fetchCall);
+        assert.ok(variableDeclaration?.type === 'VariableDeclaration');
+        const { variable: responseVariable, headersReferences: responseHeadersReferences } = analyzeResponseReferences(
+          variableDeclaration,
+          scopeManager,
+        );
+        assert.ok(responseVariable);
+
+        const directHeaderReferences = responseHeadersReferences
+          .map(getParent)
+          .filter((parent): parent is MemberExpression => parent?.type === 'MemberExpression');
+
+        const indirectHeaderReferences = responseHeadersReferences
+          .map((reference) => getParent(reference))
+          .filter((parent): parent is VariableDeclarator => parent?.type === 'VariableDeclarator')
+          .map((declarator) => (declarator.id as Identifier).name)
+          .map((redefinedHeadersVariableName) => {
+            const headersVariable = responseVariable.scope.variables.find((variable) => {
+              const identifier = variable.identifiers[0];
+              return identifier?.type === 'Identifier' && identifier.name === redefinedHeadersVariableName;
+            });
+            return (
+              headersVariable?.references
+                .map((reference) => getParent(reference.identifier))
+                .filter((parent): parent is MemberExpression => parent?.type === 'MemberExpression') ?? []
+            );
+          })
+          .flat();
+
+        const invalidHeaderReferences = [...directHeaderReferences, ...indirectHeaderReferences].filter(
+          (reference) => !(reference.property.type === 'Identifier' && reference.property.name === 'get'),
+        );
+
+        invalidHeaderReferences.forEach((reference) => {
+          const headerNameNode = reference.property;
+          const headerName = reference.computed
+            ? sourceCode.getText(headerNameNode)
+            : `'${sourceCode.getText(headerNameNode)}'`;
+          const replacementText = `${sourceCode.getText(reference.object)}.get(${headerName})`;
+
+          context.report({
+            node: reference,
+            messageId: 'shouldUseHeaderGetter',
+            fix(fixer) {
+              return fixer.replaceText(reference, replacementText);
+            },
+          });
+        });
+      },
+    };
+  },
+};
+
+export default rule;

package/src/fixture/fetch.ts

@@ -0,0 +1,5 @@
+// fixture/fetch.ts
+
+export function getResponseBodyRetrievalText(responseVariableName: string) {
+  return `await ${responseVariableName}.json()`;
+}

package/src/{no-fixture.ts → fixture/no-fixture.ts}

@@ -1,4 +1,4 @@
-// no-fixture.ts
+// fixture/no-fixture.ts
 
 /*
  * Copyright (c) 2021-2024 Check Digit, LLC
@@ -17,10 +17,14 @@ import type {
   VariableDeclaration,
 } from 'estree';
 import { type Rule, type Scope, SourceCode } from 'eslint';
-import { getEnclosingScopeNode, getEnclosingStatement, getParent } from './ast/tree';
+import { getEnclosingScopeNode, getEnclosingStatement, getParent } from '../ast/tree';
+import { analyzeResponseReferences } from './response-reference';
 import { strict as assert } from 'node:assert';
-import getDocumentationUrl from './get-documentation-url';
-import { getIndentation } from './ast/format';
+import getDocumentationUrl from '../get-documentation-url';
+import { getIndentation } from '../ast/format';
+import { getResponseBodyRetrievalText } from './fetch';
+import { isValidPropertyName } from './variable';
+import { replaceEndpointUrlPrefixWithBasePath } from './url';
 
 export const ruleId = 'no-fixture';
 
@@ -42,7 +46,7 @@ function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInfo
 
   let nextCall;
   if (parent.type === 'ReturnStatement') {
-    // direct return, no variable declaration / await
+    // direct return, no variable declaration or await
     results.fixtureNode = call;
     results.rootNode = parent;
   } else if (parent.type === 'AwaitExpression') {
@@ -84,113 +88,13 @@ function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInfo
       nextCall = setRequestHeaderCall;
     }
   } else {
-    throw new Error(`Unexpected expression in fixture/supertest call ${sourceCode.getText(parent)}`);
+    throw new Error(`Unexpected expression in fixture/supertest call ${sourceCode.getText(parent)}.`);
   }
   if (nextCall) {
     analyzeFixtureCall(nextCall, results, sourceCode);
   }
 }
 
-// analyze response related variables and their references0
-function analyzeResponseReferences(fixtureInformation: FixtureCallInformation, scopeManager: Scope.ScopeManager) {
-  const results: {
-    variable?: Scope.Variable;
-    bodyReferences: MemberExpression[];
-    headersReferences: MemberExpression[];
-    statusReferences: MemberExpression[];
-    destructuringBodyVariable?: Scope.Variable;
-    destructuringHeadersVariable?: Scope.Variable;
-    destructuringHeadersReferences?: MemberExpression[] | undefined;
-  } = {
-    bodyReferences: [],
-    headersReferences: [],
-    statusReferences: [],
-  };
-
-  if (fixtureInformation.variableDeclaration) {
-    const responseVariables = scopeManager.getDeclaredVariables(fixtureInformation.variableDeclaration);
-    for (const responseVariable of responseVariables) {
-      const scope = responseVariable.scope;
-      const identifier = responseVariable.identifiers[0];
-      assert.ok(identifier);
-      const identifierParent = getParent(identifier);
-      assert.ok(identifierParent);
-      if (identifierParent.type === 'VariableDeclarator') {
-        // e.g. const response = ...
-        results.variable = responseVariable;
-        const responseReferences = responseVariable.references.map((responseReference) =>
-          getParent(responseReference.identifier),
-        );
-        // e.g. response.body
-        results.bodyReferences = responseReferences.filter(
-          (node): node is MemberExpression =>
-            node !== null &&
-            node !== undefined &&
-            node.type === 'MemberExpression' &&
-            node.property.type === 'Identifier' &&
-            node.property.name === 'body',
-        );
-        // e.g. response.headers / response.header / response.get()
-        results.headersReferences = responseReferences.filter(
-          (node): node is MemberExpression =>
-            node !== null &&
-            node !== undefined &&
-            node.type === 'MemberExpression' &&
-            node.property.type === '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 !== null &&
-            node !== undefined &&
-            node.type === 'MemberExpression' &&
-            node.property.type === '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.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.key.name === 'headers'
-      ) {
-        results.destructuringHeadersVariable = responseVariable;
-        results.destructuringHeadersReferences = scope.set
-          .get(responseVariable.name)
-          ?.references.map((reference) => reference.identifier)
-          .map(getParent)
-          .filter(
-            (parent): parent is MemberExpression =>
-              parent?.type === 'MemberExpression' &&
-              parent.property.type === 'Identifier' &&
-              parent.property.name !== 'get' &&
-              getParent(parent)?.type !== 'CallExpression',
-          );
-      } else {
-        throw new Error(`Unknown response variable reference: ${responseVariable.name}`);
-      }
-    }
-  }
-  return results;
-}
-
-// `/sample-service/v1/ping` -> `${BASE_PATH}/ping`
-function replaceEndpointUrlPrefixWithBasePath(url: string) {
-  // eslint-disable-next-line no-template-curly-in-string
-  return url.replace(/`\/\w+(?<parts>-\w+)*\/v\d+\//u, '`${BASE_PATH}/');
-}
-
-function isValidPropertyName(name: unknown) {
-  return typeof name === 'string' && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/u.test(name);
-}
-
 // eslint-disable-next-line sonarjs/cognitive-complexity
 function createResponseAssertions(
   fixtureCallInformation: FixtureCallInformation,
@@ -304,10 +208,6 @@ function isResponseBodyRedefinition(responseBodyReference: MemberExpression): bo
   return parent?.type === 'VariableDeclarator' && parent.id.type === 'Identifier';
 }
 
-function getResponseBodyRetrievalText(responseVariableName: string) {
-  return `await ${responseVariableName}.json()`;
-}
-
 const rule: Rule.RuleModule = {
   meta: {
     type: 'suggestion',
@@ -353,8 +253,7 @@ const rule: Rule.RuleModule = {
             statusReferences: responseStatusReferences,
             destructuringBodyVariable: destructuringResponseBodyVariable,
             destructuringHeadersVariable: destructuringResponseHeadersVariable,
-            // destructuringHeadersReferences: destructuringResponseHeadersReferences,
-          } = analyzeResponseReferences(fixtureCallInformation, scopeManager);
+          } = analyzeResponseReferences(fixtureCallInformation.variableDeclaration, scopeManager);
 
           // convert url from `/sample-service/v1/ping` to `${BASE_PATH}/ping`
           const originalUrlArgumentText = sourceCode.getText(urlArgumentNode);
@@ -491,19 +390,6 @@ const rule: Rule.RuleModule = {
                 assert.ok(headerName !== undefined);
                 yield fixer.replaceText(parent, `${responseVariableNameToUse}.headers.get(${headerName})`);
               }
-              // if (destructuringResponseHeadersVariable !== undefined) {
-              //   for (const destructuringResponseHeadersReference of destructuringResponseHeadersReferences ?? []) {
-              //     const headerNameNode = destructuringResponseHeadersReference.property;
-              //     const headerName = destructuringResponseHeadersReference.computed
-              //       ? sourceCode.getText(headerNameNode)
-              //       : `'${sourceCode.getText(headerNameNode)}'`;
-
-              //     yield fixer.replaceText(
-              //       destructuringResponseHeadersReference,
-              //       `${destructuringResponseHeadersVariable.name}.get(${headerName})`,
-              //     );
-              //   }
-              // }
 
               // convert response.statusCode to response.status
               for (const responseStatusReference of responseStatusReferences) {

package/src/fixture/response-reference.ts

@@ -0,0 +1,108 @@
+// fixture/response-reference.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import type { MemberExpression, VariableDeclaration } from 'estree';
+import { type Scope } from 'eslint';
+import { strict as assert } from 'node:assert';
+import { getParent } from '../ast/tree';
+
+/**
+ * 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 function analyzeResponseReferences(
+  variableDeclaration: VariableDeclaration | undefined,
+  scopeManager: Scope.ScopeManager,
+) {
+  const results: {
+    variable?: Scope.Variable;
+    bodyReferences: MemberExpression[];
+    headersReferences: MemberExpression[];
+    statusReferences: MemberExpression[];
+    destructuringBodyVariable?: Scope.Variable;
+    destructuringHeadersVariable?: Scope.Variable;
+    destructuringHeadersReferences?: MemberExpression[] | undefined;
+  } = {
+    bodyReferences: [],
+    headersReferences: [],
+    statusReferences: [],
+  };
+  if (!variableDeclaration) {
+    return results;
+  }
+
+  const responseVariables = scopeManager.getDeclaredVariables(variableDeclaration);
+  for (const responseVariable of responseVariables) {
+    const identifier = responseVariable.identifiers[0];
+    assert.ok(identifier);
+    const identifierParent = getParent(identifier);
+    assert.ok(identifierParent);
+    if (identifierParent.type === 'VariableDeclarator') {
+      // e.g. const response = ...
+      results.variable = responseVariable;
+      const responseReferences = responseVariable.references.map((responseReference) =>
+        getParent(responseReference.identifier),
+      );
+      // e.g. response.body
+      results.bodyReferences = responseReferences.filter(
+        (node): node is MemberExpression =>
+          node !== null &&
+          node !== undefined &&
+          node.type === 'MemberExpression' &&
+          node.property.type === 'Identifier' &&
+          node.property.name === 'body',
+      );
+      // e.g. response.headers / response.header / response.get()
+      results.headersReferences = responseReferences.filter(
+        (node): node is MemberExpression =>
+          node !== null &&
+          node !== undefined &&
+          node.type === 'MemberExpression' &&
+          node.property.type === '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 !== null &&
+          node !== undefined &&
+          node.type === 'MemberExpression' &&
+          node.property.type === '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.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.key.name === 'headers'
+    ) {
+      results.destructuringHeadersVariable = responseVariable;
+      results.destructuringHeadersReferences = responseVariable.references
+        .map((reference) => reference.identifier)
+        .map(getParent)
+        .filter(
+          (parent): parent is MemberExpression =>
+            parent?.type === 'MemberExpression' &&
+            parent.property.type === 'Identifier' &&
+            parent.property.name !== 'get' &&
+            getParent(parent)?.type !== 'CallExpression',
+        );
+    } else {
+      throw new Error(`Unknown response variable reference: ${responseVariable.name}`);
+    }
+  }
+  return results;
+}

package/src/fixture/url.ts

@@ -0,0 +1,6 @@
+// fixture/url.ts
+
+export function replaceEndpointUrlPrefixWithBasePath(url: string) {
+  // eslint-disable-next-line no-template-curly-in-string
+  return url.replace(/`\/\w+(?<parts>-\w+)*\/v\d+\//u, '`${BASE_PATH}/');
+}

package/src/fixture/variable.ts

@@ -0,0 +1,5 @@
+// fixture/variable.ts
+
+export function isValidPropertyName(name: unknown) {
+  return typeof name === 'string' && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/u.test(name);
+}

package/src/index.ts

@@ -6,9 +6,10 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
+import concurrentPromises, { ruleId as concurrentPromisesRuleId } from './fixture/concurrent-promises';
+import fetchHeaderGetter, { ruleId as fetchHeaderGetterRuleId } from './fixture/fetch-header-getter';
 import invalidJsonStringify, { ruleId as invalidJsonStringifyRuleId } from './invalid-json-stringify';
-import noFixture, { ruleId as noFixtureRuleId } from './no-fixture';
-import noFixtureHeaders, { ruleId as noFixtureHeadersRuleId } from './no-fixture-headers';
+import noFixture, { ruleId as noFixtureRuleId } from './fixture/no-fixture';
 import noPromiseInstanceMethod, { ruleId as noPromiseInstanceMethodRuleId } from './no-promise-instance-method';
 import filePathComment from './file-path-comment';
 import noCardNumbers from './no-card-numbers';
@@ -34,7 +35,8 @@ export default {
     [invalidJsonStringifyRuleId]: invalidJsonStringify,
     [noPromiseInstanceMethodRuleId]: noPromiseInstanceMethod,
     [noFixtureRuleId]: noFixture,
-    [noFixtureHeadersRuleId]: noFixtureHeaders,
+    [fetchHeaderGetterRuleId]: fetchHeaderGetter,
+    [concurrentPromisesRuleId]: concurrentPromises,
   },
   configs: {
     all: {
@@ -51,7 +53,8 @@ export default {
         [`@checkdigit/${invalidJsonStringifyRuleId}`]: 'error',
         [`@checkdigit/${noPromiseInstanceMethodRuleId}`]: 'error',
         [`@checkdigit/${noFixtureRuleId}`]: 'error',
-        [`@checkdigit/${noFixtureHeadersRuleId}`]: 'error',
+        [`@checkdigit/${fetchHeaderGetterRuleId}`]: 'error',
+        [`@checkdigit/${concurrentPromisesRuleId}`]: 'error',
       },
     },
     recommended: {