@checkdigit/eslint-plugin 7.17.1 → 8.0.0-PR.141-56ee

package/src/require-assert-message.ts

@@ -22,11 +22,13 @@ const rule: TSESLint.RuleModule<string, unknown[]> = createRule({
   meta: {
     type: 'problem',
     docs: {
-      description: 'Validate that message argument is always supplied to node:assert methods',
+      description:
+        'Validate that message argument is always supplied to node:assert methods',
     },
     schema: [],
     messages: {
-      [MISSING_ASSERT_MESSAGE]: 'Missing message argument in {{methodName}}() method.',
+      [MISSING_ASSERT_MESSAGE]:
+        'Missing message argument in {{methodName}}() method.',
     },
   },
   defaultOptions: [],
@@ -39,7 +41,8 @@ const rule: TSESLint.RuleModule<string, unknown[]> = createRule({
         if (node.source.value === 'node:assert') {
           const specifier = node.specifiers.find(
             (importSpecifier) =>
-              importSpecifier.type === TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier ||
+              importSpecifier.type ===
+                TSESTree.AST_NODE_TYPES.ImportDefaultSpecifier ||
               importSpecifier.type === TSESTree.AST_NODE_TYPES.ImportSpecifier,
           );
           if (specifier) {
@@ -61,11 +64,16 @@ const rule: TSESLint.RuleModule<string, unknown[]> = createRule({
             if (!(methodName in messageIndexCache)) {
               const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
               const signature = checker.getResolvedSignature(tsNode);
-              messageIndexCache[methodName] = signature?.getParameters().findIndex((param) => param.name === 'message');
+              messageIndexCache[methodName] = signature
+                ?.getParameters()
+                .findIndex((param) => param.name === 'message');
             }
 
             const messageIndex = messageIndexCache[methodName];
-            if (messageIndex !== undefined && node.arguments.length <= messageIndex) {
+            if (
+              messageIndex !== undefined &&
+              node.arguments.length <= messageIndex
+            ) {
               context.report({
                 node,
                 messageId: MISSING_ASSERT_MESSAGE,

package/src/require-assert-predicate-rejects-throws.ts

@@ -12,7 +12,8 @@ export default {
   meta: {
     type: 'problem',
     docs: {
-      description: 'Validate that assert Predicate is always supplied to node:assert rejects,throws methods',
+      description:
+        'Validate that assert Predicate is always supplied to node:assert rejects,throws methods',
       url: 'https://github.com/checkdigit/eslint-plugin',
     },
   },
@@ -39,7 +40,8 @@ export default {
           callee.object.type === 'Identifier' &&
           callee.object.name === assertIdentifier &&
           callee.property.type === 'Identifier' &&
-          (callee.property.name === 'rejects' || callee.property.name === 'throws') &&
+          (callee.property.name === 'rejects' ||
+            callee.property.name === 'throws') &&
           node.arguments.length >= 1
         ) {
           const assertPredicate = node.arguments[1];
@@ -54,7 +56,8 @@ export default {
           ) {
             context.report({
               node,
-              message: 'Second argument in {{method}} method should be of type AssertPredicate.',
+              message:
+                'Second argument in {{method}} method should be of type AssertPredicate.',
               data: {
                 method: callee.property.name,
               },

package/src/require-fixed-services-import.ts

@@ -9,31 +9,43 @@
 import { strict as assert } from 'node:assert';
 import path from 'node:path';
 
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESTree,
+} from '@typescript-eslint/utils';
 
 import getDocumentationUrl from './get-documentation-url.ts';
 
 export const ruleId = 'require-fixed-services-import';
 
 const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
-const SERVICE_TYPINGS_IMPORT_PATH = /(?<path>\.\.\/)+services(?!\/index(?:\.ts)?)\/.*/u;
+const SERVICE_TYPINGS_IMPORT_PATH =
+  /(?<path>\.\.\/)+services(?!\/index(?:\.ts)?)\/.*/u;
 const SERVICE_TYPINGS_IMPORT_PATH_WITH_VERSION =
+  // Groups are destructed in the code
+  // eslint-disable-next-line sonarjs/unused-named-groups
   /(?<path>\.\.\/)+services\/(?<service>\w+)\/(?<version>v\d+)(?<index>\/index(?:\.ts)?)?/u;
 
 const rule: ESLintUtils.RuleModule<
-  'updateServicesImportSpecifier' | 'updateServicesImportSource' | 'renameServiceTypeReference'
+  | 'updateServicesImportSpecifier'
+  | 'updateServicesImportSource'
+  | 'renameServiceTypeReference'
 > = createRule({
   name: ruleId,
   meta: {
     type: 'suggestion',
     docs: {
-      description: 'Require fixed "from" with service typing imports from "src/services".',
+      description:
+        'Require fixed "from" with service typing imports from "src/services".',
     },
     messages: {
       updateServicesImportSpecifier:
         'Update service typing import specifiers to be from the corresponding service version namespace.',
-      updateServicesImportSource: 'Update service typing imports to be from the fixed "src/services" path.',
-      renameServiceTypeReference: 'Rename service type reference using the corresponding service version namespace.',
+      updateServicesImportSource:
+        'Update service typing imports to be from the fixed "src/services" path.',
+      renameServiceTypeReference:
+        'Rename service type reference using the corresponding service version namespace.',
     },
     fixable: 'code',
     schema: [],
@@ -53,7 +65,8 @@ const rule: ESLintUtils.RuleModule<
 
         if (SERVICE_TYPINGS_IMPORT_PATH.test(moduleName)) {
           // make sure that it matches only the src/services path
-          const match = SERVICE_TYPINGS_IMPORT_PATH_WITH_VERSION.exec(moduleName);
+          const match =
+            SERVICE_TYPINGS_IMPORT_PATH_WITH_VERSION.exec(moduleName);
           if (match?.groups) {
             // need to import the service typings from the fixed path, and also apply the namespace to the referenced types
             const { service, version } = match.groups;
@@ -65,7 +78,10 @@ const rule: ESLintUtils.RuleModule<
                 specifier.type === AST_NODE_TYPES.ImportSpecifier &&
                 specifier.imported.type === AST_NODE_TYPES.Identifier
               ) {
-                importedServiceTypeMapping.set(specifier.local.name, `${service}.${specifier.imported.name}`);
+                importedServiceTypeMapping.set(
+                  specifier.local.name,
+                  `${service}.${specifier.imported.name}`,
+                );
               }
             }
 
@@ -78,7 +94,10 @@ const rule: ESLintUtils.RuleModule<
               messageId: 'updateServicesImportSpecifier',
               node: importDeclaration.source,
               *fix(fixer) {
-                yield fixer.replaceTextRange([rangeStart, rangeEnd], `${service}V${version.slice(1)} as ${service}`);
+                yield fixer.replaceTextRange(
+                  [rangeStart, rangeEnd],
+                  `${service}V${version.slice(1)} as ${service}`,
+                );
               },
             });
           }
@@ -102,7 +121,9 @@ const rule: ESLintUtils.RuleModule<
           typeReference.typeName.type === AST_NODE_TYPES.Identifier &&
           importedServiceTypeMapping.has(typeReference.typeName.name)
         ) {
-          const renamedTypeName = importedServiceTypeMapping.get(typeReference.typeName.name);
+          const renamedTypeName = importedServiceTypeMapping.get(
+            typeReference.typeName.name,
+          );
           assert.ok(renamedTypeName !== undefined);
           context.report({
             messageId: 'renameServiceTypeReference',

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

@@ -7,210 +7,259 @@
  */
 
 import { strict as assert } from 'node:assert';
-import { AST_NODE_TYPES, ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESTree,
+} from '@typescript-eslint/utils';
 import { DefinitionType, type Scope } from '@typescript-eslint/scope-manager';
 import getDocumentationUrl from './get-documentation-url.ts';
 import { getEnclosingScopeNode } from './library/ts-tree.ts';
 
 export const ruleId = 'require-resolve-full-response';
 // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-export const PLAIN_URL_REGEXP: RegExp = /^[`']\/\w+(?<serviceNamePart>-\w+)*\/v\d+\/(?<any>.|\r|\n)+[`']$/u;
+export const PLAIN_URL_REGEXP: RegExp =
+  /^[`']\/\w+(?<serviceNamePart>-\w+)*\/v\d+\/(?<any>.|\r|\n)+[`']$/u;
 // eslint-disable-next-line @typescript-eslint/no-inferrable-types
-export const TOKENIZED_URL_REGEXP: RegExp = /^`\$\{(?<serviceNamePart>[A-Z]+_)*BASE_PATH\}\/(?<any>.|\r|\n)+`$/u;
+export const TOKENIZED_URL_REGEXP: RegExp =
+  /^`\$\{(?<serviceNamePart>[A-Z]+_)*BASE_PATH\}\/(?<any>.|\r|\n)+`$/u;
 
 const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
 
-const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> = createRule({
-  name: ruleId,
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: 'Prefer native fetch over customized service wrapper.',
-    },
-    messages: {
-      invalidOptions:
-        '"options" argument should be provided with "resolveWithFullResponse" property set as "true". Otherwise, it indicates that the response body will be obtained without status code assertion which could result in unexpected issue.',
-      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+const rule: ESLintUtils.RuleModule<'invalidOptions' | 'unknownError'> =
+  createRule({
+    name: ruleId,
+    meta: {
+      type: 'suggestion',
+      docs: {
+        description: 'Prefer native fetch over customized service wrapper.',
+      },
+      messages: {
+        invalidOptions:
+          '"options" argument should be provided with "resolveWithFullResponse" property set as "true". Otherwise, it indicates that the response body will be obtained without status code assertion which could result in unexpected issue.',
+        unknownError:
+          'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+      },
+      schema: [],
     },
-    schema: [],
-  },
-  defaultOptions: [],
-  create(context) {
-    const sourceCode = context.sourceCode;
-    const scopeManager = sourceCode.scopeManager;
-    const parserService = ESLintUtils.getParserServices(context);
-    const typeChecker = parserService.program.getTypeChecker();
-
-    function isUrlArgumentValid(urlArgument: TSESTree.Node | undefined, scope: Scope) {
-      if (
-        (urlArgument?.type === AST_NODE_TYPES.Literal && typeof urlArgument.value === 'string') ||
-        urlArgument?.type === AST_NODE_TYPES.TemplateLiteral
+    // eslint-disable-next-line max-lines-per-function
+    create(context) {
+      const sourceCode = context.sourceCode;
+      const scopeManager = sourceCode.scopeManager;
+      const parserService = ESLintUtils.getParserServices(context);
+      const typeChecker = parserService.program.getTypeChecker();
+
+      function isUrlArgumentValid(
+        urlArgument: TSESTree.Node | undefined,
+        scope: Scope,
       ) {
-        const urlText = sourceCode.getText(urlArgument);
-        return PLAIN_URL_REGEXP.test(urlText) || TOKENIZED_URL_REGEXP.test(urlText);
-      }
+        if (
+          (urlArgument?.type === AST_NODE_TYPES.Literal &&
+            typeof urlArgument.value === 'string') ||
+          urlArgument?.type === AST_NODE_TYPES.TemplateLiteral
+        ) {
+          const urlText = sourceCode.getText(urlArgument);
+          return (
+            PLAIN_URL_REGEXP.test(urlText) || TOKENIZED_URL_REGEXP.test(urlText)
+          );
+        }
 
-      if (urlArgument?.type === AST_NODE_TYPES.Identifier) {
-        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);
+        if (urlArgument?.type === AST_NODE_TYPES.Identifier) {
+          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;
           }
-          return true;
         }
-      }
-
-      return false;
-    }
 
-    function getType(identifier: TSESTree.Identifier) {
-      const variable = parserService.esTreeNodeToTSNodeMap.get(identifier);
-      const variableType = typeChecker.getTypeAtLocation(variable);
-      return typeChecker.typeToString(variableType);
-    }
-
-    function isServiceLikeName(name: string) {
-      return /.*[Ss]ervice$/u.test(name);
-    }
-
-    function isCalleeServiceWrapper(serviceCall: TSESTree.CallExpression) {
-      const callee = serviceCall.callee;
-      if (callee.type !== AST_NODE_TYPES.MemberExpression) {
         return false;
       }
 
-      const endpoint = callee.object;
-      if (endpoint.type === AST_NODE_TYPES.Identifier) {
-        return getType(endpoint) === 'Endpoint' || isServiceLikeName(endpoint.name);
-      }
-      if (endpoint.type !== AST_NODE_TYPES.CallExpression) {
-        return false;
+      function getType(identifier: TSESTree.Identifier) {
+        const variable = parserService.esTreeNodeToTSNodeMap.get(identifier);
+        const variableType = typeChecker.getTypeAtLocation(variable);
+        return typeChecker.typeToString(variableType);
       }
 
-      const [contextArgument] = endpoint.arguments;
-      if (contextArgument?.type !== AST_NODE_TYPES.Identifier) {
-        return false;
-      }
-      if (contextArgument.name !== 'EMPTY_CONTEXT' && getType(contextArgument) !== 'InboundContext') {
-        return false;
-      }
-      const service = endpoint.callee;
-      if (service.type === AST_NODE_TYPES.Identifier) {
-        return getType(service) === 'ResolvedService';
+      function isServiceLikeName(name: string) {
+        // eslint-disable-next-line sonarjs/slow-regex
+        return /.*[Ss]ervice$/u.test(name);
       }
 
-      if (service.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      const services = service.object;
-      if (services.type === AST_NODE_TYPES.Identifier) {
-        return getType(services) === 'ResolvedServices';
-      }
+      function isCalleeServiceWrapper(serviceCall: TSESTree.CallExpression) {
+        const callee = serviceCall.callee;
+        if (callee.type !== AST_NODE_TYPES.MemberExpression) {
+          return false;
+        }
 
-      if (services.type !== AST_NODE_TYPES.MemberExpression) {
-        return false;
-      }
-      const configuration = services.object;
-      if (configuration.type === AST_NODE_TYPES.Identifier) {
-        return ['Configuration', 'Configuration<ResolvedServices>'].includes(getType(configuration));
-      }
+        const endpoint = callee.object;
+        if (endpoint.type === AST_NODE_TYPES.Identifier) {
+          return (
+            getType(endpoint) === 'Endpoint' || isServiceLikeName(endpoint.name)
+          );
+        }
+        if (endpoint.type !== AST_NODE_TYPES.CallExpression) {
+          return false;
+        }
+
+        const [contextArgument] = endpoint.arguments;
+        if (contextArgument?.type !== AST_NODE_TYPES.Identifier) {
+          return false;
+        }
+        if (
+          contextArgument.name !== 'EMPTY_CONTEXT' &&
+          getType(contextArgument) !== 'InboundContext'
+        ) {
+          return false;
+        }
+        const service = endpoint.callee;
+        if (service.type === AST_NODE_TYPES.Identifier) {
+          return getType(service) === 'ResolvedService';
+        }
+
+        if (service.type !== AST_NODE_TYPES.MemberExpression) {
+          return false;
+        }
+        const services = service.object;
+        if (services.type === AST_NODE_TYPES.Identifier) {
+          return getType(services) === 'ResolvedServices';
+        }
+
+        if (services.type !== AST_NODE_TYPES.MemberExpression) {
+          return false;
+        }
+        const configuration = services.object;
+        if (configuration.type === AST_NODE_TYPES.Identifier) {
+          return ['Configuration', 'Configuration<ResolvedServices>'].includes(
+            getType(configuration),
+          );
+        }
+
+        // following applies only to test code (fixture)
+        if (configuration.type !== AST_NODE_TYPES.MemberExpression) {
+          return false;
+        }
+        const fixture = configuration.object;
+        if (fixture.type === AST_NODE_TYPES.Identifier) {
+          return fixture.name === 'fixture' || getType(fixture) === 'Fixture';
+        }
 
-      // following applies only to test code (fixture)
-      if (configuration.type !== AST_NODE_TYPES.MemberExpression) {
         return false;
       }
-      const fixture = configuration.object;
-      if (fixture.type === AST_NODE_TYPES.Identifier) {
-        return fixture.name === 'fixture' || getType(fixture) === 'Fixture';
-      }
 
-      return false;
-    }
+      return {
+        'CallExpression[callee.property.name=/^(head|get|put|post|del|patch)$/]':
+          (serviceCall: TSESTree.CallExpression) => {
+            try {
+              if (!isCalleeServiceWrapper(serviceCall)) {
+                return;
+              }
 
-    return {
-      'CallExpression[callee.property.name=/^(head|get|put|post|del|patch)$/]': (
-        serviceCall: TSESTree.CallExpression,
-      ) => {
-        try {
-          if (!isCalleeServiceWrapper(serviceCall)) {
-            return;
-          }
+              const enclosingScopeNode = getEnclosingScopeNode(serviceCall);
+              assert.ok(enclosingScopeNode, 'enclosingScopeNode is undefined');
+              const scope = scopeManager?.acquire(enclosingScopeNode);
+              assert.ok(scope, 'scope is undefined');
+              const urlArgument = serviceCall.arguments[0];
+              if (!isUrlArgumentValid(urlArgument, scope)) {
+                return;
+              }
 
-          const enclosingScopeNode = getEnclosingScopeNode(serviceCall);
-          assert.ok(enclosingScopeNode, 'enclosingScopeNode is undefined');
-          const scope = scopeManager?.acquire(enclosingScopeNode);
-          assert.ok(scope, 'scope is undefined');
-          const urlArgument = serviceCall.arguments[0];
-          if (!isUrlArgumentValid(urlArgument, scope)) {
-            return;
-          }
+              assert.ok(
+                serviceCall.callee.type === AST_NODE_TYPES.MemberExpression,
+              );
+              assert.ok(
+                serviceCall.callee.property.type === AST_NODE_TYPES.Identifier,
+              );
 
-          assert.ok(serviceCall.callee.type === AST_NODE_TYPES.MemberExpression);
-          assert.ok(serviceCall.callee.property.type === AST_NODE_TYPES.Identifier);
-
-          // method
-          const method = serviceCall.callee.property.name;
-
-          // options
-          const optionsArgument = ['get', 'head', 'del'].includes(method)
-            ? serviceCall.arguments[1]
-            : serviceCall.arguments[2];
-          if (optionsArgument === undefined) {
-            context.report({
-              node: serviceCall,
-              messageId: 'invalidOptions',
-            });
-            return;
-          }
+              // method
+              const method = serviceCall.callee.property.name;
 
-          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;
+              // options
+              const optionsArgument = ['get', 'head', 'del'].includes(method)
+                ? serviceCall.arguments[1]
+                : serviceCall.arguments[2];
+              if (optionsArgument === undefined) {
+                context.report({
+                  node: serviceCall,
+                  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,
+              );
+              context.report({
+                node: serviceCall,
+                messageId: 'unknownError',
+                data: {
+                  fileName: context.filename,
+                  error:
+                    error instanceof Error
+                      ? error.toString()
+                      : JSON.stringify(error),
+                },
+              });
             }
-          }
-          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);
-          context.report({
-            node: serviceCall,
-            messageId: 'unknownError',
-            data: {
-              fileName: context.filename,
-              error: error instanceof Error ? error.toString() : JSON.stringify(error),
-            },
-          });
-        }
-      },
-    };
-  },
-});
+          },
+      };
+    },
+  });
 
 export default rule;