@checkdigit/eslint-plugin 7.5.0-PR.75-0252 → 7.5.0-PR.93-6f1c

package/src/agent/add-base-path-const.ts

@@ -1,81 +0,0 @@
-// agent/add-url-domain.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 { getProjectRootFolder, getSwaggerPathByIndexFile, isApiIndexFile, loadPackageJson, loadSwagger } from './file';
-
-export const ruleId = 'add-base-path-const';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addBasePathConst'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add BASE_PATH const variable.',
-    },
-    messages: {
-      addBasePathConst: 'Add BASE_PATH const variable.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      Program: (program: TSESTree.Program) => {
-        if (!isApiIndexFile(context.filename)) {
-          return;
-        }
-
-        const scope = sourceCode.getScope(program).childScopes[0];
-        assert(scope);
-
-        const foundBasePathConst = scope.variables.find((variable) => variable.name === 'BASE_PATH');
-        if (foundBasePathConst) {
-          return;
-        }
-
-        const swaggerPath = getSwaggerPathByIndexFile(context.filename);
-        const swaggerFileContents = loadSwagger(swaggerPath);
-        const baseUrlLine = swaggerFileContents
-          .split('\n')
-          .find((line) => /^\s*-\s*url:\s*\/.*$/u.test(line) || /^basePath:.*/u.test(line));
-        const baseUrl = baseUrlLine?.split(':')[1]?.trim();
-        assert(baseUrl !== undefined);
-
-        const packageRoot = getProjectRootFolder(context.filename);
-        const packageJson = JSON.parse(loadPackageJson(packageRoot)) as { name: string };
-        const serviceName = packageJson.name.split('/')[1];
-        assert(serviceName !== undefined);
-
-        const domain = `https://${serviceName}.checkdigit${baseUrl}`;
-
-        const lastImportStatement = program.body.findLast((node) => node.type === AST_NODE_TYPES.ImportDeclaration);
-        assert(lastImportStatement);
-
-        context.report({
-          messageId: 'addBasePathConst',
-          node: program,
-          fix(fixer) {
-            return fixer.insertTextAfter(lastImportStatement, `\nexport const BASE_PATH = '${domain}';\n`);
-          },
-        });
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/add-base-path-import.ts

@@ -1,69 +0,0 @@
-// agent/add-url-domain.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 } from '@typescript-eslint/utils';
-
-import getDocumentationUrl from '../get-documentation-url';
-import { getApiIndexPathByFilename } from './file';
-
-export const ruleId = 'add-base-path-import';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addBasePathImport'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add import of BASE_PATH if it is used but not imported.',
-    },
-    messages: {
-      addBasePathImport: 'Add import of BASE_PATH.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      Program: (program) => {
-        const isBasePathUsed = sourceCode.text.includes(`$\{BASE_PATH}`);
-        if (isBasePathUsed) {
-          const topScope = sourceCode.getScope(program).childScopes[0];
-          assert(topScope);
-          if (topScope.variables.some((variable) => variable.name === 'BASE_PATH')) {
-            return;
-          }
-
-          const apiIndexPath = getApiIndexPathByFilename(context.filename);
-          if (apiIndexPath !== undefined) {
-            const lastImportStatement = program.body.findLast(
-              (statement) => statement.type === AST_NODE_TYPES.ImportDeclaration,
-            );
-            assert(lastImportStatement);
-
-            const basePathImportStatement = `\nimport { BASE_PATH } from '${apiIndexPath}';\n`;
-            context.report({
-              node: program,
-              messageId: 'addBasePathImport',
-              fix(fixer) {
-                return fixer.insertTextAfter(lastImportStatement, basePathImportStatement);
-              },
-            });
-          }
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/add-url-domain.ts

@@ -1,76 +0,0 @@
-// agent/add-url-domain.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 { addBasePathUrlDomain } from './url';
-
-export const ruleId = 'add-url-domain';
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-
-const rule: ESLintUtils.RuleModule<'addDomain' | 'unknownError'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Add HTTP domain to the BASE_PATH like url constant variable.',
-    },
-    messages: {
-      addDomain: 'Add HTTP domain to the BASE_PATH like url constant variable.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-
-    return {
-      'VariableDeclarator[id.name=/^([A-Z]+_)*BASE_PATH$/]': (basePathDeclarator: TSESTree.VariableDeclarator) => {
-        try {
-          if (
-            basePathDeclarator.init === null ||
-            (basePathDeclarator.init.type !== AST_NODE_TYPES.Literal &&
-              basePathDeclarator.init.type !== AST_NODE_TYPES.TemplateLiteral)
-          ) {
-            return;
-          }
-
-          const urlText = sourceCode.getText(basePathDeclarator.init);
-          const replacement = addBasePathUrlDomain(urlText);
-
-          if (replacement !== urlText) {
-            context.report({
-              messageId: 'addDomain',
-              node: basePathDeclarator.init,
-              fix(fixer) {
-                return fixer.replaceText(basePathDeclarator.init as TSESTree.Node, replacement);
-              },
-            });
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: basePathDeclarator,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/agent-test-wiring.ts

@@ -1,273 +0,0 @@
-// agent/agent-test-wiring.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_TOKEN_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import type { RuleFix, RuleFixer } from '@typescript-eslint/utils/ts-eslint';
-import debug from 'debug';
-
-import getDocumentationUrl from '../get-documentation-url';
-
-export const ruleId = 'agent-test-wiring';
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-const log = debug('eslint-plugin:agent:agent-test-wiring');
-
-const STATEMENT_FIXTURE_RESET = 'fixture.reset()';
-const STATEMENT_FIXTURE_RESET_AWAITED = `await ${STATEMENT_FIXTURE_RESET};`;
-const STATEMENT_AGENT_DECLARATION = 'let agent: Agent;';
-const STATEMENT_AGENT_CREATION = 'agent = await createAgent();';
-const STATEMENT_AGENT_REGISTER = 'agent.register(await fixturePlugin(fixture));';
-const STATEMENT_AGENT_ENABLE = 'agent.enable();';
-const STATEMENT_AGENT_DISPOSE = 'await agent[Symbol.asyncDispose]();';
-
-const rule: ESLintUtils.RuleModule<'updateTestWiring' | 'unknownError'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Update test wiring.',
-    },
-    messages: {
-      updateTestWiring: 'Updating test wiring.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  // eslint-disable-next-line max-lines-per-function
-  create(context) {
-    log('Processing file:', context.filename);
-    const sourceCode = context.sourceCode;
-    const importDeclarations = new Map<string, TSESTree.ImportDeclaration>();
-    let isFixtureUsed = false;
-    let beforeAll: TSESTree.CallExpression | undefined;
-    let beforeEach: TSESTree.CallExpression | undefined;
-    let afterAll: TSESTree.CallExpression | undefined;
-
-    return {
-      ImportDeclaration(importDeclaration) {
-        const moduleName = importDeclaration.source.value;
-        importDeclarations.set(moduleName, importDeclaration);
-        if (
-          moduleName === '@checkdigit/fixture' &&
-          importDeclaration.specifiers.some(
-            (specifier) =>
-              specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
-              specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
-              specifier.imported.name === 'createFixture',
-          )
-        ) {
-          isFixtureUsed = true;
-        }
-      },
-      'CallExpression[callee.name="beforeAll"]': (callExpression: TSESTree.CallExpression) => {
-        beforeAll = callExpression;
-      },
-      'CallExpression[callee.name="beforeEach"]': (callExpression: TSESTree.CallExpression) => {
-        beforeEach = callExpression;
-      },
-      'CallExpression[callee.name="afterAll"]': (callExpression: TSESTree.CallExpression) => {
-        afterAll = callExpression;
-      },
-      // eslint-disable-next-line sonarjs/cognitive-complexity
-      'Program:exit'(program) {
-        if (!isFixtureUsed || (beforeAll === undefined && beforeEach === undefined)) {
-          // only update test wiring if fixture is used
-          return;
-        }
-
-        try {
-          let jestImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let agentImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let fixturePluginImportFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let agentDeclarationFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let beforeAllOrEachFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-          let afterAllFixer: ((fixer: RuleFixer) => RuleFix) | undefined;
-
-          const lastImportDeclaration = [...importDeclarations.values()].at(-1);
-          assert.ok(lastImportDeclaration);
-
-          // make sure that afterAll is imported from jest
-          const jestImportDeclaration = importDeclarations.get('@jest/globals');
-          assert.ok(jestImportDeclaration);
-          const importsToAdd = ['afterAll', 'beforeAll'].filter(
-            (jestHook) =>
-              !jestImportDeclaration.specifiers.some(
-                (specifier) =>
-                  specifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier &&
-                  specifier.imported.type === TSESTree.AST_NODE_TYPES.Identifier &&
-                  specifier.imported.name === jestHook,
-              ),
-          );
-          if (importsToAdd.length > 0) {
-            const firstImportSpecifier = jestImportDeclaration.specifiers[0];
-            assert.ok(firstImportSpecifier);
-            jestImportFixer = (fixer: RuleFixer) =>
-              fixer.insertTextBefore(firstImportSpecifier, `${importsToAdd.join(', ')}, `);
-          }
-
-          // make sure that agent is imported
-          const agentImportDeclaration = importDeclarations.get('@checkdigit/agent');
-          if (!agentImportDeclaration) {
-            agentImportFixer = (fixer: RuleFixer) =>
-              fixer.insertTextAfter(
-                lastImportDeclaration,
-                `\nimport createAgent, { type Agent } from '@checkdigit/agent';`,
-              );
-          }
-
-          // make sure that fixture plugin is imported
-          const pathLets = context.filename.split('/');
-          const currentFileIndex = pathLets.length - 1;
-          const pluginFolderIndex = pathLets.lastIndexOf('src') + 1;
-          // it should be safe to assume that the test code is always at least one level deeper than the plugin folder
-          const fixturePluginImportPath = `${'../'.repeat(currentFileIndex - pluginFolderIndex)}plugin/fixture.test`;
-          if (!importDeclarations.get(fixturePluginImportPath)) {
-            fixturePluginImportFixer = (fixer: RuleFixer) =>
-              fixer.insertTextAfter(lastImportDeclaration, `\nimport fixturePlugin from '${fixturePluginImportPath}';`);
-          }
-
-          // inject agent declaration and initialization
-          if (beforeAll === undefined) {
-            // create `beforeAll` block if it doesn't exist
-            beforeAllOrEachFixer = (fixer: RuleFixer) =>
-              fixer.insertTextBefore(
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                beforeEach!,
-                [
-                  STATEMENT_AGENT_DECLARATION,
-                  `beforeAll(async () => {`,
-                  [STATEMENT_AGENT_CREATION, STATEMENT_AGENT_REGISTER, STATEMENT_AGENT_ENABLE].join('\n'),
-                  `});\n`,
-                ].join('\n'),
-              );
-          } else {
-            const beforeAllArgument = beforeAll.arguments[0];
-            assert.ok(beforeAllArgument !== undefined);
-            if (!sourceCode.getText(beforeAllArgument).includes(STATEMENT_AGENT_CREATION)) {
-              if (
-                beforeAllArgument.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression &&
-                beforeAllArgument.body.type === TSESTree.AST_NODE_TYPES.BlockStatement
-              ) {
-                const fixtureResetStatement = beforeAllArgument.body.body.find(
-                  (statement) => sourceCode.getText(statement) === STATEMENT_FIXTURE_RESET_AWAITED,
-                );
-                assert.ok(fixtureResetStatement !== undefined);
-                beforeAllOrEachFixer = (fixer: RuleFixer) =>
-                  fixer.replaceText(
-                    fixtureResetStatement,
-                    [
-                      STATEMENT_AGENT_CREATION,
-                      STATEMENT_AGENT_REGISTER,
-                      STATEMENT_AGENT_ENABLE,
-                      STATEMENT_FIXTURE_RESET_AWAITED,
-                    ].join('\n'),
-                  );
-              } else {
-                beforeAllOrEachFixer = (fixer: RuleFixer) =>
-                  fixer.replaceText(
-                    beforeAllArgument,
-                    [
-                      `async () => {`,
-                      STATEMENT_AGENT_CREATION,
-                      STATEMENT_AGENT_REGISTER,
-                      STATEMENT_AGENT_ENABLE,
-                      STATEMENT_FIXTURE_RESET_AWAITED,
-                      `}`,
-                    ].join('\n'),
-                  );
-              }
-              agentDeclarationFixer = (fixer: RuleFixer) =>
-                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                fixer.insertTextBefore(beforeAll!, `${STATEMENT_AGENT_DECLARATION}\n`);
-            }
-          }
-
-          // inject agent disposal to `afterAll` block
-          if (afterAll !== undefined) {
-            const afterAllArrowFunctionExpression = afterAll.arguments[0];
-            assert.ok(
-              afterAllArrowFunctionExpression !== undefined &&
-                afterAllArrowFunctionExpression.type === TSESTree.AST_NODE_TYPES.ArrowFunctionExpression,
-            );
-            const arrowFunctionBody = afterAllArrowFunctionExpression.body;
-            assert.ok(arrowFunctionBody.type === TSESTree.AST_NODE_TYPES.BlockStatement);
-
-            const afterAllBodyText = sourceCode.getText(arrowFunctionBody);
-            if (!afterAllBodyText.includes(STATEMENT_AGENT_DISPOSE)) {
-              const lastStatement = arrowFunctionBody.body.at(-1);
-              assert.ok(lastStatement);
-              afterAllFixer = (fixer: RuleFixer) => fixer.insertTextAfter(lastStatement, STATEMENT_AGENT_DISPOSE);
-            }
-          } else {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const nextToken = sourceCode.getTokenAfter(beforeAll ?? beforeEach!);
-            afterAllFixer = (fixer: RuleFixer) =>
-              fixer.insertTextAfter(
-                nextToken !== null && nextToken.type === AST_TOKEN_TYPES.Punctuator
-                  ? nextToken
-                  : // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    beforeAll!,
-                ['', `afterAll(async () => {`, STATEMENT_AGENT_DISPOSE, `});`].join('\n'),
-              );
-          }
-
-          if (
-            jestImportFixer !== undefined ||
-            agentImportFixer !== undefined ||
-            fixturePluginImportFixer !== undefined ||
-            agentDeclarationFixer !== undefined ||
-            beforeAllOrEachFixer !== undefined ||
-            afterAllFixer !== undefined
-          ) {
-            context.report({
-              messageId: 'updateTestWiring',
-              // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-              node: beforeAll ?? beforeEach!,
-              *fix(fixer) {
-                if (jestImportFixer !== undefined) {
-                  yield jestImportFixer(fixer);
-                }
-                if (agentImportFixer !== undefined) {
-                  yield agentImportFixer(fixer);
-                }
-                if (fixturePluginImportFixer !== undefined) {
-                  yield fixturePluginImportFixer(fixer);
-                }
-                if (agentDeclarationFixer !== undefined) {
-                  yield agentDeclarationFixer(fixer);
-                }
-                if (beforeAllOrEachFixer !== undefined) {
-                  yield beforeAllOrEachFixer(fixer);
-                }
-                if (afterAllFixer !== undefined) {
-                  yield afterAllFixer(fixer);
-                }
-              },
-            });
-          }
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: program,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;