@checkdigit/eslint-plugin 6.6.0-PR.79-1cec → 6.7.0-PR.79-33df

package/src/library/tree.ts

@@ -0,0 +1,90 @@
+// tree.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import type { Expression, Node } from 'estree';
+
+type NodeParent = Node | undefined | null;
+
+interface NodeParentExtension {
+  parent: NodeParent;
+}
+
+export function getParent(node: Node): Node | undefined | null {
+  return (node as unknown as NodeParentExtension).parent;
+}
+
+export function getAncestor(
+  node: Node,
+  matcher: string | ((testNode: Node) => boolean),
+  exitMatcher?: string | ((testNode: Node) => boolean),
+): Node | undefined {
+  const parent = getParent(node);
+  if (!parent) {
+    return undefined;
+  } else if (typeof matcher === 'string' && parent.type === matcher) {
+    return parent;
+  } else if (typeof matcher === 'function' && matcher(parent)) {
+    return parent;
+  } else if (typeof exitMatcher === 'string' && parent.type === exitMatcher) {
+    return undefined;
+  } else if (typeof exitMatcher === 'function' && exitMatcher(parent)) {
+    return undefined;
+  }
+  return getAncestor(parent, matcher, exitMatcher);
+}
+
+export function isBlockStatement(node: Node) {
+  return node.type.endsWith('Statement') || node.type.endsWith('Declaration');
+}
+
+export function getEnclosingStatement(node: Node) {
+  return getAncestor(node, isBlockStatement);
+}
+
+export function getEnclosingScopeNode(node: Node) {
+  return getAncestor(node, (parentNode) =>
+    ['FunctionExpression', 'FunctionDeclaration', 'ArrowFunctionExpression', 'Program'].includes(parentNode.type),
+  );
+}
+
+export function isUsedInArrayOrAsArgument(node: Node) {
+  if (isBlockStatement(node)) {
+    return false;
+  }
+
+  const parent = getParent(node);
+  if (!parent) {
+    return false;
+  }
+
+  if (
+    parent.type === 'ArrayExpression' ||
+    (parent.type === 'CallExpression' && parent.arguments.includes(node as Expression))
+  ) {
+    return true;
+  }
+
+  // recurse up the tree until hitting a block statement
+  return isUsedInArrayOrAsArgument(parent);
+}
+
+export function getEnclosingFunction(node: Node) {
+  if (
+    node.type === 'FunctionDeclaration' ||
+    node.type === 'FunctionExpression' ||
+    node.type === 'ArrowFunctionExpression'
+  ) {
+    return node;
+  }
+
+  const parent = getParent(node);
+  if (!parent) {
+    return;
+  }
+  return getEnclosingFunction(parent);
+}

package/src/library/ts-tree.ts

@@ -0,0 +1,101 @@
+// tree.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, TSESTree } from '@typescript-eslint/utils';
+
+type NodeParent = TSESTree.Node | undefined | null;
+
+interface NodeParentExtension {
+  parent: NodeParent;
+}
+
+export function getParent(node: TSESTree.Node): TSESTree.Node | undefined | null {
+  return (node as unknown as NodeParentExtension).parent;
+}
+
+export function getAncestor(
+  node: TSESTree.Node,
+  matcher: AST_NODE_TYPES | ((testNode: TSESTree.Node) => boolean),
+  exitMatcher?: AST_NODE_TYPES | ((testNode: TSESTree.Node) => boolean),
+): TSESTree.Node | undefined {
+  const parent = getParent(node);
+  if (!parent) {
+    return undefined;
+  } else if (typeof matcher === 'string' && parent.type === matcher) {
+    return parent;
+  } else if (typeof matcher === 'function' && matcher(parent)) {
+    return parent;
+  } else if (typeof exitMatcher === 'string' && parent.type === exitMatcher) {
+    return undefined;
+  } else if (typeof exitMatcher === 'function' && exitMatcher(parent)) {
+    return undefined;
+  }
+  return getAncestor(parent, matcher, exitMatcher);
+}
+
+export function isBlockStatement(node: TSESTree.Node) {
+  return node.type.endsWith('Statement') || node.type.endsWith('Declaration');
+}
+
+export function getEnclosingStatement(node: TSESTree.Node) {
+  return getAncestor(node, isBlockStatement);
+}
+
+export function getEnclosingScopeNode(node: TSESTree.Node) {
+  return getAncestor(node, (parentNode) =>
+    ['FunctionExpression', 'FunctionDeclaration', 'ArrowFunctionExpression', 'Program'].includes(parentNode.type),
+  );
+}
+
+export function isUsedInArrayOrAsArgument(node: TSESTree.Node) {
+  if (isBlockStatement(node)) {
+    return false;
+  }
+
+  const parent = getParent(node);
+  if (!parent) {
+    return false;
+  }
+
+  if (
+    parent.type === AST_NODE_TYPES.ArrayExpression ||
+    (parent.type === AST_NODE_TYPES.CallExpression && parent.arguments.includes(node as TSESTree.Expression))
+  ) {
+    return true;
+  }
+
+  // recurse up the tree until hitting a block statement
+  return isUsedInArrayOrAsArgument(parent);
+}
+
+export function getEnclosingFunction(node: TSESTree.Node) {
+  if (
+    node.type === AST_NODE_TYPES.FunctionDeclaration ||
+    node.type === AST_NODE_TYPES.FunctionExpression ||
+    node.type === AST_NODE_TYPES.ArrowFunctionExpression
+  ) {
+    return node;
+  }
+
+  const parent = getParent(node);
+  if (!parent) {
+    return;
+  }
+  return getEnclosingFunction(parent);
+}
+
+export function getTypeParentNode(
+  node: TSESTree.Node | undefined,
+): TSESTree.TSTypeAnnotation | TSESTree.TSAsExpression | undefined {
+  if (!node) {
+    return undefined;
+  }
+  return node.type === AST_NODE_TYPES.TSTypeAnnotation || node.type === AST_NODE_TYPES.TSAsExpression
+    ? node
+    : getTypeParentNode(node.parent);
+}

