oneOf not generating union class properties Typescript-Angular

[ealtuna]

Description

I am using the example provided in the tests for oneOf. Once I try to generate for typescript-angular I get the three classes:

// apple.ts
export interface Apple { 
    kind?: string;
}

// banana.ts
export interface Banana { 
    count?: number;
}

// fruit.ts
import { Apple } from './apple';
import { Banana } from './banana';

export type Fruit = Apple | Banana;

As you can see the color property of fruit is missing.

openapi-generator version

I was using version 4.0.1 with the docker version.

Docker image used was:

openapitools/openapi-generator-cli@sha256:d67438016ccf3067655eb12ce23aab2b6f3e89f916cd153ae9874251af82b3e2

OpenAPI declaration file content or url

openapi: 3.0.1
info:
   title: fruity
   version: 0.0.1
paths:
   /:
      get:
         responses:
            '200':
               description: desc
               content:
                  application/json:
                     schema:
                        $ref: '#/components/schemas/fruit'
components:
   schemas:
      fruit:
         title: fruit
         properties:
            color:
               type: string
         oneOf:
            - $ref: '#/components/schemas/apple'
            - $ref: '#/components/schemas/banana'
      apple:
         title: apple
         type: object
         properties:
            kind:
               type: string
      banana:
         title: banana
         type: object
         properties:
            count:
               type: number

Command line used for generation

docker run --rm -v ${PWD}:/local openapitools/openapi-generator-cli@sha256:d67438016ccf3067655eb12ce23aab2b6f3e89f916cd153ae9874251af82b3e2 generate \
-i /local/input.yaml \
-g typescript-angular \
-c /local/config.json \
-o /local

Content of config.json is:

{
    "apiPackage": "api",
    "ngVersion": "6"
}

Steps to reproduce

Execute the test file using the provided command.

[auto-labeler]

👍 Thanks for opening this issue!
🏷 I have applied any labels matching special text in your issue.

The team will review the labels and make any necessary changes.

[mhamel06]

I found a few other things of note regarding the oneOf TypeScript client generator.

I'm getting the same output as @ealtuna with the given example.

Is that the expected behavior given a top level oneOf definition?

This example would make more sense to me:

components:
   schemas:
      fruit:
         title: fruit
         properties:
            color:
               type: string
            value:
               oneOf:
                  - $ref: '#/components/schemas/apple'
                  - $ref: '#/components/schemas/banana'

That version looks like it will work properly but the generated oneOf model files are not generated

Output:

// Fruit.ts
...
import {
    OneOfapplebanana, // Does not exist 
    OneOfapplebananaFromJSON,
    OneOfapplebananaToJSON,
} from './';

/**
 * 
 * @export
 * @interface Fruit
 */
export interface Fruit {
    /**
     * 
     * @type {string}
     * @memberof Fruit
     */
    color?: string;
    /**
     * 
     * @type {OneOfapplebanana}
     * @memberof Fruit
     */
    value?: OneOfapplebanana;
}
...

One last issue I ran into was that primitive data types are ignored when they are used in oneOf definitions.

ex.

components:
   schemas:
      fruit:
         title: fruit
         properties:
            color:
               type: string
         oneOf:
            - $ref: '#/components/schemas/apple'
            - $ref: '#/components/schemas/banana'
            - string
            - integer

outputs:

// Fruit.ts

import {
    Apple,
    Banana,
} from './';

/**
 * @type Fruit
 * @export
 */
export type Fruit = Apple | Banana; // Expected string | integer here as well

[Dynalon]

Same issue exists in the typescript-fetch generator, the OneOf* functions don't get generated, but referenced leading to a compilation error :(

[scottydawg]

Similar issues here. With a schema like:

      AssetList
        ...  
        items:
          type: array
          items:
            discriminator:
              propertyName: assetType
            oneOf:
              - $ref: '#/components/schemas/BackgroundReference'
              - $ref: '#/components/schemas/EmbellishmentReference'
              - $ref: '#/components/schemas/LayoutReference'
              - $ref: '#/components/schemas/MaskReference'

I'm seeing TypeScript compilation errors like:

src/assetList.ts:14:92 - error TS2307: Cannot find module './oneOfBackgroundReferenceEmbellishmentReferenceLayoutReferenceMaskReference'.

14 import { OneOfBackgroundReferenceEmbellishmentReferenceLayoutReferenceMaskReference } from './oneOfBackgroundReferenceEmbellishmentReferenceLayoutReferenceMaskReference';

I'm seeing this with primitives as well:

    LayoutReference:
      allOf:
        - $ref: '#/components/schemas/AssetReference'
        - type: object
          properties:
            ...
            layout:
              oneOf:
                - type: string
                - type: object

TypeScript error:

src/layoutReference.ts:17:35 - error TS2307: Cannot find module './oneOfstringobject'.

17 import { OneOfstringobject } from './oneOfstringobject';

