[BUG] [Swift5] support for oneOf, anyOf, allOf, and discriminator directives

[lightman73]

Bug Report Checklist

• Have you provided a full/minimal spec to reproduce the issue?
• Have you tested with the latest master to confirm the issue still exists?
• Have you searched for related issues/PRs?
• What's the actual output vs expected output?
  The generated code should support the oneOf, anyOf, allOf directives

Description

If one has a response type defined as :

responses:
    '200':
        content:
            application/json:
                schema:
                    oneOf:
                        - $ref: '#/schemas/someObject1'
                        - $ref: '#/schemas/someObject2'

the generated Swift client has this requestBuilder definition:

let requestBuilder: RequestBuilder<OneOfsomeObject1someObject2>.Type = YourAPI.requestBuilderFactory.getBuilder()

but there is no trace of the OneOfsomeObject1someObject2 type definition in the generated code, thus making it not working.

Is there any way to get a working client for an openApi definition that uses oneOf (or anyOf, allOf) ?

openapi-generator version

5.0.0-SNAPSHOT, compiled from git.

Generation Details

openapi-generator generate -I defs.yaml -g swift5 ./output_dir

Related issues/PRs

#2588 (comment) (really old one, possibly relating to the old Swift 4 generator, gives a little suggestion, but not much)

@jgavris @ehyche @Edubits @jaz-ah @4brunu could one you look into the issue and see if there is any way to solve it ? Even a simple idea to point me in the right direction to implement the missing feature would be great...

[wing328]

@lightman73 thanks for reporting the issue. You're correct in saying that oneOf, anyOf is not supported in the swift5 generator at the moment.

If you've time to contribute a PR to add oneOf/anyOf support, I can point you in the right direction to add oneOf support to the swift5 client generator.

[lightman73]

If you've time to contribute a PR to add oneOf/anyOf support, I can point you in the right direction to add oneOf support to the swift5 client generator.

I might. Considering that the alternative would be to convince my colleagues to change the API endpoints and work around the problem, it could be easier for me to add the support to the generator. Besides, that could help others. ☺️

I'm not gonna promise you anything, though. 😅

Any hint on where to look into the code, and how it could be implemented would be great 😊

I think, but I could be wrong, that a possible solution could be to implement the OneOfsomeObject1someObject2 type as a protocol, and let someObject1 and someObject2 inherit from that... This could probably work for the oneOf in the example I gave.

Now, implementing allOf in a schema definition could be a bit trickier... What do you think ?

[lightman73]

Another possibility could be to define OneOfsomeObject1someObject2 as:

struct OneOfsomeObject1someObject2 {
    var someObject1: SomeObject1?
    var someObject2: SomeObject2?
}

and on the call return try and parse the json as SomeObject1 and SomeObject2, and put the successful one in the OneOfsomeObject1someObject2 struct, leaving the other nil.

[allezxandre]

Hello, any news on the implementation of this feature?

If not, I might take a try at it myself, so I would be interested to read ideas that were being explored, if any

[4brunu]

Not that I'm aware of

[adarhef]

Hello!
I wanted to use discriminator and mapping to utilize this feature with the oneOf directive.
Since I was already using custom templates I edited the relevant mustache file (modelOneOf.mustache). Couldn't spend too much time on it but it got things working for me:

