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

package/src/{no-serve-runtime.ts → agent/no-serve-runtime.ts}

@@ -1,4 +1,4 @@
-// no-serve-runtime.ts
+// agent/no-serve-runtime.ts
 
 /*
  * Copyright (c) 2021-2024 Check Digit, LLC
@@ -7,7 +7,7 @@
  */
 
 import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-import getDocumentationUrl from './get-documentation-url';
+import getDocumentationUrl from '../get-documentation-url';
 
 export const ruleId = 'no-serve-runtime';
 

package/src/index.ts

@@ -8,29 +8,10 @@
 
 import type { TSESLint } from '@typescript-eslint/utils';
 
-import addUrlDomain, { ruleId as addUrlDomainRuleId } from './agent/add-url-domain';
-import agentTestWiring, { ruleId as agentTestWiringRuleId } from './agent/agent-test-wiring';
-import fetchResponseBodyJson, { ruleId as fetchResponseBodyJsonRuleId } from './agent/fetch-response-body-json';
-import fetchResponseHeaderGetter, {
-  ruleId as fetchResponseHeaderGetterRuleId,
-} from './agent/fetch-response-header-getter';
-import fetchThen, { ruleId as fetchThenRuleId } from './agent/fetch-then';
-import fixFunctionCallArguments, {
-  ruleId as fixFunctionCallArgumentsRuleId,
-} from './agent/fix-function-call-arguments';
 import invalidJsonStringify, { ruleId as invalidJsonStringifyRuleId } from './invalid-json-stringify';
 import noDuplicatedImports, { ruleId as noDuplicatedImportsRuleId } from './no-duplicated-imports';
-import noFixture, { ruleId as noFixtureRuleId } from './agent/no-fixture';
-import noLegacyServiceTyping, { ruleId as noLegacyServiceTypingRuleId } from './no-legacy-service-typing';
-import noMappedResponse, { ruleId as noMappedResponseRuleId } from './agent/no-mapped-response';
+import noFullResponse, { ruleId as noFullResponseRuleId } from './agent/no-full-response';
 import noPromiseInstanceMethod, { ruleId as noPromiseInstanceMethodRuleId } from './no-promise-instance-method';
-import noServiceWrapper, { ruleId as noServiceWrapperRuleId } from './agent/no-service-wrapper';
-import noStatusCode, { ruleId as noStatusCodeRuleId } from './agent/no-status-code';
-import noUnusedFunctionArguments, {
-  ruleId as noUnusedFunctionArgumentsRuleId,
-} from './agent/no-unused-function-argument';
-import noUnusedImports, { ruleId as noUnusedImportsRuleId } from './agent/no-unused-imports';
-import noUnusedServiceVariables, { ruleId as noUnusedServiceVariablesRuleId } from './agent/no-unused-service-variable';
 import requireFixedServicesImport, {
   ruleId as requireFixedServicesImportRuleId,
 } from './require-fixed-services-import';
