export async function validateTraffic()

in lib/validate.ts [187:303]
117 lines of code
12 McCabe index (conditional complexity)

export async function validateTraffic(
  specPath: string,
  trafficPath: string,
  options: TrafficValidationOptions
): Promise<TrafficValidationIssue[]> {
  return validate(options, async (o) => {
    o.consoleLogLevel = log.consoleLogLevel;
    o.logFilepath = log.filepath;
    const validator = new TrafficValidator(specPath, trafficPath);
    const trafficValidationResult: TrafficValidationIssue[] = [];
    try {
      await validator.initialize();
      const result = await validator.validate();
      trafficValidationResult.push(...result);
    } catch (err) {
      const msg = `Detail error message:${(err as any)?.message}. ErrorStack:${
        (err as any)?.Stack
      }`;
      log.error(msg);
      trafficValidationResult.push({
        payloadFilePath: specPath,
        runtimeExceptions: [
          {
            code: ErrorCodeConstants.RUNTIME_ERROR,
            message: msg,
          },
        ],
      });
    }
    if (options.jsonReportPath) {
      const errorDefinitions = await loadErrorDefinitions();
      const report = {
        coveredSpecFiles: validator.operationCoverageResult.map((item) =>
          options.overrideLinkInReport
            ? `${options.specLinkPrefix}/${item.spec?.substring(
                item.spec?.indexOf("specification")
              )}`
            : `${item.spec}`
        ),
        allOperations: validator.operationCoverageResult
          .map((item) => item.totalOperations)
          .reduce((a, b) => a + b, 0),
        coveredOperations: validator.operationCoverageResult
          .map((item) => item.coveredOperations)
          .reduce((a, b) => a + b, 0),
        unCoveredOperationsList: validator.operationCoverageResult.map((item) => {
          return {
            spec: item.spec,
            operationIds: item.unCoveredOperationsList.map((opeartion) => opeartion.operationId),
          };
        }),
        passedOperationsList: validator.operationCoverageResult.map((item) => {
          return {
            spec: item.spec,
            operationIds: item.coveredOperationsList
              .map((opeartion) => opeartion.operationId)
              .filter((id) => {
                return !trafficValidationResult.some(
                  (error) => error.operationInfo?.operationId === id
                );
              }),
          };
        }),
        failedOperations: validator.operationCoverageResult
          .map((item) => item.validationFailOperations)
          .reduce((a, b) => a + b, 0),
        errors: Array.from(
          flatMap(
            trafficValidationResult,
            (item) =>
              item.errors?.map((it) => {
                const errorDef = errorDefinitions.get(it.code);
                const specFilePath = item.specFilePath || "";
                const overrideLinkInReport = options.overrideLinkInReport || false;
                const specLinkPrefix = options.specLinkPrefix || "";
                return {
                  spec: specFilePath,
                  errorCode: it.code,
                  errorLink: errorDef?.link,
                  errorMessage: it.message,
                  issueSource: it.issueSource,
                  operationId: item.operationInfo?.operationId,
                  schemaPathWithPosition: overrideLinkInReport
                    ? `${specLinkPrefix}/${specFilePath.substring(
                        specFilePath.indexOf("specification")
                      )}#L${it.source.position.line}`
                    : `${specFilePath}#L${it.source.position.line}`,
                };
              }) ?? []
          )
        ),
      };
      fs.writeFileSync(options.jsonReportPath, JSON.stringify(report, null, 2));
    }
    if (options.reportPath) {
      const generator = new ReportGenerator(
        trafficValidationResult,
        validator.operationCoverageResult,
        validator.operationUndefinedResult,
        options
      );
      await generator.generateHtmlReport();
    } else if (trafficValidationResult.length > 0) {
      if (o.pretty) {
        prettyPrintInfo(trafficValidationResult, "error");
      } else {
        for (const error of trafficValidationResult) {
          const errorInfo = JSON.stringify(error);
          log.error(errorInfo);
        }
      }
    } else {
      log.info("No errors were found.");
    }
    return trafficValidationResult;
  });
}