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

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

@@ -6,12 +6,13 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-import type { Identifier, MemberExpression, VariableDeclarator } from 'estree';
+import type { Identifier, 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';
+import { isInvalidResponseHeadersAccess } from './fetch';
 
 export const ruleId = 'fetch-header-getter';
 
@@ -42,12 +43,13 @@ const rule: Rule.RuleModule = {
         );
         assert.ok(responseVariable);
 
-        const directHeaderReferences = responseHeadersReferences
-          .map(getParent)
-          .filter((parent): parent is MemberExpression => parent?.type === 'MemberExpression');
+        const directHeadersReferences = responseHeadersReferences.filter((headersReference) => {
+          const headersAccess = getParent(headersReference);
+          return headersAccess?.type !== 'VariableDeclarator';
+        });
 
-        const indirectHeaderReferences = responseHeadersReferences
-          .map((reference) => getParent(reference))
+        const indirectHeadersReferences = responseHeadersReferences
+          .map(getParent)
           .filter((parent): parent is VariableDeclarator => parent?.type === 'VariableDeclarator')
           .map((declarator) => (declarator.id as Identifier).name)
           .map((redefinedHeadersVariableName) => {
@@ -55,32 +57,31 @@ const rule: Rule.RuleModule = {
               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') ?? []
-            );
+            return headersVariable?.references.map((reference) => reference.identifier) ?? [];
           })
           .flat();
 
-        const invalidHeaderReferences = [...directHeaderReferences, ...indirectHeaderReferences].filter(
-          (reference) => !(reference.property.type === 'Identifier' && reference.property.name === 'get'),
+        const invalidHeadersReferences = [...directHeadersReferences, ...indirectHeadersReferences].filter(
+          isInvalidResponseHeadersAccess,
         );
 
-        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})`;
+        invalidHeadersReferences.forEach((headersReference) => {
+          const headerAccess = getParent(headersReference);
+          if (headerAccess?.type === 'MemberExpression') {
+            const headerNameNode = headerAccess.property;
+            const headerName = headerAccess.computed
+              ? sourceCode.getText(headerNameNode)
+              : `'${sourceCode.getText(headerNameNode)}'`;
+            const replacementText = `${sourceCode.getText(headerAccess.object)}.get(${headerName})`;
 
-          context.report({
-            node: reference,
-            messageId: 'shouldUseHeaderGetter',
-            fix(fixer) {
-              return fixer.replaceText(reference, replacementText);
-            },
-          });
+            context.report({
+              node: headerAccess,
+              messageId: 'shouldUseHeaderGetter',
+              fix(fixer) {
+                return fixer.replaceText(headerAccess, replacementText);
+              },
+            });
+          }
         });
       },
     };

package/src/fixture/fetch-then.ts

@@ -0,0 +1,355 @@
+// fixture/fetch-then.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, MemberExpression, SimpleCallExpression } from 'estree';
+import { type Rule, type Scope, SourceCode } from 'eslint';
+import { getEnclosingFunction, getEnclosingStatement, getParent, isUsedInArrayOrAsArgument } from '../ast/tree';
+import { hasAssertions, isInvalidResponseHeadersAccess } from './fetch';
+import { strict as assert } from 'node:assert';
+import getDocumentationUrl from '../get-documentation-url';
+import { getIndentation } from '../ast/format';
+import { isValidPropertyName } from './variable';
+import { replaceEndpointUrlPrefixWithBasePath } from './url';
+
+export const ruleId = 'fetch-then';
+
+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 !== 'MemberExpression') {
+    results.fixtureNode = call;
+    return;
+  }
+
+  if (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,
+  };
+}
+
+function getResponseHeadersAccesses(
+  responseVariables: Scope.Variable[],
+  scopeManager: Scope.ScopeManager,
+  sourceCode: SourceCode,
+) {
+  const responseHeadersAccesses: MemberExpression[] = [];
+  for (const responseVariable of responseVariables) {
+    for (const responseReference of responseVariable.references) {
+      const responseAccess = getParent(responseReference.identifier);
+      if (!responseAccess || responseAccess.type !== 'MemberExpression') {
+        continue;
+      }
+
+      const responseAccessParent = getParent(responseAccess);
+      if (!responseAccessParent) {
+        continue;
+      }
+
+      if (
+        responseAccessParent.type === 'CallExpression' &&
+        responseAccessParent.arguments[0]?.type === 'ArrowFunctionExpression'
+      ) {
+        // map-like operation against responses, e.g. responses.map((response) => response.headers.etag)
+        responseHeadersAccesses.push(
+          ...getResponseHeadersAccesses(
+            scopeManager.getDeclaredVariables(responseAccessParent.arguments[0]),
+            scopeManager,
+            sourceCode,
+          ),
+        );
+        continue;
+      }
+
+      if (
+        responseAccess.computed &&
+        responseAccess.property.type === 'Literal' &&
+        responseAccessParent.type === 'MemberExpression'
+      ) {
+        // header access through indexed responses array, e.g. responses[0].headers, responses[1].get(...), etc.
+        responseHeadersAccesses.push(responseAccessParent);
+      } else {
+        responseHeadersAccesses.push(responseAccess);
+      }
+    }
+  }
+  return responseHeadersAccesses;
+}
+
+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.',
+      shouldUseHeaderGetter: 'Getter should be used to access response headers.',
+      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;
+    const scopeManager = sourceCode.scopeManager;
+
+    return {
+      // eslint-disable-next-line max-lines-per-function
+      'CallExpression[callee.object.object.name="fixture"][callee.object.property.name="api"]': (
+        fixtureCall: CallExpression,
+        // eslint-disable-next-line sonarjs/cognitive-complexity
+      ) => {
+        try {
+          if (!hasAssertions(fixtureCall)) {
+            // skip if there are no assertions, let "no-fixture" rule to handle the conversion
+            return;
+          }
+
+          if (!(isUsedInArrayOrAsArgument(fixtureCall) || getEnclosingFunction(fixtureCall)?.async === false)) {
+            return;
+          }
+
+          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 = fixtureCallInformation.assertions
+            ? [
+                disableLintComment,
+                `${fetchCallText}.then((${responseVariableNameToUse}) => {`,
+                appendingAssignmentAndAssertionText === '' ? '' : `  ${appendingAssignmentAndAssertionText};`,
+                `  return ${responseVariableNameToUse};`,
+                `})`,
+              ].join(`\n${indentation}`)
+            : fetchCallText;
+
+          context.report({
+            node: fixtureCall,
+            messageId: 'preferNativeFetch',
+            fix(fixer) {
+              return fixer.replaceText(fixtureCallInformation.fixtureNode, replacementText);
+            },
+          });
+
+          const responsesVariable = getEnclosingStatement(fixtureCallInformation.fixtureNode);
+          if (!responsesVariable) {
+            return;
+          }
+
+          const responseVariableReferences = scopeManager.getDeclaredVariables(responsesVariable);
+          const responseHeadersAccesses = getResponseHeadersAccesses(
+            responseVariableReferences,
+            scopeManager,
+            sourceCode,
+          );
+          for (const responseHeadersAccess of responseHeadersAccesses) {
+            if (isInvalidResponseHeadersAccess(responseHeadersAccess)) {
+              const headerAccess = getParent(responseHeadersAccess);
+              if (headerAccess?.type === 'MemberExpression') {
+                const headerNameNode = headerAccess.property;
+                const headerName = headerAccess.computed
+                  ? sourceCode.getText(headerNameNode)
+                  : `'${sourceCode.getText(headerNameNode)}'`;
+                const headerAccessReplacementText = `${sourceCode.getText(headerAccess.object)}.get(${headerName})`;
+
+                context.report({
+                  node: headerAccess,
+                  messageId: 'shouldUseHeaderGetter',
+                  fix(fixer) {
+                    return fixer.replaceText(headerAccess, headerAccessReplacementText);
+                  },
+                });
+              } else if (
+                headerAccess?.type === 'CallExpression' &&
+                responseHeadersAccess.property.type === 'Identifier' &&
+                responseHeadersAccess.property.name === 'get'
+              ) {
+                const headerAccessReplacementText = `${sourceCode.getText(responseHeadersAccess.object)}.headers.get(${sourceCode.getText(headerAccess.arguments[0])})`;
+
+                context.report({
+                  node: headerAccess,
+                  messageId: 'shouldUseHeaderGetter',
+                  fix(fixer) {
+                    return fixer.replaceText(headerAccess, headerAccessReplacementText);
+                  },
+                });
+              }
+            }
+          }
+        } 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.ts

@@ -1,5 +1,52 @@
 // fixture/fetch.ts
 
+import { getParent, isBlockStatement } from '../ast/tree';
+import type { Node } from 'estree';
+
 export function getResponseBodyRetrievalText(responseVariableName: string) {
   return `await ${responseVariableName}.json()`;
 }
+
+export function isInvalidResponseHeadersAccess(responseHeadersAccess: Node) {
+  const responseHeaderAccessParent = getParent(responseHeadersAccess);
+  if (responseHeaderAccessParent?.type === 'VariableDeclarator') {
+    return false;
+  }
+
+  if (
+    responseHeaderAccessParent?.type === 'CallExpression' &&
+    responseHeaderAccessParent.callee.type === 'MemberExpression' &&
+    responseHeaderAccessParent.callee.property.type === 'Identifier' &&
+    responseHeaderAccessParent.callee.property.name === 'get'
+  ) {
+    return true;
+  }
+
+  return !(
+    responseHeaderAccessParent?.type === 'MemberExpression' &&
+    responseHeaderAccessParent.property.type === 'Identifier' &&
+    responseHeaderAccessParent.property.name === 'get'
+  );
+}
+
+export function hasAssertions(fixtureCall: Node) {
+  if (isBlockStatement(fixtureCall)) {
+    return false;
+  }
+
+  const parent = getParent(fixtureCall);
+  if (!parent) {
+    return false;
+  }
+
+  if (
+    parent.type === 'MemberExpression' &&
+    parent.property.type === 'Identifier' &&
+    parent.property.name === 'expect' &&
+    getParent(parent)?.type === 'CallExpression'
+  ) {
+    return true;
+  }
+
+  return hasAssertions(parent);
+}

package/src/fixture/no-fixture.ts

@@ -17,19 +17,25 @@ import type {
   VariableDeclaration,
 } from 'estree';
 import { type Rule, type Scope, SourceCode } from 'eslint';
-import { getEnclosingScopeNode, getEnclosingStatement, getParent } from '../ast/tree';
+import {
+  getEnclosingFunction,
+  getEnclosingScopeNode,
+  getEnclosingStatement,
+  getParent,
+  isUsedInArrayOrAsArgument,
+} from '../ast/tree';
+import { getResponseBodyRetrievalText, hasAssertions } from './fetch';
 import { analyzeResponseReferences } from './response-reference';
 import { strict as assert } from 'node:assert';
 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';
 
 interface FixtureCallInformation {
-  rootNode: AwaitExpression | ReturnStatement | VariableDeclaration;
+  rootNode: AwaitExpression | ReturnStatement | VariableDeclaration | SimpleCallExpression;
   fixtureNode: AwaitExpression | SimpleCallExpression;
   variableDeclaration?: VariableDeclaration;
   requestBody?: Expression;
@@ -40,6 +46,7 @@ interface FixtureCallInformation {
 }
 
 // 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) {
   const parent = getParent(call);
   assert.ok(parent, 'parent should exist for fixture/supertest call node');
@@ -49,6 +56,10 @@ function analyzeFixtureCall(call: SimpleCallExpression, results: FixtureCallInfo
     // direct return, no variable declaration or await
     results.fixtureNode = call;
     results.rootNode = parent;
+  } else if (parent.type === 'ArrayExpression' || parent.type === 'CallExpression') {
+    // direct return, no variable declaration or await
+    results.fixtureNode = call;
+    results.rootNode = call;
   } else if (parent.type === 'AwaitExpression') {
     results.fixtureNode = call;
     const enclosingStatement = getEnclosingStatement(parent);
@@ -235,6 +246,14 @@ const rule: Rule.RuleModule = {
         fixtureCall: CallExpression,
       ) => {
         try {
+          if (
+            hasAssertions(fixtureCall) &&
+            (isUsedInArrayOrAsArgument(fixtureCall) || getEnclosingFunction(fixtureCall)?.async === false)
+          ) {
+            // skip and leave it to "fetch-then" rule to handle it because no "await" can be used here
+            return;
+          }
+
           assert.ok(fixtureCall.type === 'CallExpression');
           const fixtureFunction = fixtureCall.callee; // e.g. fixture.api.get
           assert.ok(fixtureFunction.type === 'MemberExpression');

package/src/fixture/response-reference.ts

@@ -52,27 +52,19 @@ export function analyzeResponseReferences(
       // 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',
+          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?.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?.type === 'MemberExpression' &&
           node.property.type === 'Identifier' &&
           (node.property.name === 'status' || node.property.name === 'statusCode'),
       );

package/src/index.ts

@@ -6,8 +6,8 @@
  * 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 fetchThen, { ruleId as fetchThenRuleId } from './fixture/fetch-then';
 import invalidJsonStringify, { ruleId as invalidJsonStringifyRuleId } from './invalid-json-stringify';
 import noFixture, { ruleId as noFixtureRuleId } from './fixture/no-fixture';
 import noPromiseInstanceMethod, { ruleId as noPromiseInstanceMethodRuleId } from './no-promise-instance-method';
@@ -36,7 +36,7 @@ export default {
     [noPromiseInstanceMethodRuleId]: noPromiseInstanceMethod,
     [noFixtureRuleId]: noFixture,
     [fetchHeaderGetterRuleId]: fetchHeaderGetter,
-    [concurrentPromisesRuleId]: concurrentPromises,
+    [fetchThenRuleId]: fetchThen,
   },
   configs: {
     all: {
@@ -54,7 +54,7 @@ export default {
         [`@checkdigit/${noPromiseInstanceMethodRuleId}`]: 'error',
         [`@checkdigit/${noFixtureRuleId}`]: 'error',
         [`@checkdigit/${fetchHeaderGetterRuleId}`]: 'error',
-        [`@checkdigit/${concurrentPromisesRuleId}`]: 'error',
+        [`@checkdigit/${fetchThenRuleId}`]: 'error',
       },
     },
     recommended: {