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

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;

package/src/agent/response-reference.ts

@@ -1,153 +0,0 @@
-// agent/response-reference.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 debug from 'debug';
-
-import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
-import type { ScopeManager, Variable } from '@typescript-eslint/scope-manager';
-import { getParent } from '../library/ts-tree';
-
-const log = debug('eslint-plugin:response-reference');
-
-/**
- * analyze response related variables and their references
- * the implementation is for fixture API, but it can be used for fetch API as well since the tree structure is similar
- * @param variableDeclaration - variable declaration node
- */
-// eslint-disable-next-line sonarjs/cognitive-complexity
-export function analyzeResponseReferences(
-  variableDeclaration: TSESTree.VariableDeclaration | undefined,
-  scopeManager: ScopeManager,
-): {
-  variable?: Variable;
-  bodyReferences: TSESTree.MemberExpression[];
-  headersReferences: TSESTree.MemberExpression[];
-  statusReferences: TSESTree.MemberExpression[];
-  destructuringBodyVariable?: Variable | TSESTree.ObjectPattern;
-  destructuringHeadersVariable?: Variable | TSESTree.ObjectPattern;
-  destructuringStatusVariable?: Variable | TSESTree.ObjectPattern;
-  destructuringHeadersReferences?: TSESTree.MemberExpression[] | undefined;
-} {
-  const results: {
-    variable?: Variable;
-    bodyReferences: TSESTree.MemberExpression[];
-    headersReferences: TSESTree.MemberExpression[];
-    statusReferences: TSESTree.MemberExpression[];
-    destructuringBodyVariable?: Variable | TSESTree.ObjectPattern;
-    destructuringHeadersVariable?: Variable | TSESTree.ObjectPattern;
-    destructuringStatusVariable?: Variable | TSESTree.ObjectPattern;
-    destructuringHeadersReferences?: TSESTree.MemberExpression[] | undefined;
-  } = {
-    bodyReferences: [],
-    headersReferences: [],
-    statusReferences: [],
-  };
-  if (!variableDeclaration) {
-    return results;
-  }
-
-  const responseVariables = scopeManager.getDeclaredVariables(variableDeclaration);
-  for (const responseVariable of responseVariables) {
-    const identifier = responseVariable.identifiers[0];
-    assert.ok(identifier);
-    const identifierParent = getParent(identifier);
-    assert.ok(identifierParent);
-    if (identifierParent.type === AST_NODE_TYPES.VariableDeclarator) {
-      // e.g. const response = ...
-      results.variable = responseVariable;
-      const responseReferences = responseVariable.references.map((responseReference) =>
-        getParent(responseReference.identifier),
-      );
-      // e.g. response.body
-      results.bodyReferences = responseReferences.filter(
-        (node): node is TSESTree.MemberExpression =>
-          node?.type === AST_NODE_TYPES.MemberExpression &&
-          node.property.type === AST_NODE_TYPES.Identifier &&
-          node.property.name === 'body',
-      );
-      // e.g. response.headers / response.header / response.get()
-      results.headersReferences = responseReferences.filter(
-        (node): node is TSESTree.MemberExpression =>
-          node?.type === AST_NODE_TYPES.MemberExpression &&
-          node.property.type === AST_NODE_TYPES.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 TSESTree.MemberExpression =>
-          node?.type === AST_NODE_TYPES.MemberExpression &&
-          node.property.type === AST_NODE_TYPES.Identifier &&
-          (node.property.name === 'status' || node.property.name === 'statusCode'),
-      );
-    } else if (
-      // body reference through destruction/renaming, e.g. "const { body } = ..."
-      identifierParent.type === AST_NODE_TYPES.Property &&
-      identifierParent.key.type === AST_NODE_TYPES.Identifier &&
-      identifierParent.key.name === 'body'
-    ) {
-      results.destructuringBodyVariable = responseVariable;
-    } else if (
-      // body reference through destruction/renaming, e.g. "const { body } = ..."
-      identifierParent.type === AST_NODE_TYPES.Property &&
-      identifierParent.key.type === AST_NODE_TYPES.Identifier &&
-      (identifierParent.key.name === 'status' || identifierParent.key.name === 'statusCode')
-    ) {
-      results.destructuringStatusVariable = responseVariable;
-    } else if (
-      // header reference through destruction/renaming, e.g. "const { headers } = ..."
-      identifierParent.type === AST_NODE_TYPES.Property &&
-      identifierParent.key.type === AST_NODE_TYPES.Identifier &&
-      identifierParent.key.name === 'headers'
-    ) {
-      results.destructuringHeadersVariable = responseVariable;
-      results.destructuringHeadersReferences = responseVariable.references
-        .map((reference) => reference.identifier)
-        .map(getParent)
-        .filter(
-          (parent): parent is TSESTree.MemberExpression =>
-            parent?.type === AST_NODE_TYPES.MemberExpression &&
-            parent.property.type === AST_NODE_TYPES.Identifier &&
-            parent.property.name !== 'get' &&
-            getParent(parent)?.type !== AST_NODE_TYPES.CallExpression,
-        );
-    } else if (identifierParent.type === AST_NODE_TYPES.Property) {
-      const parent = getParent(identifierParent);
-      if (parent?.type === AST_NODE_TYPES.ObjectPattern) {
-        // body reference through nested destruction, e.g. "const { body: {bodyPropertyName: renamedBodyPropertyName}, headers: {headerPropertyName: renamedHeaderPropertyName} } = ..."
-        const parent2 = getParent(parent);
-        if (
-          parent2?.type === AST_NODE_TYPES.Property &&
-          parent2.key.type === AST_NODE_TYPES.Identifier &&
-          parent2.key.name === 'body'
-        ) {
-          results.destructuringBodyVariable = parent;
-        }
-        if (
-          parent2?.type === AST_NODE_TYPES.Property &&
-          parent2.key.type === AST_NODE_TYPES.Identifier &&
-          (parent2.key.name === 'status' || parent2.key.name === 'statusCode')
-        ) {
-          results.destructuringStatusVariable = parent;
-        }
-        if (
-          parent2?.type === AST_NODE_TYPES.Property &&
-          parent2.key.type === AST_NODE_TYPES.Identifier &&
-          (parent2.key.name === 'header' || parent2.key.name === 'headers')
-        ) {
-          results.destructuringHeadersVariable = parent;
-        }
-      }
-    } else {
-      log('+++++++ can not handle identifierParent', identifierParent);
-      throw new Error(`Unknown response variable reference: ${responseVariable.name}`);
-    }
-  }
-  return results;
-}

