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

package/src/agent/file.ts

@@ -1,42 +0,0 @@
-// agent/file.ts
-
-import fs from 'node:fs';
-import path from 'node:path';
-
-export function isApiIndexFile(filename: string): boolean {
-  return /.*\/src\/api\/v\d+\/index.ts/u.test(filename);
-}
-
-export function getProjectRootFolder(indexFilename: string): string {
-  return indexFilename.substring(0, indexFilename.lastIndexOf('/src/'));
-}
-
-export function getSwaggerPathByIndexFile(indexFilename: string): string {
-  return indexFilename.replace(/index\.ts$/u, 'swagger.yml');
-}
-
-export function loadSwagger(filename: string): string {
-  return fs.readFileSync(filename, 'utf8');
-}
-
-export function loadPackageJson(projectRoot: string): string {
-  return fs.readFileSync(`${projectRoot}/package.json`, 'utf8');
-}
-
-export function getApiFolder(folder: string): string | undefined {
-  if (/^\/?(?<absolutePath>(?:[^/]+\/)*)src\/api\/v\d+$/u.test(folder)) {
-    return folder;
-  }
-  const upperFolder = folder.substring(0, folder.lastIndexOf('/'));
-  return upperFolder.trim() === '' ? undefined : getApiFolder(upperFolder);
-}
-
-export function getApiIndexPathByFilename(filename: string): string | undefined {
-  const apiFolder = getApiFolder(filename);
-  if (apiFolder === undefined) {
-    return undefined;
-  }
-
-  const relativePath = path.relative(path.dirname(filename), `${apiFolder}/index`);
-  return relativePath.startsWith('../') ? relativePath : `./${relativePath}`;
-}

package/src/agent/fix-function-call-arguments.ts

@@ -1,200 +0,0 @@
-// agent/fix-function-call-arguments.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 debug from 'debug';
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'fix-function-call-arguments';
-
-export interface FixFunctionCallArgumentsRuleOptions {
-  typesToCheck: string[];
-}
-const DEFAULT_OPTIONS = {
-  typesToCheck: [
-    'Configuration<ResolvedServices>',
-    'Fixture<ResolvedServices>',
-    'InboundContext',
-    '{ get: () => string; }',
-    'Api',
-  ],
-};
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-const log = debug('eslint-plugin:fix-function-call-arguments');
-
-const rule: ESLintUtils.RuleModule<
-  'removeIncompatibleFunctionArguments' | 'unknownError',
-  [FixFunctionCallArgumentsRuleOptions]
-> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Remove incompatible function arguments.',
-    },
-    messages: {
-      removeIncompatibleFunctionArguments: 'Removing incompatible function arguments.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [
-      {
-        type: 'object',
-        properties: {
-          typesToCheck: {
-            description: 'Text representation of the types of which the function call parameters will be examine',
-            type: 'array',
-            items: {
-              type: 'string',
-            },
-          },
-        },
-        additionalProperties: false,
-      },
-    ],
-  },
-  defaultOptions: [DEFAULT_OPTIONS],
-  create(context) {
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-    const { typesToCheck } = context.options[0] ?? DEFAULT_OPTIONS;
-    const parserServices = ESLintUtils.getParserServices(context);
-    const typeChecker = parserServices.program.getTypeChecker();
-    const sourceCode = context.sourceCode;
-
-    return {
-      CallExpression(callExpression) {
-        // ignore calls like `foo.bar()` which are likely to be 3rd party module calls
-        // we only focus on calls against local functions or functions imported from the same module
-        // if (callExpression.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression) {
-        //   return;
-        // }
-
-        log('===== file name:', context.filename);
-        log('callExpression:', sourceCode.getText(callExpression));
-
-        try {
-          const actualParameters = callExpression.arguments;
-          if (
-            !actualParameters.some((actualParameter) => {
-              const actualType = typeChecker.getTypeAtLocation(
-                parserServices.esTreeNodeToTSNodeMap.get(actualParameter),
-              );
-              const actualTypeString = typeChecker.typeToString(actualType);
-              return typesToCheck.includes(actualTypeString) || actualTypeString.endsWith('RequestType');
-            })
-          ) {
-            return;
-          }
-
-          const calleeTsNode = parserServices.esTreeNodeToTSNodeMap.get(callExpression.callee);
-          const calleeType = typeChecker.getTypeAtLocation(calleeTsNode);
-
-          const signatures = calleeType.getCallSignatures();
-          if (signatures.length > 1) {
-            // ignore complex signatures with overloads
-            return;
-          }
-
-          const signature = signatures[0];
-          assert(signature);
-          // if (
-          //   signature === undefined ||
-          //   (signature.typeParameters !== undefined && signature.typeParameters.length > 0)
-          // ) {
-          //   // ignore complex signatures with type parameters
-          //   return;
-          // }
-
-          log('signature:', signature.getDeclaration().getText());
-          const expectedParameters = signature.getParameters();
-          log(
-            'expected parameters:',
-            expectedParameters.map((expectedParameter) =>
-              typeChecker.typeToString(typeChecker.getTypeOfSymbol(expectedParameter)),
-            ),
-          );
-          const expectedParametersCount = expectedParameters.length;
-          const actualParametersCount = actualParameters.length;
-          if (actualParametersCount === 0) {
-            return;
-          }
-
-          const parametersToKeep: TSESTree.CallExpressionArgument[] = [];
-          let expectedParameterIndex = 0;
-          for (const [actualParameterIndex, actualParameter] of actualParameters.entries()) {
-            if (expectedParameterIndex >= expectedParametersCount) {
-              break;
-            }
-
-            const expectedParameter = expectedParameters[expectedParameterIndex];
-            assert.ok(expectedParameter, 'Expected parameter not found.');
-
-            const expectedType = typeChecker.getTypeOfSymbol(expectedParameter);
-            const actualType = typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(actualParameter));
-            const actualTypeString = typeChecker.typeToString(actualType);
-            log(
-              'expected type: #',
-              expectedParameterIndex,
-              expectedParameter.escapedName,
-              typeChecker.typeToString(expectedType),
-            );
-            log('actual type: #', actualParameterIndex, sourceCode.getText(actualParameter), actualTypeString);
-
-            if (
-              (typesToCheck.includes(actualTypeString) || actualTypeString.endsWith('RequestType')) &&
-              !typeChecker.isTypeAssignableTo(actualType, expectedType)
-            ) {
-              log('removing un-matched parameter', sourceCode.getText(actualParameter));
-              continue;
-            }
-            parametersToKeep.push(actualParameter);
-            expectedParameterIndex++;
-          }
-
-          if (parametersToKeep.length === actualParametersCount) {
-            return;
-          }
-
-          const firstParameter = actualParameters[0];
-          const lastParameter = actualParameters.at(-1);
-          assert.ok(firstParameter !== undefined && lastParameter !== undefined);
-          const tokenAfterParameters = sourceCode.getTokenAfter(lastParameter);
-
-          context.report({
-            node: callExpression,
-            messageId: 'removeIncompatibleFunctionArguments',
-            fix(fixer) {
-              return fixer.replaceTextRange(
-                [
-                  firstParameter.range[0],
-                  tokenAfterParameters?.value === ',' ? tokenAfterParameters.range[1] : lastParameter.range[1],
-                ],
-                parametersToKeep.map((arg) => sourceCode.getText(arg)).join(', '),
-              );
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: callExpression,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;