[mribichich]

i think its not supported to have top level properties and oneOf. you should include the color: type: string on each schema

but its true that even like this, the union type FromJSON and ToJSON are not being generated.

the individuals FromJSON and ToJSON to each oneOf are being generated.

it seems that when there's a discriminator its not creating the top level functions FromJSON and ToJSON to choose between the underlying oneOf types base on that discriminator

{
    "title": "Reserve Deal Vehicle Request",
    "oneOf": [
        { "$ref": "reserve_deal_vehicle_email.json#" },
        { "$ref": "reserve_deal_vehicle_phone.json#" }
    ],
    "discriminator": {
        "propertyName": "type",
        "mapping": {
            "email": "reserve_deal_vehicle_email.json",
            "sms": "reserve_deal_vehicle_phone.json"
        }
    }
}

{
    "title": "Reserve Deal Vehicle Request Email",
    "type": "object",
    "required": ["first_name", "last_name", "email"],
    "properties": {
        "email": { "type": "string", "format": "email" },
        "type": { "const": "email" }
    }
}

{
    "title": "Reserve Deal Vehicle Request Phone",
    "type": "object",
    "required": ["first_name", "last_name", "phone"],
    "properties": {
        "phone": { "type": "string" },
        "type": { "const": "sms" }
    }
}

result:

import {
    RequestsReserveDealVehicleEmail,
    RequestsReserveDealVehiclePhone,
} from './';

export type RequestsReserveDealVehicle = RequestsReserveDealVehicleEmail | RequestsReserveDealVehiclePhone;

// No top level FromJson and ToJson

export interface RequestsReserveDealVehicleEmail { 
    email: string; 
    type?: RequestsReserveDealVehicleEmailTypeEnum;
}

export function RequestsReserveDealVehicleEmailFromJSON(json: any): RequestsReserveDealVehicleEmail {
    return {
        'email': json['email'],
        'type': !exists(json, 'type') ? undefined : json['type'],
    };
}

export function RequestsReserveDealVehicleEmailToJSON(value?: RequestsReserveDealVehicleEmail): any {
    if (value === undefined) {
        return undefined;
    }
    return {
        'email': value.email,
        'type': value.type,
    };
}

export enum RequestsReserveDealVehicleEmailTypeEnum {
    Email = 'email'
}

export interface RequestsReserveDealVehiclePhone {
    phone: string;
    type?: RequestsReserveDealVehiclePhoneTypeEnum;
}

export function RequestsReserveDealVehiclePhoneFromJSON(json: any): RequestsReserveDealVehiclePhone {
    return {
        'phone': json['phone'],
        'type': !exists(json, 'type') ? undefined : json['type'],
    };
}

export function RequestsReserveDealVehiclePhoneToJSON(value?: RequestsReserveDealVehiclePhone): any {
    if (value === undefined) {
        return undefined;
    }
    return {
        'phone': value.phone,
        'type': value.type,
    };
}

export enum RequestsReserveDealVehiclePhoneTypeEnum {
    Sms = 'sms'
}

We need a FromJSON and ToJSON thats uses the discriminator to choose between one or the other

[cjam]

I'm not positive that it was exactly the same issue, but I managed to get the desired results while using the taggedUnion=true by modifying the modelTaggedUnion.mustache file to look like this:

{{#discriminator}}
export type {{classname}} = {{#children}}{{^-first}} | {{/-first}}{{classname}}{{/children}};
{{/discriminator}}
{{^discriminator}}
{{#parent}}
export interface {{classname}} { {{>modelGenericAdditionalProperties}}
{{#allVars}}
    {{#description}}
    /**
    * {{{description}}}
    */
    {{/description}}
    {{name}}{{^required}}?{{/required}}: {{#discriminatorValue}}'{{discriminatorValue}}'{{/discriminatorValue}}{{^discriminatorValue}}{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{/discriminatorValue}}{{#isNullable}} | null{{/isNullable}};
{{/allVars}}
{{!-- 
The following section is necessary as it seems that when the discriminatorValue is present
 the allVars doesn't contain the parent members.  But vars does, so just including them in as well
--}}
{{#vars}}
    {{#description}}
    /**
    * {{{description}}}
    */
    {{/description}}
    {{name}}{{^required}}?{{/required}}: {{#discriminatorValue}}'{{discriminatorValue}}'{{/discriminatorValue}}{{^discriminatorValue}}{{#isEnum}}{{{datatypeWithEnum}}}{{/isEnum}}{{^isEnum}}{{{dataType}}}{{/isEnum}}{{/discriminatorValue}}{{#isNullable}} | null{{/isNullable}};
{{/vars}}
}
{{>modelGenericEnums}}
{{/parent}}
{{^parent}}{{>modelGeneric}}{{/parent}}{{/discriminator}}

Just thought I'd post it back here in the event it helps someone work around / fix the problem.