package/src/agent/supertest-then.ts

@@ -1,230 +0,0 @@
-// agent/supertest-then.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 type { SourceCode } from '@typescript-eslint/utils/ts-eslint';
-
-import { getEnclosingFunction, getParent, isUsedInArrayOrAsArgument } from '../library/ts-tree';
-import getDocumentationUrl from '../get-documentation-url';
-import { getIndentation } from '../library/format';
-
-export const ruleId = 'supertest-then';
-
-interface FixtureCallInformation {
-  fixtureNode: TSESTree.CallExpression;
-  requestBody?: TSESTree.Expression;
-  requestHeaders?: { name: TSESTree.Expression; value: TSESTree.Expression }[];
-  assertions?: TSESTree.Expression[][];
-}
-
-// recursively analyze the fixture/supertest call chain to collect information of request/response
-function analyzeFixtureCall(call: TSESTree.CallExpression, results: FixtureCallInformation, sourceCode: SourceCode) {
-  const parent = getParent(call);
-  if (!parent) {
-    return;
-  }
-
-  let nextCall;
-  if (parent.type !== AST_NODE_TYPES.MemberExpression) {
-    results.fixtureNode = call;
-    return;
-  }
-
-  if (parent.property.type === AST_NODE_TYPES.Identifier) {
-    if (parent.property.name === 'expect') {
-      // supertest assertions
-      const assertionCall = getParent(parent);
-      assert.ok(assertionCall && assertionCall.type === AST_NODE_TYPES.CallExpression);
-      results.assertions = [...(results.assertions ?? []), assertionCall.arguments as TSESTree.Expression[]];
-      nextCall = assertionCall;
-    }
-  } else {
-    throw new Error(`Unexpected TSESTree.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 === AST_NODE_TYPES.MemberExpression &&
-          assertionArgument.object.type === AST_NODE_TYPES.Identifier &&
-          assertionArgument.object.name === 'StatusCodes') ||
-        assertionArgument.type === AST_NODE_TYPES.Literal ||
-        sourceCode.getText(assertionArgument).includes('StatusCodes.')
-      ) {
-        // status code assertion
-        statusAssertion = `assert.equal(${responseVariableName}.status, ${sourceCode.getText(assertionArgument)})`;
-      } else if (assertionArgument.type === AST_NODE_TYPES.ArrowFunctionExpression) {
-        // callback assertion using arrow function
-        let functionBody = sourceCode.getText(assertionArgument.body);
-
-        const [originalResponseArgument] = assertionArgument.params;
-        assert.ok(originalResponseArgument?.type === AST_NODE_TYPES.Identifier);
-        const originalResponseArgumentName = originalResponseArgument.name;
-        if (originalResponseArgumentName !== responseVariableName) {
-          functionBody = functionBody.replace(
-            new RegExp(`\\b${originalResponseArgumentName}\\b`, 'ug'),
-            responseVariableName,
-          );
-        }
-        nonStatusAssertions.push(`assert.doesNotThrow(()=>${functionBody})`);
-      } else if (assertionArgument.type === AST_NODE_TYPES.Identifier) {
-        // callback assertion using function reference
-        nonStatusAssertions.push(
-          `assert.doesNotThrow(()=>${sourceCode.getText(assertionArgument)}(${responseVariableName}))`,
-        );
-      } else if (
-        assertionArgument.type === AST_NODE_TYPES.ObjectExpression ||
-        assertionArgument.type === AST_NODE_TYPES.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 === AST_NODE_TYPES.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,
-  };
-}
-
-const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-const rule: ESLintUtils.RuleModule<
-  'unknownError' | 'preferNativeFetch'
-  // | 'shouldUseHeaderGetter'
-> = createRule({
-  name: ruleId,
-  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 }}.',
-    },
-    fixable: 'code',
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const scopeManager = sourceCode.scopeManager;
-    assert.ok(scopeManager);
-
-    return {
-      'CallExpression[callee.property.name="expect"]': (supertestCall: TSESTree.CallExpression) => {
-        try {
-          assert.ok(supertestCall.callee.type === AST_NODE_TYPES.MemberExpression);
-          if (
-            supertestCall.callee.object.type !== AST_NODE_TYPES.CallExpression ||
-            (supertestCall.callee.object.callee.type === AST_NODE_TYPES.MemberExpression &&
-              supertestCall.callee.object.callee.property.type === AST_NODE_TYPES.Identifier &&
-              supertestCall.callee.object.callee.property.name === 'expect')
-          ) {
-            // skip nested expect calls, only focus on the top level
-            return;
-          }
-
-          if (!(isUsedInArrayOrAsArgument(supertestCall) || getEnclosingFunction(supertestCall)?.async === false)) {
-            return;
-          }
-
-          const fixtureFunction = supertestCall.callee.object;
-          const indentation = getIndentation(supertestCall, sourceCode);
-
-          const [urlArgumentNode] = supertestCall.arguments; // e.g. `/sample-service/v1/ping`
-          assert.ok(urlArgumentNode !== undefined);
-
-          const fixtureCallInformation = {} as FixtureCallInformation;
-          analyzeFixtureCall(fixtureFunction, fixtureCallInformation, sourceCode);
-
-          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 = sourceCode.getText(fixtureFunction);
-          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: supertestCall,
-            messageId: 'preferNativeFetch',
-            fix(fixer) {
-              return fixer.replaceText(fixtureCallInformation.fixtureNode, replacementText);
-            },
-          });
-        } catch (error) {
-          // eslint-disable-next-line no-console
-          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
-          context.report({
-            node: supertestCall,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
-
-export default rule;

package/src/agent/url.ts

@@ -1,32 +0,0 @@
-// agent/url.ts
-
-// eslint-disable-next-line @typescript-eslint/no-inferrable-types
-const PLAIN_URL_REGEXP: RegExp = /^[`']\/\w+(?<serviceNamePart>-\w+)*\/v\d+\/(?<any>.|\r|\n)+[`']$/u;
-// eslint-disable-next-line @typescript-eslint/no-inferrable-types
-const TOKENIZED_URL_REGEXP: RegExp = /^`\$\{(?<serviceNamePart>[A-Z]+_)*BASE_PATH\}\/(?<any>.|\r|\n)+`$/u;
-
-export function isServiceApiCallUrl(url: string): boolean {
-  return PLAIN_URL_REGEXP.test(url) || TOKENIZED_URL_REGEXP.test(url);
-}
-
-export function replaceEndpointUrlPrefixWithBasePath(url: string): string {
-  return url.replace(
-    /^(?<quotStart>[`'])\/(?<servicename>\w+(?<parts>-\w+)*)(?<path>\/v\d+\/)(?<endpoint>(?<any>.|\r|\n)+)(?<quotEnd>[`'])$/u,
-    // eslint-disable-next-line no-template-curly-in-string
-    '`${BASE_PATH}/$5`',
-  );
-}
-
-export function replaceEndpointUrlPrefixWithDomain(url: string): string {
-  return url.replace(
-    /^(?<quotStart>[`'])\/(?<servicename>\w+(?<parts>-\w+)*)(?<path>\/v\d+\/(?<any>.|\r|\n)+(?<quotEnd>[`'])$)/u,
-    '$1https://$2.checkdigit/$2$4',
-  );
-}
-
-export function addBasePathUrlDomain(url: string): string {
-  return url.replace(
-    /^(?<quotStart>[`'])\/(?<servicename>\w+(?<parts>-\w+)*)(?<path>\/v\d+(?<quotEnd>[`'])$)/u,
-    '$1https://$2.checkdigit/$2$4',
-  );
-}