function extractHttpResponses()

in src/typespec-aaz/src/convertor.ts [426:533]

• 100 lines of code
• 28 McCabe index (conditional complexity)

function extractHttpResponses(
  context: AAZOperationEmitterContext,
  operation: HttpOperation,
  lroMetadata: LroMetadata | undefined,
): CMDHttpResponse[] | undefined {
  let success202Response: CMDHttpResponse | undefined; // only one success 202 response is allowed
  let success204Response: CMDHttpResponse | undefined; // only one success 204 response is allowed
  let success2xxResponse: CMDHttpResponse | undefined; // only one success 2xx(except 202 and 204) response is allowed
  let redirectResponse: CMDHttpResponse | undefined;
  const errorResponses = [];

  for (const response of operation.responses) {
    let statusCodes = getOpenAPI2StatusCodes(context, response.statusCodes, response.type);
    if (statusCodes.length === 0) {
      reportDiagnostic(context.program, {
        code: "missing-status-codes",
        target: response.type,
      });
    }
    if (statusCodes.includes("default")) {
      errorResponses.push(convert2CMDHttpResponse(context, response, undefined, true));
      continue;
    }
    const isSuccess = statusCodes.map((code) => code.startsWith("2")).includes(true);
    const isRedirect = statusCodes.map((code) => code.startsWith("3")).includes(true);
    const isError = !isSuccess && !isRedirect;
    if (isSuccess) {
      if (statusCodes.includes("202")) {
        if (success202Response !== undefined) {
          reportDiagnostic(context.program, {
            code: "Duplicated-success-202",
            target: response.type,
          });
        }
        success202Response = convert2CMDHttpResponse(context, response, ["202"], false);
      }
      if (statusCodes.includes("204")) {
        if (success204Response !== undefined) {
          reportDiagnostic(context.program, {
            code: "Duplicated-success-204",
            target: response.type,
          });
        }
        success204Response = convert2CMDHttpResponse(context, response, ["204"], false);
      }
      // remove 202 and 204 from statusCodes
      statusCodes = statusCodes.filter((code) => code !== "202" && code !== "204");
      if (statusCodes.length > 0) {
        if (success2xxResponse !== undefined) {
          success2xxResponse.statusCode = [
            ...success2xxResponse.statusCode!,
            ...statusCodes.map((code) => Number(code)),
          ];
          context.tracer.trace("AppendSuccess2xxStatusCodes", JSON.stringify(success2xxResponse.statusCode));
        } else {
          success2xxResponse = convert2CMDHttpResponse(context, response, statusCodes, false);
        }
      }
    } else if (isRedirect) {
      if (redirectResponse !== undefined) {
        reportDiagnostic(context.program, {
          code: "Duplicated-redirect",
          target: response.type,
        });
      }
      redirectResponse = convert2CMDHttpResponse(context, response, statusCodes, false);
    } else if (isError) {
      errorResponses.push(convert2CMDHttpResponse(context, response, statusCodes, true));
    }
  }

  const responses = [];
  if (success2xxResponse !== undefined) {
    responses.push(success2xxResponse);
  }
  if (success202Response !== undefined) {
    responses.push(success202Response);
  }
  if (success204Response !== undefined) {
    responses.push(success204Response);
  }

  const success_status_code: number[] = [
    ...(success2xxResponse?.statusCode || []),
    ...(success202Response?.statusCode || []),
    ...(success204Response?.statusCode || []),
  ];
  const lro_base_status_code = success_status_code.filter((code) => [200, 201].includes(code));
  if (lro_base_status_code.length === 0 && lroMetadata !== undefined && operation.verb === "delete") {
    const lro_response: CMDHttpResponse = {
      statusCode: [200, 201],
      isError: false,
      description: "Response schema for long-running operation.",
    };
    responses.push(lro_response);
  }

  if (redirectResponse !== undefined) {
    responses.push(redirectResponse);
  }
  responses.push(...errorResponses);

  if (lroMetadata !== undefined && lroMetadata.logicalResult) {
    // TODO: add logicalResult in responses
  }

  return responses;
}