@checkdigit/eslint-plugin 7.3.0-PR.75-f04b → 7.3.0-PR.89-2e8d

package/src/agent/no-service-wrapper.ts

@@ -1,241 +0,0 @@
-// agent/no-service-wrapper.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 { DefinitionType, type Scope } from '@typescript-eslint/scope-manager';
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getEnclosingScopeNode } from '../library/ts-tree';
-import { getIndentation } from '../library/format';
-import { isServiceApiCallUrl, replaceEndpointUrlPrefixWithDomain } from './url';
-
-export const ruleId = 'no-service-wrapper';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'preferNativeFetch' | 'invalidOptions'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Prefer native fetch over customized service wrapper.',
-    },
-    messages: {
-      preferNativeFetch: 'Prefer native fetch over customized service wrapper.',
-      invalidOptions:
-        '"options" argument should be provided with "resolveWithFullResponse" property set as "true". Otherwise, it indicates that the response body will be obtained without status code assertion which could result in unexpected issue. Please manually convert the usage of customized service wrapper call to native fetch.',
-      unknownError:
-        'Unknown error occurred in file "{{fileName}}": {{ error }}. Please manually convert the usage of customized service wrapper call to native fetch.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const scopeManager = sourceCode.scopeManager;
-    const parserService = ESLintUtils.getParserServices(context);
-    const typeChecker = parserService.program.getTypeChecker();
-
-    function isUrlArgumentValid(urlArgument: TSESTree.Node | undefined, scope: Scope) {
-      if (
-        (urlArgument?.type === AST_NODE_TYPES.Literal && typeof urlArgument.value === 'string') ||
-        urlArgument?.type === AST_NODE_TYPES.TemplateLiteral
-      ) {
-        const urlText = sourceCode.getText(urlArgument);
-        return isServiceApiCallUrl(urlText);
-      }
-
-      if (urlArgument?.type === AST_NODE_TYPES.Identifier) {
-        const foundVariable = scope.variables.find((variable) => variable.name === urlArgument.name);
-        if (foundVariable) {
-          const variableDefinition = foundVariable.defs.find((def) => def.type === DefinitionType.Variable);
-          if (variableDefinition !== undefined) {
-            const variableDefinitionNode = variableDefinition.node;
-            assert.ok(variableDefinitionNode.init, 'Variable definition node has no init property');
-            return isUrlArgumentValid(variableDefinitionNode.init, scope);
-          }
-          return true;
-        }
-      }
-
-      return false;
-    }
-
-    function getType(identifier: TSESTree.Identifier) {
-      const variable = parserService.esTreeNodeToTSNodeMap.get(identifier);
-      const variableType = typeChecker.getTypeAtLocation(variable);
-      return typeChecker.typeToString(variableType);
-    }
-
-    function isServiceLikeName(name: string) {
-      return /.*[Ss]ervice$/u.test(name);
-    }
-
-    function isCalleeServiceWrapper(serviceCall: TSESTree.CallExpression) {
-      const callee = serviceCall.callee;
-      if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-
-      const endpoint = callee.object;
-      if (endpoint.type === AST_NODE_TYPES.Identifier) {
-        return getType(endpoint) === 'Endpoint' || isServiceLikeName(endpoint.name);
-      }
-      if (endpoint.type !== AST_NODE_TYPES.CallExpression) {
-        return false;
-      }
-
-      const [contextArgument] = endpoint.arguments;
-      if (contextArgument?.type !== AST_NODE_TYPES.Identifier) {
-        return false;
-      }
-      if (contextArgument.name !== 'EMPTY_CONTEXT' && getType(contextArgument) !== 'InboundContext') {
-        return false;
-      }
-      const service = endpoint.callee;
-      if (service.type === AST_NODE_TYPES.Identifier) {
-        return getType(service) === 'ResolvedService';
-      }
-
-      if (service.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      const services = service.object;
-      if (services.type === AST_NODE_TYPES.Identifier) {
-        return getType(services) === 'ResolvedServices';
-      }
-
-      if (services.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      const configuration = services.object;
-      if (configuration.type === AST_NODE_TYPES.Identifier) {
-        return ['Configuration', 'Configuration<ResolvedServices>'].includes(getType(configuration));
-      }
-
-      // following applies only to test code (fixture)
-      if (configuration.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      const fixture = configuration.object;
-      if (fixture.type === AST_NODE_TYPES.Identifier) {
-        return fixture.name === 'fixture' || getType(fixture) === 'Fixture';
-      }
-
-      return false;
-    }
-
-    return {
-      'CallExpression[callee.property.name=/^(head|get|put|post|del|patch)$/]': (
-        serviceCall: TSESTree.CallExpression,
-      ) => {
-        try {
-          if (!isCalleeServiceWrapper(serviceCall)) {
-            return;
-          }
-
-          const enclosingScopeNode = getEnclosingScopeNode(serviceCall);
-          assert.ok(enclosingScopeNode, 'enclosingScopeNode is undefined');
-          const scope = scopeManager?.acquire(enclosingScopeNode);
-          assert.ok(scope, 'scope is undefined');
-          const urlArgument = serviceCall.arguments[0];
-          if (!isUrlArgumentValid(urlArgument, scope)) {
-            return;
-          }
-
-          assert.ok(serviceCall.callee.type === AST_NODE_TYPES.MemberExpression);
-          assert.ok(serviceCall.callee.property.type === AST_NODE_TYPES.Identifier);
-
-          // method
-          const method = serviceCall.callee.property.name;
-
-          // body
-          let requestBodyProperty = ['put', 'post', 'options'].includes(method) ? serviceCall.arguments[1] : undefined;
-          if (
-            requestBodyProperty !== undefined &&
-            requestBodyProperty.type === AST_NODE_TYPES.Identifier &&
-            requestBodyProperty.name === 'undefined'
-          ) {
-            requestBodyProperty = undefined;
-          }
-          // options
-          const optionsArgument = ['get', 'head', 'del'].includes(method)
-            ? serviceCall.arguments[1]
-            : serviceCall.arguments[2];
-          if (optionsArgument === undefined || optionsArgument.type !== AST_NODE_TYPES.ObjectExpression) {
-            context.report({
-              node: serviceCall,
-              messageId: 'invalidOptions',
-            });
-            return;
-          }
-          const resolveWithFullResponseProperty = optionsArgument.properties.find(
-            (property) =>
-              property.type === AST_NODE_TYPES.Property &&
-              property.key.type === AST_NODE_TYPES.Identifier &&
-              property.key.name === 'resolveWithFullResponse',
-          );
-          if (
-            resolveWithFullResponseProperty?.type !== AST_NODE_TYPES.Property ||
-            resolveWithFullResponseProperty.value.type !== AST_NODE_TYPES.Literal ||
-            resolveWithFullResponseProperty.value.value !== true
-          ) {
-            context.report({
-              node: optionsArgument,
-              messageId: 'invalidOptions',
-            });
-            return;
-          }
-
-          // headers
-          const requestHeadersProperty = optionsArgument.properties.find(
-            (property) =>
-              property.type === AST_NODE_TYPES.Property &&
-              property.key.type === AST_NODE_TYPES.Identifier &&
-              property.key.name === 'headers',
-          );
-
-          context.report({
-            messageId: 'preferNativeFetch',
-            node: serviceCall,
-            fix(fixer) {
-              const url = sourceCode.getText(urlArgument);
-              const replacedUrl = replaceEndpointUrlPrefixWithDomain(url);
-              const indentation = getIndentation(serviceCall, sourceCode);
-
-              const fetchText = [
-                `fetch(${replacedUrl}, {`,
-                `  method: '${method.toLowerCase() === 'del' ? 'DELETE' : method.toUpperCase()}',`,
-                ...(requestHeadersProperty ? [`  ${sourceCode.getText(requestHeadersProperty)},`] : []),
-                ...(requestBodyProperty ? [`  body: JSON.stringify(${sourceCode.getText(requestBodyProperty)}),`] : []),
-                '})',
-              ].join(`\n${indentation}`);
-              return fixer.replaceText(serviceCall, fetchText);
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: serviceCall,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/no-status-code.ts

@@ -1,72 +0,0 @@
-// agent/no-status-code.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'no-status-code';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'replaceStatusCode'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Access the status code property of the fetch Response using "status" instead of "statusCode".',
-    },
-    messages: {
-      replaceStatusCode: 'Replace "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 {
-      'MemberExpression[property.name="statusCode"]': (responseStatusCode: TSESTree.MemberExpression) => {
-        try {
-          const responseNode = parserServices.esTreeNodeToTSNodeMap.get(responseStatusCode.object);
-          const responseType = typeChecker.getTypeAtLocation(responseNode);
-
-          const shouldReplace =
-            responseType.getProperties().some((symbol) => symbol.name === 'status') &&
-            !responseType.getProperties().some((symbol) => symbol.name === 'statusCode');
-
-          if (shouldReplace) {
-            context.report({
-              messageId: 'replaceStatusCode',
-              node: responseStatusCode.property,
-              fix(fixer) {
-                return fixer.replaceText(responseStatusCode.property, 'status');
-              },
-            });
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: responseStatusCode,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/no-unused-function-argument.ts

@@ -1,98 +0,0 @@
-// agent/no-unused-function-argument.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 { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import type { Scope } from '@typescript-eslint/utils/ts-eslint';
-
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'no-unused-function-argument';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'removeUnusedFunctionArguments'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Remove unused function arguments.',
-    },
-    messages: {
-      removeUnusedFunctionArguments: 'Removing unused function arguments.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    function isParameterUsed(parameter: TSESTree.Identifier, scope: Scope.Scope): boolean {
-      return (
-        scope.references.some((ref) => ref.identifier.name === parameter.name) ||
-        scope.childScopes.some((childScope) => isParameterUsed(parameter, childScope))
-      );
-    }
-
-    return {
-      FunctionDeclaration(functionDeclaration: TSESTree.FunctionDeclaration) {
-        try {
-          const parameters = functionDeclaration.params;
-          if (parameters.length === 0) {
-            return;
-          }
-
-          const functionScope = sourceCode.getScope(functionDeclaration);
-          const parametersToKeep = parameters.filter(
-            (parameter) =>
-              parameter.type !== TSESTree.AST_NODE_TYPES.Identifier || isParameterUsed(parameter, functionScope),
-          );
-          if (parametersToKeep.length === parameters.length) {
-            return;
-          }
-
-          const updatedParameters = parametersToKeep.map((parameter) => sourceCode.getText(parameter)).join(', ');
-          context.report({
-            node: functionDeclaration,
-            messageId: 'removeUnusedFunctionArguments',
-            fix(fixer) {
-              const firstParameter = parameters[0];
-              const lastParameter = parameters.at(-1);
-              assert.ok(firstParameter !== undefined && lastParameter !== undefined);
-              const tokenAfterParameters = sourceCode.getTokenAfter(lastParameter);
-
-              return fixer.replaceTextRange(
-                [
-                  firstParameter.range[0],
-                  tokenAfterParameters?.value === ',' ? tokenAfterParameters.range[1] : lastParameter.range[1],
-                ],
-                updatedParameters,
-              );
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: functionDeclaration,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/no-unused-imports.ts

@@ -1,103 +0,0 @@
-// agent/no-unused-imports.ts
-
-/*
- * Copyright (c) 2021-2024 Check Digit, LLC
- *
- * This code is licensed under the MIT license (see LICENSE.txt for details).
- */
-
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import type { Scope } from '@typescript-eslint/utils/ts-eslint';
-
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'no-unused-imports';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'removeUnusedImports'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Remove unused imports.',
-    },
-    messages: {
-      removeUnusedImports: 'Removing unused imports.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    function isImportUsed(specifier: TSESTree.ImportClause, scope: Scope.Scope): boolean {
-      return (
-        specifier.type !== TSESTree.AST_NODE_TYPES.ImportSpecifier ||
-        scope.references.some((ref) => ref.identifier.name === specifier.local.name) ||
-        scope.childScopes.some((childScope) => isImportUsed(specifier, childScope))
-      );
-    }
-
-    return {
-      ImportDeclaration(importDeclaration) {
-        try {
-          const moduleName = importDeclaration.source.value;
-          if (
-            !importDeclaration.specifiers.every(
-              (specifier) => specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier,
-            ) ||
-            // [TODO:] move to meta schema
-            !['@checkdigit/serve-runtime', '@checkdigit/fixture'].includes(moduleName)
-          ) {
-            return;
-          }
-
-          const originalSpecifiers = importDeclaration.specifiers;
-          const scope = sourceCode.getScope(importDeclaration);
-          const usedSpecifiers = originalSpecifiers.filter((specifier) => isImportUsed(specifier, scope));
-          if (usedSpecifiers.length === originalSpecifiers.length) {
-            return;
-          }
-
-          if (usedSpecifiers.length === 0) {
-            context.report({
-              messageId: 'removeUnusedImports',
-              node: importDeclaration,
-              *fix(fixer) {
-                yield fixer.remove(importDeclaration);
-              },
-            });
-            return;
-          }
-
-          const usedSpecifierTexts = usedSpecifiers.map((specifier) => sourceCode.getText(specifier));
-          const updatedImportDeclaration = `import ${importDeclaration.importKind === 'type' ? 'type ' : ''}{ ${usedSpecifierTexts.join(', ')} } from '${moduleName}';`;
-
-          context.report({
-            messageId: 'removeUnusedImports',
-            node: importDeclaration,
-            *fix(fixer) {
-              yield fixer.replaceText(importDeclaration, updatedImportDeclaration);
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: importDeclaration,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/no-unused-service-variable.ts

@@ -1,93 +0,0 @@
-// agent/no-unused-service-variable.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 { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import type { Scope } from '@typescript-eslint/utils/ts-eslint';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getEnclosingScopeNode } from '../library/ts-tree';
-
-export const ruleId = 'no-unused-service-variable';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'unknownError' | 'removeUnusedServiceVariables'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Remove unused service variables.',
-    },
-    messages: {
-      removeUnusedServiceVariables: 'Removing unused service variables.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const scopeManager = sourceCode.scopeManager;
-
-    function isVariableUsed(variableIdentifier: TSESTree.Identifier, scope: Scope.Scope): boolean {
-      const variable = scope.variables.find((variableToCheck) => variableToCheck.name === variableIdentifier.name);
-      return variable !== undefined && variable.references.length > 1;
-    }
-
-    return {
-      VariableDeclaration(variableDeclaration: TSESTree.VariableDeclaration) {
-        try {
-          if (
-            variableDeclaration.declarations.length !== 1 ||
-            !sourceCode.getText(variableDeclaration).includes('.service.')
-          ) {
-            return;
-          }
-
-          const enclosingScopeNode = getEnclosingScopeNode(variableDeclaration);
-          assert.ok(enclosingScopeNode, 'enclosingScopeNode is undefined');
-
-          const declarator = variableDeclaration.declarations[0];
-          if (declarator.id.type !== TSESTree.AST_NODE_TYPES.Identifier) {
-            return;
-          }
-
-          const scope = scopeManager?.acquire(enclosingScopeNode);
-          assert.ok(scope, 'variable declaration is undefined');
-          if (isVariableUsed(declarator.id, scope)) {
-            return;
-          }
-
-          context.report({
-            node: variableDeclaration,
-            messageId: 'removeUnusedServiceVariables',
-            fix(fixer) {
-              return fixer.remove(variableDeclaration);
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: variableDeclaration,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;