@checkdigit/eslint-plugin 7.4.1 → 7.5.0-PR.75-0252

package/src/agent/response-reference.ts

@@ -0,0 +1,129 @@
+// 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 type { MemberExpression, ObjectPattern, VariableDeclaration } from 'estree';
+import { type Scope } from 'eslint';
+import debug from 'debug';
+
+import { getParent } from '../library/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
+ */
+export function analyzeResponseReferences(
+  variableDeclaration: VariableDeclaration | undefined,
+  scopeManager: Scope.ScopeManager,
+): {
+  variable?: Scope.Variable;
+  bodyReferences: MemberExpression[];
+  headersReferences: MemberExpression[];
+  statusReferences: MemberExpression[];
+  destructuringBodyVariable?: Scope.Variable | ObjectPattern;
+  destructuringHeadersVariable?: Scope.Variable | ObjectPattern;
+  destructuringHeadersReferences?: MemberExpression[] | undefined;
+} {
+  const results: {
+    variable?: Scope.Variable;
+    bodyReferences: MemberExpression[];
+    headersReferences: MemberExpression[];
+    statusReferences: MemberExpression[];
+    destructuringBodyVariable?: Scope.Variable | ObjectPattern;
+    destructuringHeadersVariable?: Scope.Variable | ObjectPattern;
+    destructuringHeadersReferences?: 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 === '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 MemberExpression =>
+          node?.type === 'MemberExpression' && node.property.type === 'Identifier' && node.property.name === 'body',
+      );
+      // e.g. response.headers / response.header / response.get()
+      results.headersReferences = responseReferences.filter(
+        (node): node is MemberExpression =>
+          node?.type === 'MemberExpression' &&
+          node.property.type === '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 MemberExpression =>
+          node?.type === 'MemberExpression' &&
+          node.property.type === 'Identifier' &&
+          (node.property.name === 'status' || node.property.name === 'statusCode'),
+      );
+    } else if (
+      // body reference through destruction/renaming, e.g. "const { body } = ..."
+      identifierParent.type === 'Property' &&
+      identifierParent.key.type === 'Identifier' &&
+      identifierParent.key.name === 'body'
+    ) {
+      results.destructuringBodyVariable = responseVariable;
+    } else if (
+      // header reference through destruction/renaming, e.g. "const { headers } = ..."
+      identifierParent.type === 'Property' &&
+      identifierParent.key.type === 'Identifier' &&
+      identifierParent.key.name === 'headers'
+    ) {
+      results.destructuringHeadersVariable = responseVariable;
+      results.destructuringHeadersReferences = responseVariable.references
+        .map((reference) => reference.identifier)
+        .map(getParent)
+        .filter(
+          (parent): parent is MemberExpression =>
+            parent?.type === 'MemberExpression' &&
+            parent.property.type === 'Identifier' &&
+            parent.property.name !== 'get' &&
+            getParent(parent)?.type !== 'CallExpression',
+        );
+    } else if (identifierParent.type === 'Property') {
+      const parent = getParent(identifierParent);
+      if (parent?.type === 'ObjectPattern') {
+        // body reference through nested destruction, e.g. "const { body: {bodyPropertyName: renamedBodyPropertyName}, headers: {headerPropertyName: renamedHeaderPropertyName} } = ..."
+        const parent2 = getParent(parent);
+        if (parent2?.type === 'Property' && parent2.key.type === 'Identifier' && parent2.key.name === 'body') {
+          results.destructuringBodyVariable = parent;
+        }
+        if (
+          parent2?.type === 'Property' &&
+          parent2.key.type === '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/url.ts

@@ -0,0 +1,32 @@
+// 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',
+  );
+}

package/src/index.ts

@@ -8,10 +8,30 @@
 
 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 fetchResponseStatus, { ruleId as fetchResponseStatusRuleId } from './agent/fetch-response-status';
+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 noFullResponse, { ruleId as noFullResponseRuleId } from './agent/no-full-response';
+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 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';
@@ -21,7 +41,10 @@ import requireResolveFullResponse, {
 import requireTypeOutOfTypeOnlyImports, {
   ruleId as requireTypeOutOfTypeOnlyImportsRuleId,
 } from './require-type-out-of-type-only-imports';
-import noServeRuntime, { ruleId as noServeRuntimeRuleId } from './agent/no-serve-runtime';
+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 filePathComment from './file-path-comment';
 import noCardNumbers from './no-card-numbers';
 import noSideEffects from './no-side-effects';
@@ -48,69 +71,202 @@ const rules: Record<string, TSESLint.LooseRuleDefinition> = {
   'object-literal-response': objectLiteralResponse,
   [invalidJsonStringifyRuleId]: invalidJsonStringify,
   [noPromiseInstanceMethodRuleId]: noPromiseInstanceMethod,
-  [noFullResponseRuleId]: noFullResponse,
+  [noFixtureRuleId]: noFixture,
+  [fetchThenRuleId]: fetchThen,
+  [noServiceWrapperRuleId]: noServiceWrapper,
+  [noStatusCodeRuleId]: noStatusCode,
+  [fetchResponseBodyJsonRuleId]: fetchResponseBodyJson,
+  [fetchResponseHeaderGetterRuleId]: fetchResponseHeaderGetter,
+  [fetchResponseStatusRuleId]: fetchResponseStatus,
+  [addUrlDomainRuleId]: addUrlDomain,
+  [noLegacyServiceTypingRuleId]: noLegacyServiceTyping,
+  [noMappedResponseRuleId]: noMappedResponse,
   [requireResolveFullResponseRuleId]: requireResolveFullResponse,
-  [requireTypeOutOfTypeOnlyImportsRuleId]: requireTypeOutOfTypeOnlyImports,
   [noDuplicatedImportsRuleId]: noDuplicatedImports,
-  [requireFixedServicesImportRuleId]: requireFixedServicesImport,
   [noServeRuntimeRuleId]: noServeRuntime,
+  [addBasePathConstRuleId]: addBasePathConst,
+  [addBasePathImportRuleId]: addBasePathImport,
+  [addAssertImportRuleId]: addAssertImport,
+  [requireFixedServicesImportRuleId]: requireFixedServicesImport,
+  [requireTypeOutOfTypeOnlyImportsRuleId]: requireTypeOutOfTypeOnlyImports,
+  [noUnusedFunctionArgumentsRuleId]: noUnusedFunctionArguments,
+  [noUnusedServiceVariablesRuleId]: noUnusedServiceVariables,
+  [noUnusedImportsRuleId]: noUnusedImports,
+  [fixFunctionCallArgumentsRuleId]: fixFunctionCallArguments,
+  [agentTestWiringRuleId]: agentTestWiring,
 };
 
 const plugin: TSESLint.FlatConfig.Plugin = {
   rules,
 };
 
-const configs: Record<string, TSESLint.FlatConfig.Config> = {
-  all: {
-    plugins: {
-      '@checkdigit': plugin,
+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-random-v4-uuid': 'error',
+        '@checkdigit/no-uuid': 'error',
+        '@checkdigit/require-strict-assert': 'error',
+        '@checkdigit/no-wallaby-comment': 'error',
+        '@checkdigit/no-side-effects': ['error', { excludedIdentifiers: ['assert', 'debug', 'log', 'promisify'] }],
+        '@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/${fetchResponseStatusRuleId}`]: '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-random-v4-uuid': 'error',
+        '@checkdigit/no-uuid': 'error',
+        '@checkdigit/require-strict-assert': 'error',
+        '@checkdigit/no-wallaby-comment': 'off',
+        '@checkdigit/no-side-effects': '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}`]: 'off',
+        [`@checkdigit/${noLegacyServiceTypingRuleId}`]: 'off',
+        [`@checkdigit/${requireResolveFullResponseRuleId}`]: 'off',
+        [`@checkdigit/${noDuplicatedImportsRuleId}`]: 'error',
+        [`@checkdigit/${requireFixedServicesImportRuleId}`]: 'off',
+        [`@checkdigit/${requireTypeOutOfTypeOnlyImportsRuleId}`]: 'error',
+        [`@checkdigit/${noServeRuntimeRuleId}`]: 'off',
+        // --- 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/${fetchResponseStatusRuleId}`]: '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 ---
+      },
     },
-    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/no-side-effects': ['error', { excludedIdentifiers: ['assert', 'debug', 'log', 'promisify'] }],
-      '@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',
+  ],
+  '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/${noServiceWrapperRuleId}`]: 'error',
+        [`@checkdigit/${noStatusCodeRuleId}`]: 'error',
+        [`@checkdigit/${fetchResponseBodyJsonRuleId}`]: 'error',
+        [`@checkdigit/${fetchResponseHeaderGetterRuleId}`]: 'error',
+        [`@checkdigit/${fetchResponseStatusRuleId}`]: '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',
+      },
     },
