private ExpandAllOf()

in src/lib/util/resolveSwagger.ts [230:283]
52 lines of code
14 McCabe index (conditional complexity)

  private ExpandAllOf(schema: any) {
    if (!schema || !schema.allOf) {
      return
    }
    this.checkCircularAllOf(schema, undefined, [])
    const schemaList = schema.properties ? schema.properties : {}
    for (const reference of sm.values(schema.allOf)) {
      let allOfSchema = reference as any
      if (allOfSchema.$ref) {
        allOfSchema = this.dereference(allOfSchema.$ref)
        if (!allOfSchema) {
          throw new Error("Invalid reference:" + allOfSchema.$ref)
        }
      }
      if (allOfSchema.allOf) {
        this.ExpandAllOf(allOfSchema)
      }
      if (allOfSchema.properties) {
        sm.keys(allOfSchema.properties).forEach(key => {
          if (sm.keys(schemaList).some(k => k === key)) {
            if (!this.isEqual(allOfSchema.properties[key], schemaList[key])) {
              const allOfProp = allOfSchema.properties[key]
              const allOfPath = getPath(getInfo(allOfProp) as ObjectInfo)
              const allOfOriginalPosition = this.map.originalPositionFor(getFilePosition(allOfProp) as FilePosition)

              const schemaListProp = schemaList[key]
              const schemaListPath = getPath(getInfo(schemaListProp) as ObjectInfo)
              const schemaListOriginalPosition = this.map.originalPositionFor(getFilePosition(schemaListProp) as FilePosition)

              throw new Error(
                `incompatible properties : ${key}\n` +
                  `  ${schemaListPath.join("/")}\n` +
                  `    at ${schemaListOriginalPosition.source}#L${schemaListOriginalPosition.line}:${schemaListOriginalPosition.column}\n` +
                  `  ${allOfPath.join("/")}\n` +
                  `    at ${allOfOriginalPosition.source}#L${allOfOriginalPosition.line}:${allOfOriginalPosition.column}`
              )
            }
          } else {
            schemaList[key] = allOfSchema.properties[key]
          }
        })
      }
      if (allOfSchema.required) {
        const requiredProperties = schema.required ? schema.required : []
        sm.values(allOfSchema.required).forEach(prop => {
          if (!sm.values(requiredProperties).some(v => v === prop)) {
            requiredProperties.push(prop)
          }
        })
        schema.required = requiredProperties
      }
    }
    schema.properties = schemaList
  }