@checkdigit/eslint-plugin 6.6.0-PR.75-7695 → 6.6.0-PR.75-8ba0

package/src/fixture/no-full-response.ts

@@ -0,0 +1,75 @@
+// fixture/no-full-response.ts
+
+/*
+ * Copyright (c) 2021-2024 Check Digit, LLC
+ *
+ * This code is licensed under the MIT license (see LICENSE.txt for details).
+ */
+
+import { ESLintUtils, TSESTree } from '@typescript-eslint/utils';
+import { strict as assert } from 'node:assert';
+import getDocumentationUrl from '../get-documentation-url';
+import { getTypeParentNode } from './ts-tree';
+
+export const ruleId = 'no-full-response';
+
+const createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+
+const rule = createRule({
+  name: ruleId,
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Remove the usage of FullResponse type.',
+    },
+    messages: {
+      removeFullResponse: 'Remove the usage of FullResponse type.',
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.',
+    },
+    fixable: 'code',
+    schema: [],
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+
+    return {
+      'TSTypeReference[typeName.name="FullResponse"]': (typeReference: TSESTree.TSTypeReference) => {
+        try {
+          const typeParentNode = getTypeParentNode(typeReference);
+          assert.ok(typeParentNode);
+          if (typeParentNode.type === TSESTree.AST_NODE_TYPES.TSAsExpression) {
+            context.report({
+              messageId: 'removeFullResponse',
+              node: typeReference,
+              fix(fixer) {
+                return fixer.replaceText(typeParentNode, sourceCode.getText(typeParentNode.expression));
+              },
+            });
+          } else {
+            context.report({
+              messageId: 'removeFullResponse',
+              node: typeReference,
+              fix(fixer) {
+                return fixer.remove(typeParentNode);
+              },
+            });
+          }
+        } catch (error) {
+          // eslint-disable-next-line no-console
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: typeReference,
+            messageId: 'unknownError',
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error),
+            },
+          });
+        }
+      },
+    };
+  },
+});
+
+export default rule;

package/src/fixture/no-service-wrapper.ts

@@ -135,21 +135,19 @@ const rule = createRule({
         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;
           }
 
-          if (!isCalleeServiceWrapper(serviceCall)) {
-            return;
-          }
-
           assert.ok(serviceCall.callee.type === AST_NODE_TYPES.MemberExpression);
           assert.ok(serviceCall.callee.property.type === AST_NODE_TYPES.Identifier);
 

package/src/fixture/ts-tree.ts

@@ -0,0 +1,14 @@
+// fixture/ts-tree.ts
+
+import { AST_NODE_TYPES, TSESTree } from '@typescript-eslint/utils';
+
+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/index.ts

@@ -15,6 +15,7 @@ import fetchResponseHeaderGetterTs, {
 import fetchThen, { ruleId as fetchThenRuleId } from './fixture/fetch-then';
 import invalidJsonStringify, { ruleId as invalidJsonStringifyRuleId } from './invalid-json-stringify';
 import noFixture, { ruleId as noFixtureRuleId } from './fixture/no-fixture';
+import noFullResponse, { ruleId as noFullResponseRuleId } from './fixture/no-full-response';
 import noPromiseInstanceMethod, { ruleId as noPromiseInstanceMethodRuleId } from './no-promise-instance-method';
 import noServiceWrapper, { ruleId as noServiceWrapperRuleId } from './fixture/no-service-wrapper';
 import noStatusCode, { ruleId as noStatusCodeRuleId } from './fixture/no-status-code';
@@ -49,6 +50,7 @@ export default {
     [fetchResponseBodyJsonRuleId]: fetchResponseBodyJson,
     [fetchResponseHeaderGetterTsRuleId]: fetchResponseHeaderGetterTs,
     [addUrlDomainRuleId]: addUrlDomain,
+    [noFullResponseRuleId]: noFullResponse,
   },
   configs: {
     all: {
@@ -72,6 +74,7 @@ export default {
         [`@checkdigit/${fetchResponseBodyJsonRuleId}`]: 'error',
         [`@checkdigit/${fetchResponseHeaderGetterTsRuleId}`]: 'error',
         [`@checkdigit/${addUrlDomainRuleId}`]: 'error',
+        [`@checkdigit/${noFullResponseRuleId}`]: 'error',
       },
     },
     recommended: {