-  },
-  recommended: {
-    plugins: {
-      '@checkdigit': plugin,
+    {
+      files: ['**/*.spec.ts'],
+      ignores: ['src/plugin/**'],
+      plugins: {
+        '@checkdigit': plugin,
+      },
+      rules: {
+        [`@checkdigit/${agentTestWiringRuleId}`]: 'error',
+        [`@checkdigit/${noFixtureRuleId}`]: '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/no-side-effects': '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',
+  ],
+  'agent-phase-2-production': [
+    {
+      files: ['**/*.ts'],
+      ignores: ['src/plugin/**'],
+      plugins: {
+        '@checkdigit': plugin,
+      },
+      rules: {
+        [`@checkdigit/${noMappedResponseRuleId}`]: 'error',
+        [`@checkdigit/${addUrlDomainRuleId}`]: 'error',
+        [`@checkdigit/${noServiceWrapperRuleId}`]: 'error',
+        [`@checkdigit/${noStatusCodeRuleId}`]: 'error',
+        [`@checkdigit/${fetchResponseBodyJsonRuleId}`]: 'error',
+        [`@checkdigit/${fetchResponseHeaderGetterRuleId}`]: 'error',
+        [`@checkdigit/${fetchResponseStatusRuleId}`]: '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',
+      },
     },
-  },
+  ],
 };
 
-const pluginToExport: TSESLint.FlatConfig.Plugin = {
+const defaultToExport: Exclude<TSESLint.FlatConfig.Plugin, 'config'> & {
+  configs: Record<string, TSESLint.FlatConfig.Config | TSESLint.FlatConfig.Config[]>;
+} = {
   ...plugin,
   configs,
 };
-export default pluginToExport;
+export default defaultToExport;

package/src/library/tree.ts

@@ -64,6 +64,7 @@ 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-legacy-service-typing.ts

@@ -0,0 +1,49 @@
+// no-legacy-service-typing.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';
+
+export const ruleId = 'no-legacy-service-typing';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const DISALLOWED_SERVICE_TYPINGS: string[] | undefined = ['FullResponse', 'Endpoint'];
+
+const rule: ESLintUtils.RuleModule<'noLegacyServiceTyping', [typeof DISALLOWED_SERVICE_TYPINGS]> = createRule({
+  name: ruleId,
+  meta: {
+    type: 'problem',
+    docs: {
+      description: 'Legacy service typings should not be used.',
+    },
+    messages: {
+      noLegacyServiceTyping: 'Please remove the usage of legacy service typings.',
+    },
+    schema: [{ type: 'array', items: { type: 'string' } }],
+  },
+  defaultOptions: [DISALLOWED_SERVICE_TYPINGS],
+  create(context) {
+    return {
+      TSTypeReference: (typeReference: TSESTree.TSTypeReference) => {
+        if (
+          typeReference.typeName.type === AST_NODE_TYPES.Identifier &&
+          // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          (context.options[0] ?? DISALLOWED_SERVICE_TYPINGS).includes(typeReference.typeName.name)
+        ) {
+          context.report({
+            messageId: 'noLegacyServiceTyping',
+            node: typeReference,
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

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

@@ -1,4 +1,4 @@
-// agent/no-serve-runtime.ts
+// 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/require-fixed-services-import.ts

@@ -13,7 +13,7 @@ import getDocumentationUrl from './get-documentation-url';
 export const ruleId = 'require-fixed-services-import';
 
 const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-const SERVICE_TYPINGS_IMPORT_PATH_PREFIX = /(?<path>\.\.\/)+services(?!\/index(?:\.ts)?)\/.*/u;
+const SERVICE_TYPINGS_IMPORT_PATH_PREFIX = /(?<path>\.\.\/)+services\/.*/u;
 
 const rule: ESLintUtils.RuleModule<'updateServicesImportFrom'> = createRule({
   name: ruleId,

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

@@ -54,10 +54,12 @@ 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);
-          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);
+          if (variableDefinition) {
+            const variableDefinitionNode = variableDefinition.node;
+            assert.ok(variableDefinitionNode.init, 'Variable definition node has no init property');
+            return isUrlArgumentValid(variableDefinitionNode.init, scope);
+          }
+          return true;
         }
       }
 
@@ -156,7 +158,7 @@ const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> = createRu
           const optionsArgument = ['get', 'head', 'del'].includes(method)
             ? serviceCall.arguments[1]
             : serviceCall.arguments[2];
-          if (optionsArgument === undefined || optionsArgument.type !== AST_NODE_TYPES.ObjectExpression) {
+          if (optionsArgument === undefined) {
             context.report({
               node: serviceCall,
               messageId: 'invalidOptions',
@@ -164,23 +166,38 @@ const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> = createRu
             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;
+          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;
+            }
           }
+
+          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);