@checkdigit/eslint-plugin 7.5.0 → 7.6.0-PR.75-5da1

package/dist-mjs/agent/fix-function-call-arguments.mjs

@@ -0,0 +1,153 @@
+// src/agent/fix-function-call-arguments.ts
+import { strict as assert } from "node:assert";
+import { ESLintUtils } from "@typescript-eslint/utils";
+import debug from "debug";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+var ruleId = "fix-function-call-arguments";
+var DEFAULT_OPTIONS = {
+  typesToCheck: [
+    "Configuration<ResolvedServices>",
+    "Fixture<ResolvedServices>",
+    "InboundContext",
+    "{ get: () => string; }",
+    "Api"
+  ]
+};
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var log = debug("eslint-plugin:fix-function-call-arguments");
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Remove incompatible function arguments."
+    },
+    messages: {
+      removeIncompatibleFunctionArguments: "Removing incompatible function arguments.",
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: [
+      {
+        type: "object",
+        properties: {
+          typesToCheck: {
+            description: "Text representation of the types of which the function call parameters will be examine",
+            type: "array",
+            items: {
+              type: "string"
+            }
+          }
+        },
+        additionalProperties: false
+      }
+    ]
+  },
+  defaultOptions: [DEFAULT_OPTIONS],
+  create(context) {
+    const { typesToCheck } = context.options[0] ?? DEFAULT_OPTIONS;
+    const parserServices = ESLintUtils.getParserServices(context);
+    const typeChecker = parserServices.program.getTypeChecker();
+    const sourceCode = context.sourceCode;
+    return {
+      CallExpression(callExpression) {
+        log("===== file name:", context.filename);
+        log("callExpression:", sourceCode.getText(callExpression));
+        try {
+          const actualParameters = callExpression.arguments;
+          if (!actualParameters.some((actualParameter) => {
+            const actualType = typeChecker.getTypeAtLocation(
+              parserServices.esTreeNodeToTSNodeMap.get(actualParameter)
+            );
+            const actualTypeString = typeChecker.typeToString(actualType);
+            return typesToCheck.includes(actualTypeString) || actualTypeString.endsWith("RequestType");
+          })) {
+            return;
+          }
+          const calleeTsNode = parserServices.esTreeNodeToTSNodeMap.get(callExpression.callee);
+          const calleeType = typeChecker.getTypeAtLocation(calleeTsNode);
+          const signatures = calleeType.getCallSignatures();
+          if (signatures.length > 1) {
+            return;
+          }
+          const signature = signatures[0];
+          assert(signature);
+          log("signature:", signature.getDeclaration().getText());
+          const expectedParameters = signature.getParameters();
+          log(
+            "expected parameters:",
+            expectedParameters.map(
+              (expectedParameter) => typeChecker.typeToString(typeChecker.getTypeOfSymbol(expectedParameter))
+            )
+          );
+          const expectedParametersCount = expectedParameters.length;
+          const actualParametersCount = actualParameters.length;
+          if (actualParametersCount === 0) {
+            return;
+          }
+          const parametersToKeep = [];
+          let expectedParameterIndex = 0;
+          for (const [actualParameterIndex, actualParameter] of actualParameters.entries()) {
+            if (expectedParameterIndex >= expectedParametersCount) {
+              break;
+            }
+            const expectedParameter = expectedParameters[expectedParameterIndex];
+            assert.ok(expectedParameter, "Expected parameter not found.");
+            const expectedType = typeChecker.getTypeOfSymbol(expectedParameter);
+            const actualType = typeChecker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(actualParameter));
+            const actualTypeString = typeChecker.typeToString(actualType);
+            log(
+              "expected type: #",
+              expectedParameterIndex,
+              expectedParameter.escapedName,
+              typeChecker.typeToString(expectedType)
+            );
+            log("actual type: #", actualParameterIndex, sourceCode.getText(actualParameter), actualTypeString);
+            if ((typesToCheck.includes(actualTypeString) || actualTypeString.endsWith("RequestType")) && !typeChecker.isTypeAssignableTo(actualType, expectedType)) {
+              log("removing un-matched parameter", sourceCode.getText(actualParameter));
+              continue;
+            }
+            parametersToKeep.push(actualParameter);
+            expectedParameterIndex++;
+          }
+          if (parametersToKeep.length === actualParametersCount) {
+            return;
+          }
+          const firstParameter = actualParameters[0];
+          const lastParameter = actualParameters.at(-1);
+          assert.ok(firstParameter !== void 0 && lastParameter !== void 0);
+          const tokenAfterParameters = sourceCode.getTokenAfter(lastParameter);
+          context.report({
+            node: callExpression,
+            messageId: "removeIncompatibleFunctionArguments",
+            fix(fixer) {
+              return fixer.replaceTextRange(
+                [
+                  firstParameter.range[0],
+                  tokenAfterParameters?.value === "," ? tokenAfterParameters.range[1] : lastParameter.range[1]
+                ],
+                parametersToKeep.map((arg) => sourceCode.getText(arg)).join(", ")
+              );
+            }
+          });
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: callExpression,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var fix_function_call_arguments_default = rule;
+export {
+  fix_function_call_arguments_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist-mjs/agent/no-fixture.mjs

@@ -0,0 +1,361 @@
+// src/agent/no-fixture.ts
+import { strict as assert } from "node:assert";
+import "eslint";
+import {
+  getEnclosingFunction,
+  getEnclosingScopeNode,
+  getEnclosingStatement,
+  getParent,
+  isUsedInArrayOrAsArgument
+} from "../library/tree.mjs";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+import { getIndentation } from "../library/format.mjs";
+import { isValidPropertyName } from "../library/variable.mjs";
+import { analyzeResponseReferences } from "./response-reference.mjs";
+import { getResponseBodyRetrievalText, getResponseHeadersRetrievalText, hasAssertions } from "./fetch.mjs";
+import { replaceEndpointUrlPrefixWithBasePath } from "./url.mjs";
+var ruleId = "no-fixture";
+function analyzeFixtureCall(call, results, sourceCode) {
+  const parent = getParent(call);
+  assert.ok(parent, "parent should exist for fixture/supertest call node");
+  let nextCall;
+  if (parent.type === "ReturnStatement") {
+    results.fixtureNode = call;
+    results.rootNode = parent;
+  } else if (parent.type === "ArrayExpression" || parent.type === "CallExpression" || parent.type === "ArrowFunctionExpression") {
+    results.fixtureNode = call;
+    results.rootNode = call;
+  } else if (parent.type === "AwaitExpression") {
+    results.fixtureNode = call;
+    const enclosingStatement = getEnclosingStatement(parent);
+    assert.ok(enclosingStatement);
+    const awaitParent = getParent(parent);
+    if (awaitParent?.type === "MemberExpression") {
+      results.rootNode = parent;
+      results.inlineStatementNode = enclosingStatement;
+      if (awaitParent.property.type === "Identifier" && awaitParent.property.name === "body") {
+        results.inlineBodyReference = awaitParent;
+      }
+      if (awaitParent.property.type === "Identifier" && (awaitParent.property.name === "header" || awaitParent.property.name === "headers")) {
+        results.inlineHeadersReference = awaitParent;
+      }
+    } else if (enclosingStatement.type === "VariableDeclaration") {
+      results.variableDeclaration = enclosingStatement;
+      results.rootNode = enclosingStatement;
+    } else if (enclosingStatement.type === "ExpressionStatement" && enclosingStatement.expression.type === "AssignmentExpression") {
+      results.variableAssignment = enclosingStatement;
+      results.rootNode = enclosingStatement;
+    } else {
+      results.rootNode = parent;
+    }
+  } else if (parent.type === "MemberExpression" && parent.property.type === "Identifier") {
+    if (parent.property.name === "expect") {
+      const assertionCall = getParent(parent);
+      assert.ok(assertionCall && assertionCall.type === "CallExpression");
+      results.assertions = [...results.assertions ?? [], assertionCall.arguments];
+      nextCall = assertionCall;
+    } else if (parent.property.name === "send") {
+      const sendRequestBodyCall = getParent(parent);
+      assert.ok(sendRequestBodyCall && sendRequestBodyCall.type === "CallExpression");
+      results.requestBody = sendRequestBodyCall.arguments[0];
+      nextCall = sendRequestBodyCall;
+    } else if (parent.property.name === "set") {
+      const setRequestHeaderCall = getParent(parent);
+      assert.ok(setRequestHeaderCall && setRequestHeaderCall.type === "CallExpression");
+      const [arg1, arg2] = setRequestHeaderCall.arguments;
+      if (arg1.type === "ObjectExpression") {
+        results.requestHeadersObjectLiteral = arg1;
+      } else {
+        results.requestHeaders = [...results.requestHeaders ?? [], { name: arg1, value: arg2 }];
+      }
+      nextCall = setRequestHeaderCall;
+    }
+  } else {
+    throw new Error(`Unexpected expression in fixture/supertest call ${sourceCode.getText(parent)}.`);
+  }
+  if (nextCall) {
+    analyzeFixtureCall(nextCall, results, sourceCode);
+  }
+}
+function createResponseAssertions(fixtureCallInformation, sourceCode, responseVariableName, destructuringResponseHeadersVariable) {
+  let statusAssertion;
+  const nonStatusAssertions = [];
+  for (const expectArguments of fixtureCallInformation.assertions ?? []) {
+    if (expectArguments.length === 1) {
+      const [assertionArgument] = expectArguments;
+      assert.ok(assertionArgument);
+      if (assertionArgument.type === "MemberExpression" && assertionArgument.object.type === "Identifier" && assertionArgument.object.name === "StatusCodes" || assertionArgument.type === "Literal" || sourceCode.getText(assertionArgument).includes("StatusCodes.")) {
+        statusAssertion = `assert.equal(${responseVariableName}.status, ${sourceCode.getText(assertionArgument)})`;
+      } else if (assertionArgument.type === "ArrowFunctionExpression") {
+        let functionBody = sourceCode.getText(assertionArgument.body);
+        const [originalResponseArgument] = assertionArgument.params;
+        assert.ok(originalResponseArgument?.type === "Identifier");
+        const originalResponseArgumentName = originalResponseArgument.name;
+        if (originalResponseArgumentName !== responseVariableName) {
+          functionBody = functionBody.replace(
+            new RegExp(`\\b${originalResponseArgumentName}\\b`, "ug"),
+            responseVariableName
+          );
+        }
+        nonStatusAssertions.push(`assert.doesNotThrow(()=>${functionBody})`);
+      } else if (assertionArgument.type === "Identifier") {
+        nonStatusAssertions.push(
+          `assert.doesNotThrow(()=>${sourceCode.getText(assertionArgument)}(${responseVariableName}))`
+        );
+      } else if (assertionArgument.type === "ObjectExpression" || assertionArgument.type === "CallExpression") {
+        nonStatusAssertions.push(
+          `assert.deepEqual(await ${responseVariableName}.json(), ${sourceCode.getText(assertionArgument)})`
+        );
+      } else {
+        throw new Error(`Unexpected Supertest assertion argument: ".expect(${sourceCode.getText(assertionArgument)})`);
+      }
+    } else if (expectArguments.length === 2) {
+      const [headerName, headerValue] = expectArguments;
+      assert.ok(headerName && headerValue);
+      const headersReference = destructuringResponseHeadersVariable !== void 0 ? destructuringResponseHeadersVariable.name : `${responseVariableName}.headers`;
+      if (headerValue.type === "Literal" && headerValue.value instanceof RegExp) {
+        nonStatusAssertions.push(
+          `assert.ok(${headersReference}.get(${sourceCode.getText(headerName)}).match(${sourceCode.getText(headerValue)}))`
+        );
+      } else {
+        nonStatusAssertions.push(
+          `assert.equal(${headersReference}.get(${sourceCode.getText(headerName)}), ${sourceCode.getText(headerValue)})`
+        );
+      }
+    }
+  }
+  return {
+    statusAssertion,
+    nonStatusAssertions
+  };
+}
+function getResponseVariableNameToUse(scopeManager, fixtureCallInformation, scopeVariablesMap) {
+  if (fixtureCallInformation.variableAssignment) {
+    assert.ok(
+      fixtureCallInformation.variableAssignment.expression.type === "AssignmentExpression" && fixtureCallInformation.variableAssignment.expression.left.type === "Identifier"
+    );
+    return fixtureCallInformation.variableAssignment.expression.left.name;
+  }
+  if (fixtureCallInformation.variableDeclaration) {
+    const firstDeclaration = fixtureCallInformation.variableDeclaration.declarations[0];
+    if (firstDeclaration && firstDeclaration.id.type === "Identifier") {
+      return firstDeclaration.id.name;
+    }
+  }
+  const enclosingScopeNode = getEnclosingScopeNode(fixtureCallInformation.rootNode);
+  scopeManager.getDeclaredVariables(fixtureCallInformation.rootNode);
+  assert.ok(enclosingScopeNode);
+  const scope = scopeManager.acquire(enclosingScopeNode);
+  assert.ok(scope !== null);
+  let scopeVariables = scopeVariablesMap.get(scope);
+  if (!scopeVariables) {
+    scopeVariables = [...scope.set.keys()];
+    scopeVariablesMap.set(scope, scopeVariables);
+  }
+  let responseVariableCounter = 0;
+  let responseVariableNameToUse;
+  while (responseVariableNameToUse === void 0) {
+    responseVariableCounter++;
+    responseVariableNameToUse = `response${responseVariableCounter === 1 ? "" : responseVariableCounter.toString()}`;
+    if (scopeVariables.includes(responseVariableNameToUse)) {
+      responseVariableNameToUse = void 0;
+    }
+  }
+  scopeVariables.push(responseVariableNameToUse);
+  return responseVariableNameToUse;
+}
+function isResponseBodyRedefinition(responseBodyReference) {
+  const parent = getParent(responseBodyReference);
+  return parent?.type === "VariableDeclarator" && parent.id.type === "Identifier";
+}
+var rule = {
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Prefer native fetch API over customized fixture API.",
+      url: getDocumentationUrl(ruleId)
+    },
+    messages: {
+      preferNativeFetch: "Prefer native fetch API over customized fixture API.",
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: []
+  },
+  // eslint-disable-next-line max-lines-per-function
+  create(context) {
+    const sourceCode = context.sourceCode;
+    const scopeManager = sourceCode.scopeManager;
+    const scopeVariablesMap = /* @__PURE__ */ new Map();
+    return {
+      // eslint-disable-next-line max-lines-per-function
+      'CallExpression[callee.object.object.name="fixture"][callee.object.property.name="api"]': (fixtureCall) => {
+        try {
+          if (hasAssertions(fixtureCall) && (isUsedInArrayOrAsArgument(fixtureCall) || getEnclosingFunction(fixtureCall)?.async === false)) {
+            return;
+          }
+          assert.ok(fixtureCall.type === "CallExpression");
+          const fixtureFunction = fixtureCall.callee;
+          assert.ok(fixtureFunction.type === "MemberExpression");
+          const indentation = getIndentation(fixtureCall, sourceCode);
+          const [urlArgumentNode] = fixtureCall.arguments;
+          assert.ok(urlArgumentNode !== void 0);
+          const fixtureCallInformation = {};
+          analyzeFixtureCall(fixtureCall, fixtureCallInformation, sourceCode);
+          const {
+            variable: responseVariable,
+            bodyReferences: responseBodyReferences,
+            headersReferences: responseHeadersReferences,
+            statusReferences: responseStatusReferences,
+            destructuringBodyVariable: destructuringResponseBodyVariable,
+            destructuringHeadersVariable: destructuringResponseHeadersVariable
+          } = analyzeResponseReferences(fixtureCallInformation.variableDeclaration, scopeManager);
+          const originalUrlArgumentText = sourceCode.getText(urlArgumentNode);
+          const fetchUrlArgumentText = replaceEndpointUrlPrefixWithBasePath(originalUrlArgumentText);
+          const methodNode = fixtureFunction.property;
+          assert.ok(methodNode.type === "Identifier");
+          const methodName = methodNode.name.toUpperCase();
+          const fetchRequestArgumentLines = [
+            "{",
+            `  method: '${methodName === "DEL" ? "DELETE" : methodName}',`,
+            ...fixtureCallInformation.requestBody ? [`  body: JSON.stringify(${sourceCode.getText(fixtureCallInformation.requestBody)}),`] : [],
+            // eslint-disable-next-line no-nested-ternary
+            ...fixtureCallInformation.requestHeadersObjectLiteral ? [`  headers: ${sourceCode.getText(fixtureCallInformation.requestHeadersObjectLiteral)},`] : fixtureCallInformation.requestHeaders ? [
+              `  headers: {`,
+              ...fixtureCallInformation.requestHeaders.map(
+                ({ name, value }) => (
+                  // eslint-disable-next-line @typescript-eslint/restrict-template-expressions, no-nested-ternary, sonarjs/no-nested-template-literals
+                  `    ${name.type === "Literal" ? isValidPropertyName(name.value) ? name.value : `'${name.value}'` : `[${sourceCode.getText(name)}]`}: ${sourceCode.getText(value)},`
+                )
+              ),
+              `  },`
+            ] : [],
+            "}"
+          ].join(`
+${indentation}`);
+          const responseVariableNameToUse = getResponseVariableNameToUse(
+            scopeManager,
+            fixtureCallInformation,
+            scopeVariablesMap
+          );
+          const isResponseBodyVariableRedefinitionNeeded = destructuringResponseBodyVariable !== void 0 || fixtureCallInformation.inlineBodyReference !== void 0 || responseBodyReferences.length > 0 && !responseBodyReferences.some(isResponseBodyRedefinition);
+          const redefineResponseBodyVariableName = `${responseVariableNameToUse}Body`;
+          const isResponseHeadersVariableRedefinitionNeeded = destructuringResponseHeadersVariable !== void 0 && // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+          destructuringResponseHeadersVariable.type === "ObjectPattern" || fixtureCallInformation.inlineHeadersReference !== void 0;
+          const redefineResponseHeadersVariableName = `${responseVariableNameToUse}Headers`;
+          const isResponseVariableRedefinitionNeeded = fixtureCallInformation.variableAssignment === void 0 && responseVariable === void 0 && fixtureCallInformation.assertions !== void 0 || isResponseBodyVariableRedefinitionNeeded || isResponseHeadersVariableRedefinitionNeeded;
+          const responseBodyHeadersVariableRedefineLines = isResponseVariableRedefinitionNeeded ? [
+            // eslint-disable-next-line no-nested-ternary
+            ...destructuringResponseBodyVariable ? [
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${destructuringResponseBodyVariable.type === "ObjectPattern" ? sourceCode.getText(destructuringResponseBodyVariable) : destructuringResponseBodyVariable.name} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`
+            ] : isResponseBodyVariableRedefinitionNeeded ? [
+              `const ${redefineResponseBodyVariableName} = ${getResponseBodyRetrievalText(responseVariableNameToUse)}`
+            ] : [],
+            // eslint-disable-next-line no-nested-ternary
+            ...destructuringResponseHeadersVariable ? (
+              // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+              destructuringResponseHeadersVariable.type === "ObjectPattern" ? destructuringResponseHeadersVariable.properties.map((property) => {
+                assert.ok(property.type === "Property");
+                assert.equal(property.value.type, "Identifier");
+                return `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${property.value.name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}.get(${property.key.type === "Literal" ? sourceCode.getText(property.key) : `'${sourceCode.getText(property.key)}'`})`;
+              }) : [
+                `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${destructuringResponseHeadersVariable.name} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}`
+              ]
+            ) : isResponseHeadersVariableRedefinitionNeeded ? [
+              `const ${redefineResponseHeadersVariableName} = ${getResponseHeadersRetrievalText(responseVariableNameToUse)}`
+            ] : []
+          ] : [];
+          const { statusAssertion, nonStatusAssertions } = createResponseAssertions(
+            fixtureCallInformation,
+            sourceCode,
+            responseVariableNameToUse,
+            destructuringResponseHeadersVariable
+          );
+          const fetchCallText = `fetch(${fetchUrlArgumentText}, ${fetchRequestArgumentLines})`;
+          const fetchStatementText = !isResponseVariableRedefinitionNeeded ? fetchCallText : `${fixtureCallInformation.variableDeclaration?.kind ?? "const"} ${responseVariableNameToUse} = await ${fetchCallText}`;
+          const nodeToReplace = isResponseVariableRedefinitionNeeded ? fixtureCallInformation.rootNode : fixtureCallInformation.fixtureNode;
+          const appendingAssignmentAndAssertionText = [
+            "",
+            ...statusAssertion !== void 0 ? [statusAssertion] : [],
+            ...responseBodyHeadersVariableRedefineLines,
+            ...nonStatusAssertions
+          ].join(`;
+${indentation}`);
+          context.report({
+            node: fixtureCall,
+            messageId: "preferNativeFetch",
+            *fix(fixer) {
+              if (fixtureCallInformation.inlineStatementNode) {
+                const preInlineDeclaration = [
+                  fetchStatementText,
+                  `${appendingAssignmentAndAssertionText};
+${indentation}`
+                ].join(``);
+                yield fixer.insertTextBefore(fixtureCallInformation.inlineStatementNode, preInlineDeclaration);
+              } else {
+                yield fixer.replaceText(nodeToReplace, fetchStatementText);
+                const needEndingSemiColon = sourceCode.getText(nodeToReplace).endsWith(";");
+                yield fixer.insertTextAfter(
+                  nodeToReplace,
+                  needEndingSemiColon ? `${appendingAssignmentAndAssertionText};` : appendingAssignmentAndAssertionText
+                );
+              }
+              for (const responseBodyReference of responseBodyReferences) {
+                yield fixer.replaceText(
+                  responseBodyReference,
+                  isResponseBodyVariableRedefinitionNeeded || !isResponseBodyRedefinition(responseBodyReference) ? redefineResponseBodyVariableName : getResponseBodyRetrievalText(responseVariableNameToUse)
+                );
+              }
+              if (fixtureCallInformation.inlineBodyReference) {
+                yield fixer.replaceText(fixtureCallInformation.inlineBodyReference, redefineResponseBodyVariableName);
+              }
+              for (const responseHeadersReference of responseHeadersReferences) {
+                const parent = getParent(responseHeadersReference);
+                assert.ok(parent);
+                let headerName;
+                if (parent.type === "MemberExpression") {
+                  const headerNameNode = parent.property;
+                  headerName = parent.computed ? sourceCode.getText(headerNameNode) : `'${sourceCode.getText(headerNameNode)}'`;
+                } else if (parent.type === "CallExpression") {
+                  const headerNameNode = parent.arguments[0];
+                  headerName = sourceCode.getText(headerNameNode);
+                }
+                assert.ok(headerName !== void 0);
+                yield fixer.replaceText(parent, `${responseVariableNameToUse}.headers.get(${headerName})`);
+              }
+              for (const responseStatusReference of responseStatusReferences) {
+                if (responseStatusReference.property.type === "Identifier" && responseStatusReference.property.name === "statusCode") {
+                  yield fixer.replaceText(responseStatusReference.property, `status`);
+                }
+              }
+              if (fixtureCallInformation.rootNode.type === "ReturnStatement" && fixtureCallInformation.assertions !== void 0) {
+                yield fixer.insertTextAfter(
+                  fixtureCallInformation.rootNode,
+                  `
+${indentation}return ${responseVariableNameToUse};`
+                );
+              }
+            }
+          });
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: fixtureCall,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      }
+    };
+  }
+};
+var no_fixture_default = rule;
+export {
+  no_fixture_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../src/agent/no-fixture.ts"],
  "mappings": "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",
  "names": []
}


package/dist-mjs/agent/no-mapped-response.mjs

@@ -0,0 +1,75 @@
+// src/agent/no-mapped-response.ts
+import { ESLintUtils } from "@typescript-eslint/utils";
+import getDocumentationUrl from "../get-documentation-url.mjs";
+var ruleId = "no-mapped-response";
+var createRule = ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
+var rule = createRule({
+  name: ruleId,
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Replace the usage of MappedResponse type with FetchResponse."
+    },
+    messages: {
+      replaceFullResponseWithFetchResponse: "Replace the usage of FullResponse type with FetchResponse.",
+      unknownError: 'Unknown error occurred in file "{{fileName}}": {{ error }}.'
+    },
+    fixable: "code",
+    schema: []
+  },
+  defaultOptions: [],
+  create(context) {
+    const sourceCode = context.sourceCode;
+    return {
+      'TSTypeReference[typeName.name="MappedResponse"]': (typeReference) => {
+        try {
+          context.report({
+            messageId: "replaceFullResponseWithFetchResponse",
+            node: typeReference,
+            fix(fixer) {
+              const typeParams = sourceCode.getText(typeReference.typeArguments);
+              return fixer.replaceText(typeReference, `FetchResponse${typeParams || ""}`);
+            }
+          });
+        } catch (error) {
+          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)
+            }
+          });
+        }
+      },
+      'ImportSpecifier[imported.name="MappedResponse"]': (importSpecifier) => {
+        try {
+          context.report({
+            messageId: "replaceFullResponseWithFetchResponse",
+            node: importSpecifier.imported,
+            fix(fixer) {
+              return fixer.replaceText(importSpecifier.imported, "FetchResponse");
+            }
+          });
+        } catch (error) {
+          console.error(`Failed to apply ${ruleId} rule for file "${context.filename}":`, error);
+          context.report({
+            node: importSpecifier.imported,
+            messageId: "unknownError",
+            data: {
+              fileName: context.filename,
+              error: error instanceof Error ? error.toString() : JSON.stringify(error)
+            }
+          });
+        }
+      }
+    };
+  }
+});
+var no_mapped_response_default = rule;
+export {
+  no_mapped_response_default as default,
+  ruleId
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vc3JjL2FnZW50L25vLW1hcHBlZC1yZXNwb25zZS50cyJdLAogICJtYXBwaW5ncyI6ICI7QUFRQSxTQUFTLG1CQUE2QjtBQUN0QyxPQUFPLHlCQUF5QjtBQUV6QixJQUFNLFNBQVM7QUFFdEIsSUFBTSxhQUFhLFlBQVksWUFBWSxDQUFDLFNBQVMsb0JBQW9CLElBQUksQ0FBQztBQUU5RSxJQUFNLE9BQXdGLFdBQVc7QUFBQSxFQUN2RyxNQUFNO0FBQUEsRUFDTixNQUFNO0FBQUEsSUFDSixNQUFNO0FBQUEsSUFDTixNQUFNO0FBQUEsTUFDSixhQUFhO0FBQUEsSUFDZjtBQUFBLElBQ0EsVUFBVTtBQUFBLE1BQ1Isc0NBQXNDO0FBQUEsTUFDdEMsY0FBYztBQUFBLElBQ2hCO0FBQUEsSUFDQSxTQUFTO0FBQUEsSUFDVCxRQUFRLENBQUM7QUFBQSxFQUNYO0FBQUEsRUFDQSxnQkFBZ0IsQ0FBQztBQUFBLEVBQ2pCLE9BQU8sU0FBUztBQUNkLFVBQU0sYUFBYSxRQUFRO0FBRTNCLFdBQU87QUFBQSxNQUNMLG1EQUFtRCxDQUFDLGtCQUE0QztBQUM5RixZQUFJO0FBQ0Ysa0JBQVEsT0FBTztBQUFBLFlBQ2IsV0FBVztBQUFBLFlBQ1gsTUFBTTtBQUFBLFlBQ04sSUFBSSxPQUFPO0FBQ1Qsb0JBQU0sYUFBYSxXQUFXLFFBQVEsY0FBYyxhQUFhO0FBQ2pFLHFCQUFPLE1BQU0sWUFBWSxlQUFlLGdCQUFnQixjQUFjLEVBQUUsRUFBRTtBQUFBLFlBQzVFO0FBQUEsVUFDRixDQUFDO0FBQUEsUUFDSCxTQUFTLE9BQU87QUFFZCxrQkFBUSxNQUFNLG1CQUFtQixNQUFNLG1CQUFtQixRQUFRLFFBQVEsTUFBTSxLQUFLO0FBQ3JGLGtCQUFRLE9BQU87QUFBQSxZQUNiLE1BQU07QUFBQSxZQUNOLFdBQVc7QUFBQSxZQUNYLE1BQU07QUFBQSxjQUNKLFVBQVUsUUFBUTtBQUFBLGNBQ2xCLE9BQU8saUJBQWlCLFFBQVEsTUFBTSxTQUFTLElBQUksS0FBSyxVQUFVLEtBQUs7QUFBQSxZQUN6RTtBQUFBLFVBQ0YsQ0FBQztBQUFBLFFBQ0g7QUFBQSxNQUNGO0FBQUEsTUFDQSxtREFBbUQsQ0FBQyxvQkFBOEM7QUFDaEcsWUFBSTtBQUNGLGtCQUFRLE9BQU87QUFBQSxZQUNiLFdBQVc7QUFBQSxZQUNYLE1BQU0sZ0JBQWdCO0FBQUEsWUFDdEIsSUFBSSxPQUFPO0FBQ1QscUJBQU8sTUFBTSxZQUFZLGdCQUFnQixVQUFVLGVBQWU7QUFBQSxZQUNwRTtBQUFBLFVBQ0YsQ0FBQztBQUFBLFFBQ0gsU0FBUyxPQUFPO0FBRWQsa0JBQVEsTUFBTSxtQkFBbUIsTUFBTSxtQkFBbUIsUUFBUSxRQUFRLE1BQU0sS0FBSztBQUNyRixrQkFBUSxPQUFPO0FBQUEsWUFDYixNQUFNLGdCQUFnQjtBQUFBLFlBQ3RCLFdBQVc7QUFBQSxZQUNYLE1BQU07QUFBQSxjQUNKLFVBQVUsUUFBUTtBQUFBLGNBQ2xCLE9BQU8saUJBQWlCLFFBQVEsTUFBTSxTQUFTLElBQUksS0FBSyxVQUFVLEtBQUs7QUFBQSxZQUN6RTtBQUFBLFVBQ0YsQ0FBQztBQUFBLFFBQ0g7QUFBQSxNQUNGO0FBQUEsSUFDRjtBQUFBLEVBQ0Y7QUFDRixDQUFDO0FBRUQsSUFBTyw2QkFBUTsiLAogICJuYW1lcyI6IFtdCn0K