@checkdigit/eslint-plugin 7.6.0-PR.75-7ee9 → 7.6.0-PR.97-b19c

package/src/agent/fetch-response-body-json.ts

@@ -1,194 +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';
-import { isFetchResponse } from './fetch';
-
-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);
-
-          if (isFetchResponse(responseType)) {
-            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;

package/src/agent/fetch-response-header-getter.ts

@@ -1,148 +0,0 @@
-// agent/fetch-response-header-getter-ts.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'fetch-response-header-getter-ts';
-const HEADER_BUILTIN_FUNCTIONS = Object.keys(Headers.prototype);
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'useGetter'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Use "get()" method to get header value from the headers object of the fetch response.',
-    },
-    messages: {
-      useGetter: 'Use "get()" method to get header value from the headers object of the fetch response.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const parserServices = ESLintUtils.getParserServices(context);
-    const typeChecker = parserServices.program.getTypeChecker();
-    const sourceCode = context.sourceCode;
-
-    return {
-      MemberExpression: (responseHeadersAccess: TSESTree.MemberExpression) => {
-        try {
-          if (
-            responseHeadersAccess.property.type === AST_NODE_TYPES.Identifier &&
-            HEADER_BUILTIN_FUNCTIONS.includes(responseHeadersAccess.property.name)
-          ) {
-            // skip Headers's built-in function calls
-            return;
-          }
-
-          const responseHeadersTsNode = parserServices.esTreeNodeToTSNodeMap.get(responseHeadersAccess.object);
-          let responseHeadersType = typeChecker.getTypeAtLocation(responseHeadersTsNode);
-          // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-          responseHeadersType = responseHeadersType.isUnion() ? responseHeadersType.types[0]! : responseHeadersType;
-          const responseHeadersTypeName = // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-            (responseHeadersType.symbol ?? responseHeadersType.aliasSymbol)?.escapedName;
-          // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
-          if (responseHeadersTypeName !== 'Headers' && responseHeadersTypeName !== 'HeaderGetter') {
-            return;
-          }
-
-          let replacementText: string;
-          if (!responseHeadersAccess.computed) {
-            // e.g. headers.etag
-            replacementText = `${sourceCode.getText(responseHeadersAccess.object)}.get('${sourceCode.getText(responseHeadersAccess.property)}')`;
-          } else if (
-            responseHeadersAccess.property.type === AST_NODE_TYPES.Identifier ||
-            responseHeadersAccess.property.type === AST_NODE_TYPES.Literal ||
-            responseHeadersAccess.property.type === AST_NODE_TYPES.TemplateLiteral
-          ) {
-            replacementText = `${sourceCode.getText(responseHeadersAccess.object)}.get(${sourceCode.getText(responseHeadersAccess.property)})`;
-          } else {
-            throw new Error(`Unexpected property type: ${responseHeadersAccess.property.type}`);
-          }
-
-          context.report({
-            messageId: 'useGetter',
-            node: responseHeadersAccess.property,
-            fix(fixer) {
-              return fixer.replaceText(responseHeadersAccess, replacementText);
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: responseHeadersAccess,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-
-      // convert response.get() to response.headers.get()
-      'CallExpression[callee.property.name="get"]': (responseHeadersAccess: TSESTree.CallExpression) => {
-        try {
-          if (responseHeadersAccess.callee.type !== AST_NODE_TYPES.MemberExpression) {
-            return;
-          }
-
-          // skip request-like calls
-          if (
-            responseHeadersAccess.callee.object.type !== AST_NODE_TYPES.Identifier ||
-            responseHeadersAccess.callee.object.name === 'request'
-          ) {
-            return;
-          }
-          const responseNode = responseHeadersAccess.callee.object;
-          const responseHeadersTsNode = parserServices.esTreeNodeToTSNodeMap.get(responseNode);
-          const responseType = typeChecker.getTypeAtLocation(responseHeadersTsNode);
-          const typeName = typeChecker.typeToString(responseType);
-          if (typeName === 'InboundContext' || typeName.endsWith('RequestType')) {
-            return;
-          }
-
-          // make sure the response type has "headers" property
-          const hasHeadersProperty = responseType.getProperties().some((symbol) => symbol.name === 'headers');
-          if (!hasHeadersProperty) {
-            return;
-          }
-
-          const replacementText = `${sourceCode.getText(responseNode)}.headers`;
-          context.report({
-            messageId: 'useGetter',
-            node: responseHeadersAccess,
-            fix(fixer) {
-              return fixer.replaceText(responseNode, replacementText);
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: responseHeadersAccess,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/fetch-response-status.ts

@@ -1,100 +0,0 @@
-// agent/fetch-response-status.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 { isFetchResponse } from './fetch';
-
-export const ruleId = 'fetch-response-status';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'renameStatusCodeProperty'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'problem',
-    docs: {
-      description: 'Replace "response.body" with "await response.json()".',
-    },
-    messages: {
-      renameStatusCodeProperty: 'Rename "statusCode" with "status".',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const parserServices = ESLintUtils.getParserServices(context);
-    const typeChecker = parserServices.program.getTypeChecker();
-
-    return {
-      VariableDeclaration: (variableDeclaration: TSESTree.VariableDeclaration) => {
-        const variableInit = variableDeclaration.declarations[0]?.init;
-        if (
-          !variableInit ||
-          variableInit.type !== AST_NODE_TYPES.AwaitExpression ||
-          variableInit.argument.type !== AST_NODE_TYPES.CallExpression
-        ) {
-          return;
-        }
-
-        const variableId = variableDeclaration.declarations[0]?.id;
-        if (variableId.type !== AST_NODE_TYPES.ObjectPattern) {
-          return;
-        }
-        const statusCodeProperty = variableId.properties.find<TSESTree.Property>(
-          (property): property is TSESTree.Property =>
-            property.type === AST_NODE_TYPES.Property &&
-            property.key.type === AST_NODE_TYPES.Identifier &&
-            property.key.name === 'statusCode',
-        );
-        if (!statusCodeProperty) {
-          return;
-        }
-
-        if (
-          variableInit.argument.callee.type !== AST_NODE_TYPES.Identifier ||
-          variableInit.argument.callee.name !== 'fetch'
-        ) {
-          const variableNode = parserServices.esTreeNodeToTSNodeMap.get(variableId);
-          const variableType = typeChecker.getTypeAtLocation(variableNode);
-          if (!isFetchResponse(variableType)) {
-            return;
-          }
-        }
-
-        try {
-          context.report({
-            node: statusCodeProperty,
-            messageId: 'renameStatusCodeProperty',
-            fix(fixer) {
-              return statusCodeProperty.shorthand
-                ? fixer.replaceText(statusCodeProperty, 'status: statusCode')
-                : fixer.replaceText(statusCodeProperty.key, 'status');
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: statusCodeProperty,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;