public enum {{classname}}: {{#useVapor}}Content{{/useVapor}}{{^useVapor}}Codable, JSONEncodable{{#vendorExtensions.x-swift-hashable}}, Hashable{{/vendorExtensions.x-swift-hashable}}{{/useVapor}} {
    {{#oneOf}}
    case type{{.}}({{.}})
    {{/oneOf}}

    public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        {{#oneOf}}
        case .type{{.}}(let value):
            try container.encode(value)
        {{/oneOf}}
        }
    }

    {{#discriminator}}
    enum CodingKeys: String, CodingKey {
        case {{discriminator.propertyName}}
    }
    {{/discriminator}}

    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        {{#discriminator}}
        let keyedContainer = try decoder.container(keyedBy: CodingKeys.self)
        let discriminator = try keyedContainer.decode(String.self, forKey: .{{discriminator.propertyName}})
        switch discriminator {
        {{#discriminator.mappedModels}}
        case "{{mappingName}}":
            let value = try container.decode({{modelName}}.self)
            self = .type{{modelName}}(value)
        {{/discriminator.mappedModels}}
        default:
            throw DecodingError.typeMismatch(Self.Type.self, .init(codingPath: decoder.codingPath, debugDescription: "Unable to decode instance of {{classname}}"))
        }
        {{/discriminator}}
        {{^discriminator}}
        {{#oneOf}}
        {{#-first}}
        if let value = try? container.decode({{.}}.self) {
        {{/-first}}
        {{^-first}}
        } else if let value = try? container.decode({{.}}.self) {
        {{/-first}}
            self = .type{{.}}(value)
        {{/oneOf}}
        } else {
            throw DecodingError.typeMismatch(Self.Type.self, .init(codingPath: decoder.codingPath, debugDescription: "Unable to decode instance of {{classname}}"))
        }
        {{/discriminator}}
    }
}

This results in a Codable enum that represent all of the options discriminated by the discriminator property.

For my use case the code ends up looking like this:

//
// DiscriminatedSearchMatchResult.swift
//
// Generated by openapi-generator
// https://openapi-generator.tech
//

import Foundation
#if canImport(AnyCodable)
import AnyCodable
#endif

public enum DiscriminatedSearchMatchResult: Codable, JSONEncodable, Hashable {
    case typeAggravatingFactorResult(AggravatingFactorResult)
    case typeConditionResult(ConditionResult)
    case typeEntityTypeResult(EntityTypeResult)
    case typeSubstanceGroupResult(SubstanceGroupResult)
    case typeSymptomResult(SymptomResult)
    case typeTreatmentResult(TreatmentResult)

    public func encode(to encoder: Encoder) throws {
        var container = encoder.singleValueContainer()
        switch self {
        case .typeAggravatingFactorResult(let value):
            try container.encode(value)
        case .typeConditionResult(let value):
            try container.encode(value)
        case .typeEntityTypeResult(let value):
            try container.encode(value)
        case .typeSubstanceGroupResult(let value):
            try container.encode(value)
        case .typeSymptomResult(let value):
            try container.encode(value)
        case .typeTreatmentResult(let value):
            try container.encode(value)
        }
    }

    enum CodingKeys: String, CodingKey {
        case matchType
    }

    public init(from decoder: Decoder) throws {
        let container = try decoder.singleValueContainer()
        let keyedContainer = try decoder.container(keyedBy: CodingKeys.self)
        let discriminator = try keyedContainer.decode(String.self, forKey: .matchType)
        switch discriminator {
        case "Aggravating Factor":
            let value = try container.decode(AggravatingFactorResult.self)
            self = .typeAggravatingFactorResult(value)
        case "Condition":
            let value = try container.decode(ConditionResult.self)
            self = .typeConditionResult(value)
        case "Entity Type":
            let value = try container.decode(EntityTypeResult.self)
            self = .typeEntityTypeResult(value)
        case "Substance Group":
            let value = try container.decode(SubstanceGroupResult.self)
            self = .typeSubstanceGroupResult(value)
        case "Symptom":
            let value = try container.decode(SymptomResult.self)
            self = .typeSymptomResult(value)
        case "Treatment":
            let value = try container.decode(TreatmentResult.self)
            self = .typeTreatmentResult(value)
        default:
            throw DecodingError.typeMismatch(Self.Type.self, .init(codingPath: decoder.codingPath, debugDescription: "Unable to decode instance of DiscriminatedSearchMatchResult"))
        }
    }
}

When using the schema:

    DiscriminatedSearchMatchResult:
      oneOf:
        - $ref: '#/components/schemas/ConditionResult'
        - $ref: '#/components/schemas/SubstanceGroupResult'
        - $ref: '#/components/schemas/SymptomResult'
        - $ref: '#/components/schemas/AggravatingFactorResult'
        - $ref: '#/components/schemas/EntityTypeResult'
        - $ref: '#/components/schemas/TreatmentResult'
      discriminator:
        propertyName: matchType
        mapping:
          "Condition": '#/components/schemas/ConditionResult'
          "Substance Group": '#/components/schemas/SubstanceGroupResult'
          "Symptom": '#/components/schemas/SymptomResult'
          "Aggravating Factor": '#/components/schemas/AggravatingFactorResult'
          "Entity Type": '#/components/schemas/EntityTypeResult'
          "Treatment": '#/components/schemas/TreatmentResult'

If anyone wants to take this and create a PR that'd be great. @4brunu

[4brunu]

Currently I don't have much time to work on this.
If someone want's to create a PR I'm happy to help with review.
If not, I will try to create a PR when I have some time.

[teameh]

I think this would still be a great addition. @4brunu I guess you didn't fine the time?