@@ -40,12 +21,10 @@ import requireResolveFullResponse, {
 import requireTypeOutOfTypeOnlyImports, {
   ruleId as requireTypeOutOfTypeOnlyImportsRuleId,
 } from './require-type-out-of-type-only-imports';
-import noServeRuntime, { ruleId as noServeRuntimeRuleId } from './no-serve-runtime';
-import addBasePathConst, { ruleId as addBasePathConstRuleId } from './agent/add-base-path-const';
-import addBasePathImport, { ruleId as addBasePathImportRuleId } from './agent/add-base-path-import';
-import addAssertImport, { ruleId as addAssertImportRuleId } from './agent/add-assert-import';
+import noServeRuntime, { ruleId as noServeRuntimeRuleId } from './agent/no-serve-runtime';
 import filePathComment from './file-path-comment';
 import noCardNumbers from './no-card-numbers';
+import noRandomV4UUID from './no-random-v4-uuid';
 import noTestImport from './no-test-import';
 import noUuid from './no-uuid';
 import noWallabyComment from './no-wallaby-comment';
@@ -57,6 +36,7 @@ import requireStrictAssert from './require-strict-assert';
 const rules: Record<string, TSESLint.LooseRuleDefinition> = {
   'file-path-comment': filePathComment,
   'no-card-numbers': noCardNumbers,
+  'no-random-v4-uuid': noRandomV4UUID,
   'no-uuid': noUuid,
   'require-strict-assert': requireStrictAssert,
   'no-test-import': noTestImport,
@@ -66,170 +46,67 @@ const rules: Record<string, TSESLint.LooseRuleDefinition> = {
   'object-literal-response': objectLiteralResponse,
   [invalidJsonStringifyRuleId]: invalidJsonStringify,
   [noPromiseInstanceMethodRuleId]: noPromiseInstanceMethod,
-  [noFixtureRuleId]: noFixture,
-  [fetchThenRuleId]: fetchThen,
-  [noServiceWrapperRuleId]: noServiceWrapper,
-  [noStatusCodeRuleId]: noStatusCode,
-  [fetchResponseBodyJsonRuleId]: fetchResponseBodyJson,
-  [fetchResponseHeaderGetterRuleId]: fetchResponseHeaderGetter,
-  [addUrlDomainRuleId]: addUrlDomain,
-  [noLegacyServiceTypingRuleId]: noLegacyServiceTyping,
-  [noMappedResponseRuleId]: noMappedResponse,
+  [noFullResponseRuleId]: noFullResponse,
   [requireResolveFullResponseRuleId]: requireResolveFullResponse,
+  [requireTypeOutOfTypeOnlyImportsRuleId]: requireTypeOutOfTypeOnlyImports,
   [noDuplicatedImportsRuleId]: noDuplicatedImports,
-  [noServeRuntimeRuleId]: noServeRuntime,
-  [addBasePathConstRuleId]: addBasePathConst,
-  [addBasePathImportRuleId]: addBasePathImport,
-  [addAssertImportRuleId]: addAssertImport,
   [requireFixedServicesImportRuleId]: requireFixedServicesImport,
-  [requireTypeOutOfTypeOnlyImportsRuleId]: requireTypeOutOfTypeOnlyImports,
-  [noUnusedFunctionArgumentsRuleId]: noUnusedFunctionArguments,
-  [noUnusedServiceVariablesRuleId]: noUnusedServiceVariables,
-  [noUnusedImportsRuleId]: noUnusedImports,
-  [fixFunctionCallArgumentsRuleId]: fixFunctionCallArguments,
-  [agentTestWiringRuleId]: agentTestWiring,
+  [noServeRuntimeRuleId]: noServeRuntime,
 };
 
 const plugin: TSESLint.FlatConfig.Plugin = {
   rules,
 };
 
-const configs: Record<string, TSESLint.FlatConfig.Config | TSESLint.FlatConfig.Config[]> = {
-  all: [
-    {
-      files: ['**/*.ts'],
-      plugins: {
-        '@checkdigit': plugin,
-      },
-      rules: {
-        '@checkdigit/no-card-numbers': 'error',
-        '@checkdigit/file-path-comment': 'error',
-        '@checkdigit/no-uuid': 'error',
-        '@checkdigit/require-strict-assert': 'error',
-        '@checkdigit/no-wallaby-comment': 'error',
-        '@checkdigit/regular-expression-comment': 'error',
-        '@checkdigit/require-assert-predicate-rejects-throws': 'error',
-        '@checkdigit/object-literal-response': 'error',
-        '@checkdigit/no-test-import': 'error',
-        [`@checkdigit/${invalidJsonStringifyRuleId}`]: 'error',
-        [`@checkdigit/${noPromiseInstanceMethodRuleId}`]: 'error',
-        [`@checkdigit/${noLegacyServiceTypingRuleId}`]: 'error',
-        [`@checkdigit/${requireResolveFullResponseRuleId}`]: 'error',
-        [`@checkdigit/${noDuplicatedImportsRuleId}`]: 'error',
-        [`@checkdigit/${requireFixedServicesImportRuleId}`]: 'error',
-        [`@checkdigit/${requireTypeOutOfTypeOnlyImportsRuleId}`]: 'error',
-        [`@checkdigit/${noServeRuntimeRuleId}`]: 'error',
-        // --- agent rules BEGIN ---
-        [`@checkdigit/${noMappedResponseRuleId}`]: 'off',
-        [`@checkdigit/${addUrlDomainRuleId}`]: 'off',
-        [`@checkdigit/${noFixtureRuleId}`]: 'off',
-        [`@checkdigit/${noServiceWrapperRuleId}`]: 'off',
-        [`@checkdigit/${noStatusCodeRuleId}`]: 'off',
-        [`@checkdigit/${fetchResponseBodyJsonRuleId}`]: 'off',
-        [`@checkdigit/${fetchResponseHeaderGetterRuleId}`]: 'off',
-        [`@checkdigit/${fetchThenRuleId}`]: 'off',
-        [`@checkdigit/${noUnusedFunctionArgumentsRuleId}`]: 'off',
-        [`@checkdigit/${noUnusedServiceVariablesRuleId}`]: 'off',
-        [`@checkdigit/${noUnusedImportsRuleId}`]: 'off',
-        [`@checkdigit/${fixFunctionCallArgumentsRuleId}`]: 'off',
-        [`@checkdigit/${agentTestWiringRuleId}`]: 'off',
-        [`@checkdigit/${addBasePathConstRuleId}`]: 'off',
-        [`@checkdigit/${addBasePathImportRuleId}`]: 'off',
-        [`@checkdigit/${addAssertImportRuleId}`]: 'off',
-        // --- agent rules END ---
-      },
-    },
-  ],
-  recommended: [
-    {
-      files: ['**/*.ts'],
-      plugins: {
-        '@checkdigit': plugin,
-      },
-      rules: {
-        '@checkdigit/no-card-numbers': 'error',
-        '@checkdigit/file-path-comment': 'off',
-        '@checkdigit/no-uuid': 'error',
-        '@checkdigit/require-strict-assert': 'error',
-        '@checkdigit/no-wallaby-comment': 'off',
-        '@checkdigit/regular-expression-comment': 'error',
-        '@checkdigit/require-assert-predicate-rejects-throws': 'error',
-        '@checkdigit/object-literal-response': 'error',
-        '@checkdigit/no-test-import': 'error',
-        [`@checkdigit/${invalidJsonStringifyRuleId}`]: 'error',
-        [`@checkdigit/${noPromiseInstanceMethodRuleId}`]: 'error',
-      },
+const configs: Record<string, TSESLint.FlatConfig.Config> = {
+  all: {
+    plugins: {
+      '@checkdigit': plugin,
     },
-  ],
-  'agent-phase-1-test': [
-    {
-      files: ['**/*.spec.ts', '**/*.test.ts', 'src/api/v*/index.ts'],
-      // eslint-disable-next-line sonarjs/no-duplicate-string
-      ignores: ['src/plugin/**'],
-      plugins: {
-        '@checkdigit': plugin,
-      },
-      rules: {
-        [`@checkdigit/${noMappedResponseRuleId}`]: 'error',
-        [`@checkdigit/${addUrlDomainRuleId}`]: 'error',
-        [`@checkdigit/${noFixtureRuleId}`]: 'error',
-        [`@checkdigit/${noServiceWrapperRuleId}`]: 'error',
-        [`@checkdigit/${noStatusCodeRuleId}`]: 'error',
-        [`@checkdigit/${fetchResponseBodyJsonRuleId}`]: 'error',
-        [`@checkdigit/${fetchResponseHeaderGetterRuleId}`]: 'error',
-        [`@checkdigit/${fetchThenRuleId}`]: 'error',
-        [`@checkdigit/${noUnusedFunctionArgumentsRuleId}`]: 'error',
-        [`@checkdigit/${noUnusedServiceVariablesRuleId}`]: 'error',
-        [`@checkdigit/${noUnusedImportsRuleId}`]: 'error',
-        [`@checkdigit/${fixFunctionCallArgumentsRuleId}`]: 'error',
-        [`@checkdigit/${addBasePathConstRuleId}`]: 'error',
-        [`@checkdigit/${addBasePathImportRuleId}`]: 'error',
-        [`@checkdigit/${addAssertImportRuleId}`]: 'error',
-      },
+    rules: {
+      '@checkdigit/no-card-numbers': 'error',
+      '@checkdigit/file-path-comment': 'error',
+      '@checkdigit/no-random-v4-uuid': 'error',
+      '@checkdigit/no-uuid': 'error',
+      '@checkdigit/require-strict-assert': 'error',
+      '@checkdigit/no-wallaby-comment': 'error',
+      '@checkdigit/regular-expression-comment': 'error',
+      '@checkdigit/require-assert-predicate-rejects-throws': 'error',
+      '@checkdigit/object-literal-response': 'error',
+      '@checkdigit/no-test-import': 'error',
+      [`@checkdigit/${invalidJsonStringifyRuleId}`]: 'error',
+      [`@checkdigit/${noPromiseInstanceMethodRuleId}`]: 'error',
+      [`@checkdigit/${noFullResponseRuleId}`]: 'error',
+      [`@checkdigit/${requireResolveFullResponseRuleId}`]: 'error',
+      [`@checkdigit/${requireTypeOutOfTypeOnlyImportsRuleId}`]: 'error',
+      [`@checkdigit/${noDuplicatedImportsRuleId}`]: 'error',
+      [`@checkdigit/${requireFixedServicesImportRuleId}`]: 'error',
+      [`@checkdigit/${noServeRuntimeRuleId}`]: 'error',
     },
-    {
-      files: ['**/*.spec.ts'],
-      ignores: ['src/plugin/**'],
-      plugins: {
-        '@checkdigit': plugin,
-      },
-      rules: {
-        [`@checkdigit/${agentTestWiringRuleId}`]: 'error',
-      },
+  },
+  recommended: {
+    plugins: {
+      '@checkdigit': plugin,
     },
-  ],
-  'agent-phase-2-production': [
-    {
-      files: ['**/*.ts'],
-      ignores: ['src/plugin/**'],
-      plugins: {
-        '@checkdigit': plugin,
-      },
-      rules: {
-        [`@checkdigit/${noMappedResponseRuleId}`]: 'error',
-        [`@checkdigit/${addUrlDomainRuleId}`]: 'error',
-        [`@checkdigit/${noFixtureRuleId}`]: 'off',
-        [`@checkdigit/${noServiceWrapperRuleId}`]: 'error',
-        [`@checkdigit/${noStatusCodeRuleId}`]: 'error',
-        [`@checkdigit/${fetchResponseBodyJsonRuleId}`]: 'error',
-        [`@checkdigit/${fetchResponseHeaderGetterRuleId}`]: 'error',
-        [`@checkdigit/${fetchThenRuleId}`]: 'error',
-        [`@checkdigit/${noUnusedFunctionArgumentsRuleId}`]: 'error',
-        [`@checkdigit/${noUnusedServiceVariablesRuleId}`]: 'error',
-        [`@checkdigit/${noUnusedImportsRuleId}`]: 'error',
-        [`@checkdigit/${fixFunctionCallArgumentsRuleId}`]: 'error',
-        [`@checkdigit/${addBasePathConstRuleId}`]: 'error',
-        [`@checkdigit/${addBasePathImportRuleId}`]: 'error',
-        [`@checkdigit/${addAssertImportRuleId}`]: 'error',
-      },
+    rules: {
+      '@checkdigit/no-card-numbers': 'error',
+      '@checkdigit/file-path-comment': 'off',
+      '@checkdigit/no-random-v4-uuid': 'error',
+      '@checkdigit/no-uuid': 'error',
+      '@checkdigit/require-strict-assert': 'error',
+      '@checkdigit/no-wallaby-comment': 'off',
+      '@checkdigit/regular-expression-comment': 'error',
+      '@checkdigit/require-assert-predicate-rejects-throws': 'error',
+      '@checkdigit/object-literal-response': 'error',
+      '@checkdigit/no-test-import': 'error',
+      [`@checkdigit/${invalidJsonStringifyRuleId}`]: 'error',
+      [`@checkdigit/${noPromiseInstanceMethodRuleId}`]: 'error',
     },
-  ],
+  },
 };
 
-const defaultToExport: Exclude<TSESLint.FlatConfig.Plugin, 'config'> & {
-  configs: Record<string, TSESLint.FlatConfig.Config | TSESLint.FlatConfig.Config[]>;
-} = {
+const pluginToExport: TSESLint.FlatConfig.Plugin = {
   ...plugin,
   configs,
 };
-export default defaultToExport;
+export default pluginToExport;

package/src/library/tree.ts

@@ -64,7 +64,6 @@ export function isUsedInArrayOrAsArgument(node: Node): boolean {
 
   if (
     parent.type === 'ArrayExpression' ||
-    parent.type === 'ArrowFunctionExpression' ||
     (parent.type === 'CallExpression' && parent.arguments.includes(node as Expression))
   ) {
     return true;

package/src/no-random-v4-uuid.ts

@@ -0,0 +1,92 @@
+// no-random-v4-uuid.ts
+
+/*
+ * Copyright (c) 2022-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { AST_NODE_TYPES, ESLintUtils, TSESLint, TSESTree } from '@typescript-eslint/utils';
+import getDocumentationUrl from './get-documentation-url';
+
+export const ruleId = 'no-random-v4-uuid';
+const NO_RANDOM_V4_UUID = 'NO_RANDOM_V4_UUID';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+// process the import declaration to get the alias for uuid.v4 and uuid.
+const processImportDeclaration = (
+  node: TSESTree.ImportDeclaration,
+  uuid4Alias: string | undefined,
+  uuidDefaultAlias: string | undefined,
+) => {
+  let updatedUuid4Alias = uuid4Alias;
+  let updatedUuidDefaultAlias = uuidDefaultAlias;
+  node.specifiers.forEach((specifier) => {
+    switch (specifier.type) {
+      case AST_NODE_TYPES.ImportSpecifier:
+        if (specifier.imported.type === AST_NODE_TYPES.Identifier && specifier.imported.name === 'v4') {
+          updatedUuid4Alias = specifier.local.name;
+        }
+        break;
+      case AST_NODE_TYPES.ImportDefaultSpecifier:
+        updatedUuidDefaultAlias = specifier.local.name;
+        break;
+    }
+  });
+  return { uuid4Alias: updatedUuid4Alias, uuidDefaultAlias: updatedUuidDefaultAlias };
+};
+
+// checks if the function call is either directly using the alias for uuid.v4 or using uuid.v4 as a member expression.
+const isUuid4Call = (
+  node: TSESTree.CallExpression,
+  uuid4Alias: string | undefined,
+  uuidDefaultAlias: string | undefined,
+): boolean =>
+  (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === uuid4Alias) ||
+  (node.callee.type === AST_NODE_TYPES.MemberExpression &&
+    node.callee.object.type === AST_NODE_TYPES.Identifier &&
+    node.callee.object.name === uuidDefaultAlias &&
+    node.callee.property.type === AST_NODE_TYPES.Identifier &&
+    node.callee.property.name === 'v4');
+
+const rule: TSESLint.RuleModule<typeof NO_RANDOM_V4_UUID> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Disallow the use of `uuid.v4` for generating random v4 UUIDs',
+    },
+    schema: [],
+    messages: {
+      [NO_RANDOM_V4_UUID]: 'Avoid using `uuid.v4` for generating random v4 UUIDs.',
+    },
+  },
+  defaultOptions: [],
+  create(context) {
+    let uuid4Alias: string | undefined;
+    let uuidDefaultAlias: string | undefined;
+    let hasUuidImport = false;
+
+    return {
+      ImportDeclaration(node: TSESTree.ImportDeclaration) {
+        if (node.source.value === 'uuid') {
+          hasUuidImport = true;
+          const result = processImportDeclaration(node, uuid4Alias, uuidDefaultAlias);
+          uuid4Alias = result.uuid4Alias;
+          uuidDefaultAlias = result.uuidDefaultAlias;
+        }
+      },
+      CallExpression(node: TSESTree.CallExpression) {
+        if (hasUuidImport && isUuid4Call(node, uuid4Alias, uuidDefaultAlias)) {
+          context.report({
+            node,
+            messageId: NO_RANDOM_V4_UUID,
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

package/src/require-resolve-full-response.ts

@@ -54,12 +54,10 @@ const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> = createRu
         const foundVariable = scope.variables.find((variable) => variable.name === urlArgument.name);
         if (foundVariable) {
           const variableDefinition = foundVariable.defs.find((def) => def.type === DefinitionType.Variable);
-          if (variableDefinition) {
-            const variableDefinitionNode = variableDefinition.node;
-            assert.ok(variableDefinitionNode.init, 'Variable definition node has no init property');
-            return isUrlArgumentValid(variableDefinitionNode.init, scope);
-          }
-          return true;
+          assert.ok(variableDefinition, `Variable "${urlArgument.name}" not defined in scope`);
+          const variableDefinitionNode = variableDefinition.node;
+          assert.ok(variableDefinitionNode.init, 'Variable definition node has no init property');
+          return isUrlArgumentValid(variableDefinitionNode.init, scope);
         }
       }
 
@@ -158,7 +156,7 @@ const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> = createRu
           const optionsArgument = ['get', 'head', 'del'].includes(method)
             ? serviceCall.arguments[1]
             : serviceCall.arguments[2];
-          if (optionsArgument === undefined) {
+          if (optionsArgument === undefined || optionsArgument.type !== AST_NODE_TYPES.ObjectExpression) {
             context.report({
               node: serviceCall,
               messageId: 'invalidOptions',
@@ -166,38 +164,23 @@ const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> = createRu
             return;
           }
 
-          if (optionsArgument.type === AST_NODE_TYPES.Identifier) {
-            const optionsTypeString = getType(optionsArgument);
-            if (optionsTypeString === 'FullResponseOptions') {
-              return;
-            }
-
-            const variable = parserService.esTreeNodeToTSNodeMap.get(optionsArgument);
-            const optionType = typeChecker.getTypeAtLocation(variable);
-            const resolveWithFullResponseProperty = optionType.getProperty('resolveWithFullResponse');
-            if (resolveWithFullResponseProperty?.declarations?.[0]?.getText() === 'resolveWithFullResponse: true') {
-              return;
-            }
-          } else if (optionsArgument.type === AST_NODE_TYPES.ObjectExpression) {
-            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
-            ) {
-              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;
           }
-
-          context.report({
-            node: optionsArgument,
-            messageId: 'invalidOptions',
-          });
         } catch (error) {
           // eslint-disable-next-line no-console
           console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);

package/dist-mjs/agent/add-assert-import.mjs

@@ -1,58 +0,0 @@
-// src/agent/add-assert-import.ts
-import { strict as assert } from "node:assert";
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import getDocumentationUrl from "../get-documentation-url.mjs";
-var ruleId = "add-assert-import";
-var ASSERT_IMPORT_STATEMENT = "import { strict as assert } from 'node:assert';";
-var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-var rule = createRule({
-  name: ruleId,
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Add import of assert module of node."
-    },
-    messages: {
-      addAssertImport: "Add import of assert module of node."
-    },
-    fixable: "code",
-    schema: []
-  },
-  defaultOptions: [],
-  create(context) {
-    let isAssertImported = false;
-    let isAssertUsed = false;
-    return {
-      ImportDeclaration: (node) => {
-        if (node.source.value === "assert" || node.source.value === "node:assert") {
-          isAssertImported = true;
-        }
-      },
-      CallExpression: (callExpression) => {
-        if (callExpression.callee.type === AST_NODE_TYPES.Identifier && callExpression.callee.name === "assert" || callExpression.callee.type === AST_NODE_TYPES.MemberExpression && callExpression.callee.object.type === AST_NODE_TYPES.Identifier && callExpression.callee.object.name === "assert") {
-          isAssertUsed = true;
-        }
-      },
-      "Program:exit": (program) => {
-        if (isAssertUsed && !isAssertImported) {
-          const firstStatement = program.body[0];
-          assert(firstStatement);
-          context.report({
-            node: program,
-            messageId: "addAssertImport",
-            fix(fixer) {
-              return fixer.insertTextBefore(firstStatement, `${ASSERT_IMPORT_STATEMENT}
-`);
-            }
-          });
-        }
-      }
-    };
-  }
-});
-var add_assert_import_default = rule;
-export {
-  add_assert_import_default as default,
-  ruleId
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC1hc3NlcnQtaW1wb3J0LnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQVFBLFNBQVMsVUFBVSxjQUFjO0FBRWpDLFNBQVMsZ0JBQWdCLG1CQUFtQjtBQUU1QyxPQUFPLHlCQUF5QjtBQUV6QixJQUFNLFNBQVM7QUFFdEIsSUFBTSwwQkFBMEI7QUFFaEMsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQWtELFdBQVc7QUFBQSxFQUNqRSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1IsaUJBQWlCO0FBQUEsSUFDbkI7QUFBQSxJQUNBLFNBQVM7QUFBQSxJQUNULFFBQVEsQ0FBQztBQUFBLEVBQ1g7QUFBQSxFQUNBLGdCQUFnQixDQUFDO0FBQUEsRUFDakIsT0FBTyxTQUFTO0FBQ2QsUUFBSSxtQkFBbUI7QUFDdkIsUUFBSSxlQUFlO0FBRW5CLFdBQU87QUFBQSxNQUNMLG1CQUFtQixDQUFDLFNBQVM7QUFDM0IsWUFBSSxLQUFLLE9BQU8sVUFBVSxZQUFZLEtBQUssT0FBTyxVQUFVLGVBQWU7QUFDekUsNkJBQW1CO0FBQUEsUUFDckI7QUFBQSxNQUNGO0FBQUEsTUFDQSxnQkFBZ0IsQ0FBQyxtQkFBbUI7QUFFbEMsWUFDRyxlQUFlLE9BQU8sU0FBUyxlQUFlLGNBQWMsZUFBZSxPQUFPLFNBQVMsWUFDM0YsZUFBZSxPQUFPLFNBQVMsZUFBZSxvQkFDN0MsZUFBZSxPQUFPLE9BQU8sU0FBUyxlQUFlLGNBQ3JELGVBQWUsT0FBTyxPQUFPLFNBQVMsVUFDeEM7QUFDQSx5QkFBZTtBQUFBLFFBQ2pCO0FBQUEsTUFDRjtBQUFBLE1BQ0EsZ0JBQWdCLENBQUMsWUFBWTtBQUUzQixZQUFJLGdCQUFnQixDQUFDLGtCQUFrQjtBQUNyQyxnQkFBTSxpQkFBaUIsUUFBUSxLQUFLLENBQUM7QUFDckMsaUJBQU8sY0FBYztBQUNyQixrQkFBUSxPQUFPO0FBQUEsWUFDYixNQUFNO0FBQUEsWUFDTixXQUFXO0FBQUEsWUFDWCxJQUFJLE9BQU87QUFDVCxxQkFBTyxNQUFNLGlCQUFpQixnQkFBZ0IsR0FBRyx1QkFBdUI7QUFBQSxDQUFJO0FBQUEsWUFDOUU7QUFBQSxVQUNGLENBQUM7QUFBQSxRQUNIO0FBQUEsTUFDRjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQ0YsQ0FBQztBQUVELElBQU8sNEJBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==

package/dist-mjs/agent/add-base-path-const.mjs

@@ -1,65 +0,0 @@
-// src/agent/add-base-path-const.ts
-import { strict as assert } from "node:assert";
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import getDocumentationUrl from "../get-documentation-url.mjs";
-import { getProjectRootFolder, getSwaggerPathByIndexFile, isApiIndexFile, loadPackageJson, loadSwagger } from "./file.mjs";
-var ruleId = "add-base-path-const";
-var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-var rule = 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) => {
-        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 !== void 0);
-        const packageRoot = getProjectRootFolder(context.filename);
-        const packageJson = JSON.parse(loadPackageJson(packageRoot));
-        const serviceName = packageJson.name.split("/")[1];
-        assert(serviceName !== void 0);
-        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, `
-export const BASE_PATH = '${domain}';
-`);
-          }
-        });
-      }
-    };
-  }
-});
-var add_base_path_const_default = rule;
-export {
-  add_base_path_const_default as default,
-  ruleId
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC1iYXNlLXBhdGgtY29uc3QudHMiXSwKICAibWFwcGluZ3MiOiAiO0FBUUEsU0FBUyxVQUFVLGNBQWM7QUFFakMsU0FBUyxnQkFBZ0IsbUJBQTZCO0FBRXRELE9BQU8seUJBQXlCO0FBQ2hDLFNBQVMsc0JBQXNCLDJCQUEyQixnQkFBZ0IsaUJBQWlCLG1CQUFtQjtBQUV2RyxJQUFNLFNBQVM7QUFFdEIsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQW1ELFdBQVc7QUFBQSxFQUNsRSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1Isa0JBQWtCO0FBQUEsSUFDcEI7QUFBQSxJQUNBLFNBQVM7QUFBQSxJQUNULFFBQVEsQ0FBQztBQUFBLEVBQ1g7QUFBQSxFQUNBLGdCQUFnQixDQUFDO0FBQUEsRUFDakIsT0FBTyxTQUFTO0FBQ2QsVUFBTSxhQUFhLFFBQVE7QUFFM0IsV0FBTztBQUFBLE1BQ0wsU0FBUyxDQUFDLFlBQThCO0FBQ3RDLFlBQUksQ0FBQyxlQUFlLFFBQVEsUUFBUSxHQUFHO0FBQ3JDO0FBQUEsUUFDRjtBQUVBLGNBQU0sUUFBUSxXQUFXLFNBQVMsT0FBTyxFQUFFLFlBQVksQ0FBQztBQUN4RCxlQUFPLEtBQUs7QUFFWixjQUFNLHFCQUFxQixNQUFNLFVBQVUsS0FBSyxDQUFDLGFBQWEsU0FBUyxTQUFTLFdBQVc7QUFDM0YsWUFBSSxvQkFBb0I7QUFDdEI7QUFBQSxRQUNGO0FBRUEsY0FBTSxjQUFjLDBCQUEwQixRQUFRLFFBQVE7QUFDOUQsY0FBTSxzQkFBc0IsWUFBWSxXQUFXO0FBQ25ELGNBQU0sY0FBYyxvQkFDakIsTUFBTSxJQUFJLEVBQ1YsS0FBSyxDQUFDLFNBQVMsd0JBQXdCLEtBQUssSUFBSSxLQUFLLGdCQUFnQixLQUFLLElBQUksQ0FBQztBQUNsRixjQUFNLFVBQVUsYUFBYSxNQUFNLEdBQUcsRUFBRSxDQUFDLEdBQUcsS0FBSztBQUNqRCxlQUFPLFlBQVksTUFBUztBQUU1QixjQUFNLGNBQWMscUJBQXFCLFFBQVEsUUFBUTtBQUN6RCxjQUFNLGNBQWMsS0FBSyxNQUFNLGdCQUFnQixXQUFXLENBQUM7QUFDM0QsY0FBTSxjQUFjLFlBQVksS0FBSyxNQUFNLEdBQUcsRUFBRSxDQUFDO0FBQ2pELGVBQU8sZ0JBQWdCLE1BQVM7QUFFaEMsY0FBTSxTQUFTLFdBQVcsV0FBVyxjQUFjLE9BQU87QUFFMUQsY0FBTSxzQkFBc0IsUUFBUSxLQUFLLFNBQVMsQ0FBQyxTQUFTLEtBQUssU0FBUyxlQUFlLGlCQUFpQjtBQUMxRyxlQUFPLG1CQUFtQjtBQUUxQixnQkFBUSxPQUFPO0FBQUEsVUFDYixXQUFXO0FBQUEsVUFDWCxNQUFNO0FBQUEsVUFDTixJQUFJLE9BQU87QUFDVCxtQkFBTyxNQUFNLGdCQUFnQixxQkFBcUI7QUFBQSw0QkFBK0IsTUFBTTtBQUFBLENBQU07QUFBQSxVQUMvRjtBQUFBLFFBQ0YsQ0FBQztBQUFBLE1BQ0g7QUFBQSxJQUNGO0FBQUEsRUFDRjtBQUNGLENBQUM7QUFFRCxJQUFPLDhCQUFROyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist-mjs/agent/add-base-path-import.mjs

@@ -1,60 +0,0 @@
-// src/agent/add-base-path-import.ts
-import { strict as assert } from "node:assert";
-import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
-import getDocumentationUrl from "../get-documentation-url.mjs";
-import { getApiIndexPathByFilename } from "./file.mjs";
-var ruleId = "add-base-path-import";
-var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-var rule = 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 !== void 0) {
-            const lastImportStatement = program.body.findLast(
-              (statement) => statement.type === AST_NODE_TYPES.ImportDeclaration
-            );
-            assert(lastImportStatement);
-            const basePathImportStatement = `
-import { BASE_PATH } from '${apiIndexPath}';
-`;
-            context.report({
-              node: program,
-              messageId: "addBasePathImport",
-              fix(fixer) {
-                return fixer.insertTextAfter(lastImportStatement, basePathImportStatement);
-              }
-            });
-          }
-        }
-      }
-    };
-  }
-});
-var add_base_path_import_default = rule;
-export {
-  add_base_path_import_default as default,
-  ruleId
-};
-//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L2FkZC1iYXNlLXBhdGgtaW1wb3J0LnRzIl0sCiAgIm1hcHBpbmdzIjogIjtBQVFBLFNBQVMsVUFBVSxjQUFjO0FBRWpDLFNBQVMsZ0JBQWdCLG1CQUFtQjtBQUU1QyxPQUFPLHlCQUF5QjtBQUNoQyxTQUFTLGlDQUFpQztBQUVuQyxJQUFNLFNBQVM7QUFFdEIsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQW9ELFdBQVc7QUFBQSxFQUNuRSxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1IsbUJBQW1CO0FBQUEsSUFDckI7QUFBQSxJQUNBLFNBQVM7QUFBQSxJQUNULFFBQVEsQ0FBQztBQUFBLEVBQ1g7QUFBQSxFQUNBLGdCQUFnQixDQUFDO0FBQUEsRUFDakIsT0FBTyxTQUFTO0FBQ2QsVUFBTSxhQUFhLFFBQVE7QUFFM0IsV0FBTztBQUFBLE1BQ0wsU0FBUyxDQUFDLFlBQVk7QUFDcEIsY0FBTSxpQkFBaUIsV0FBVyxLQUFLLFNBQVMsZUFBZTtBQUMvRCxZQUFJLGdCQUFnQjtBQUNsQixnQkFBTSxXQUFXLFdBQVcsU0FBUyxPQUFPLEVBQUUsWUFBWSxDQUFDO0FBQzNELGlCQUFPLFFBQVE7QUFDZixjQUFJLFNBQVMsVUFBVSxLQUFLLENBQUMsYUFBYSxTQUFTLFNBQVMsV0FBVyxHQUFHO0FBQ3hFO0FBQUEsVUFDRjtBQUVBLGdCQUFNLGVBQWUsMEJBQTBCLFFBQVEsUUFBUTtBQUMvRCxjQUFJLGlCQUFpQixRQUFXO0FBQzlCLGtCQUFNLHNCQUFzQixRQUFRLEtBQUs7QUFBQSxjQUN2QyxDQUFDLGNBQWMsVUFBVSxTQUFTLGVBQWU7QUFBQSxZQUNuRDtBQUNBLG1CQUFPLG1CQUFtQjtBQUUxQixrQkFBTSwwQkFBMEI7QUFBQSw2QkFBZ0MsWUFBWTtBQUFBO0FBQzVFLG9CQUFRLE9BQU87QUFBQSxjQUNiLE1BQU07QUFBQSxjQUNOLFdBQVc7QUFBQSxjQUNYLElBQUksT0FBTztBQUNULHVCQUFPLE1BQU0sZ0JBQWdCLHFCQUFxQix1QkFBdUI7QUFBQSxjQUMzRTtBQUFBLFlBQ0YsQ0FBQztBQUFBLFVBQ0g7QUFBQSxRQUNGO0FBQUEsTUFDRjtBQUFBLElBQ0Y7QUFBQSxFQUNGO0FBQ0YsQ0FBQztBQUVELElBQU8sK0JBQVE7IiwKICAibmFtZXMiOiBbXQp9Cg==