private async visitParameterDefinition()

in packages/libs/oai2-to-oai3/src/converter.ts [321:440]
103 lines of code
31 McCabe index (conditional complexity)

  private async visitParameterDefinition(
    parameterTarget: MappingTreeObject<oai3.Parameter>,
    parameterValue: any,
    sourcePointer: string,
    parameterItemMembers: () => Iterable<Node>,
  ) {
    const parameterUnchangedProperties = ["name", "in", "description", "allowEmptyValue", "required"];

    for (const key of parameterUnchangedProperties) {
      if (parameterValue[key] !== undefined) {
        parameterTarget.__set__(key as any, { value: parameterValue[key], sourcePointer });
      }
    }

    if (parameterValue["x-ms-skip-url-encoding"] !== undefined) {
      if (parameterValue.in === "query") {
        parameterTarget.__set__("allowReserved", { value: true, sourcePointer });
      } else {
        parameterTarget.__set__("x-ms-skip-url-encoding", {
          value: parameterValue["x-ms-skip-url-encoding"],
          sourcePointer,
        });
      }
    }

    /**
     * List of extension properties that shouldn't just be passed through.
     */
    const extensionPropertiesCustom = new Set(["x-ms-skip-url-encoding", "x-ms-original", "x-ms-enum"]);

    for (const key of includeXDashKeys(parameterValue)) {
      if (parameterValue[key] !== undefined && !extensionPropertiesCustom.has(key)) {
        parameterTarget.__set__(key, { value: parameterValue[key], sourcePointer });
      }
    }

    // Collection Format
    if (parameterValue.type === "array") {
      parameterValue.collectionFormat = parameterValue.collectionFormat || "csv";
      if (
        parameterValue.collectionFormat === "csv" &&
        (parameterValue.in === "query" || parameterValue.in === "cookie")
      ) {
        parameterTarget.__set__("style", { value: EncodingStyle.Form, sourcePointer });
      }
      if (
        parameterValue.collectionFormat === "csv" &&
        (parameterValue.in === "path" || parameterValue.in === "header")
      ) {
        parameterTarget.__set__("style", { value: EncodingStyle.Simple, sourcePointer });
      }
      if (parameterValue.collectionFormat === "ssv") {
        if (parameterValue.in === "query") {
          parameterTarget.__set__("style", { value: EncodingStyle.SpaceDelimited, sourcePointer });
        }
      }
      if (parameterValue.collectionFormat === "pipes") {
        if (parameterValue.in === "query") {
          parameterTarget.__set__("style", { value: EncodingStyle.PipeDelimited, sourcePointer });
        }
      }
      if (parameterValue.collectionFormat === "multi") {
        parameterTarget.__set__("style", { value: EncodingStyle.Form, sourcePointer });
        parameterTarget.__set__("explode", { value: true, sourcePointer });
      }

      // tsv is no longer supported in OAI3, but we still need to support this.
      if (parameterValue.collectionFormat === "tsv") {
        parameterTarget.__set__("style", { value: EncodingStyle.TabDelimited, sourcePointer });
      }
    }

    if (parameterTarget.schema === undefined) {
      parameterTarget.__set__("schema", this.newObject(sourcePointer));
    }

    const schema: MappingTreeObject<oai3.Schema> = parameterTarget.schema as any;

    const schemaKeys = [
      "maximum",
      "exclusiveMaximum",
      "minimum",
      "exclusiveMinimum",
      "maxLength",
      "minLength",
      "pattern",
      "maxItems",
      "minItems",
      "uniqueItems",
      "enum",
      "x-ms-enum",
      "multipleOf",
      "default",
      "format",
    ];

    for (const { key, childIterator, pointer: jsonPointer } of parameterItemMembers()) {
      if (key === "schema") {
        if (schema.items === undefined) {
          schema.__set__("items", this.newObject(jsonPointer));
        }
        await this.visitSchema(schema.items as any, parameterValue.items, childIterator);
      } else if (schemaKeys.indexOf(key) !== -1) {
        schema.__set__(key as any, { value: parameterValue[key], sourcePointer });
      }
    }

    if (parameterValue.type !== undefined) {
      schema.__set__("type", { value: parameterValue.type, sourcePointer });
    }

    if (parameterValue.items !== undefined) {
      schema?.__set__("items", this.newObject(sourcePointer));
      for (const { key, childIterator } of parameterItemMembers()) {
        if (key === "items") {
          await this.visitSchema(schema.items as any, parameterValue.items, childIterator);
        }
      }
    }
  }