package/src/library/variable.ts

@@ -0,0 +1,5 @@
+// fixture/variable.ts
+
+export function isValidPropertyName(name: unknown) {
+  return typeof name === 'string' && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/u.test(name);
+}

package/src/no-enum.ts

@@ -1,18 +1,32 @@
 // no-enum.ts
 
-import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
-
 /*
  * 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';
+
 export const ruleId = 'no-enum';
 const NO_ENUM = 'NO_ENUM';
 
 const createRule = ESLintUtils.RuleCreator((name) => name);
 
+function isJsonSchemaProperty(node?: TSESTree.Node): boolean {
+  if (!node) {
+    return false;
+  }
+  if (
+    node.type === TSESTree.AST_NODE_TYPES.Property &&
+    node.key.type === TSESTree.AST_NODE_TYPES.Identifier &&
+    node.key.name === 'properties'
+  ) {
+    return true;
+  }
+  return isJsonSchemaProperty(node.parent);
+}
+
 const rule = createRule({
   name: ruleId,
   meta: {
@@ -38,7 +52,8 @@ const rule = createRule({
         if (
           node.key.type === TSESTree.AST_NODE_TYPES.Identifier &&
           node.key.name === 'enum' &&
-          node.value.type === TSESTree.AST_NODE_TYPES.ArrayExpression
+          node.value.type === TSESTree.AST_NODE_TYPES.ArrayExpression &&
+          !isJsonSchemaProperty(node.parent)
         ) {
           context.report({
             node,

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

@@ -0,0 +1,200 @@
+// require-resolve-full-response.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 { DefinitionType, type Scope } from '@typescript-eslint/scope-manager';
+import { strict as assert } from 'node:assert';
+import getDocumentationUrl from './get-documentation-url';
+import { getEnclosingScopeNode } from './library/ts-tree';
+
+export const ruleId = 'require-resolve-full-response';
+export const PLAIN_URL_REGEXP = /^[`']\/\w+(?<serviceNamePart>-\w+)*\/v\d+\/(?<any>.|\r|\n)+[`']$/u;
+export const TOKENIZED_URL_REGEXP = /^`\$\{(?<serviceNamePart>[A-Z]+_)*BASE_PATH\}\/(?<any>.|\r|\n)+`$/u;
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule = 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: [],
+  },
+  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
+      ) {
+        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);
+          assert.ok(variableDefinition, `Variable "${urlArgument.name}" not defined in scope`);
+          const variableDefinitionNode = variableDefinition.node;
+          assert.ok(variableDefinitionNode.type === AST_NODE_TYPES.VariableDeclarator);
+          assert.ok(variableDefinitionNode.init, 'Variable definition node has no init property');
+          return isUrlArgumentValid(variableDefinitionNode.init, scope);
+        }
+      }
+
+      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;
+      }
+
+      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';
+      }
+
+      return false;
+    }
+
+    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;
+          }
+
+          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 || optionsArgument.type !== AST_NODE_TYPES.ObjectExpression) {
+            context.report({
+              node: serviceCall,
+              messageId: 'invalidOptions',
+            });
+            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;
+          }
+        } 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;