[bugfix] [typescript-fetch] add oneOf string union & array support (#19909)

modules/openapi-generator/src/main/java/org/openapitools/codegen/CodegenProperty.java

@@ -20,12 +20,7 @@
 import lombok.Getter;
 import lombok.Setter;
 
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Objects;
+import java.util.*;
 
 public class CodegenProperty implements Cloneable, IJsonSchemaValidationProperties {
     /**
@@ -960,6 +955,19 @@ public void setIsEnum(boolean isEnum) {
         this.isEnum = isEnum;
     }
 
+    @SuppressWarnings("unchecked")
+    public List<String> getAllowableValuesList() {
+        return Optional.ofNullable(this.getAllowableValues())
+                .map(allowableValues -> allowableValues.get("values"))
+                .flatMap(valuesList -> {
+                    try {
+                        return Optional.ofNullable((List<String>)valuesList);
+                    } catch (ClassCastException e) {
+                        return Optional.empty();
+                    }
+                })
+                .orElse(Collections.emptyList());
+    }
 
     @Override
     public String toString() {

modules/openapi-generator/src/main/java/org/openapitools/codegen/DefaultCodegen.java

@@ -2707,6 +2707,11 @@ protected void updateModelForComposedSchema(CodegenModel m, Schema schema, Map<S
 
                         }
                     } else if (composed.getOneOf() != null) {
+                        if (ModelUtils.isStringSchema(interfaceSchema) && ModelUtils.isEnumSchema(interfaceSchema)) {
+                            // use string union literals
+                            languageType = getEnumStringLiteralUnionType(interfaceSchema);
+                        }
+
                         if (m.oneOf.contains(languageType)) {
                             LOGGER.debug("{} (oneOf schema) already has `{}` defined and therefore it's skipped.", m.name, languageType);
                         } else {
@@ -2819,6 +2824,13 @@ protected void updateModelForComposedSchema(CodegenModel m, Schema schema, Map<S
         // end of code block for composed schema
     }
 
+    @SuppressWarnings("unchecked")
+    private static String getEnumStringLiteralUnionType(Schema interfaceSchema) {
+        return (String) interfaceSchema.getEnum().stream()
+                .map(enumName -> "\"" + (String)enumName + "\"")
+                .collect(Collectors.joining(" | "));
+    }
+
     /**
      * Combines all previously-detected type entries for a schema with newly-discovered ones, to ensure
      * that schema for items like enum include all possible values.

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptFetchClientCodegen.java

@@ -780,16 +780,39 @@ private ExtendedCodegenModel processCodeGenModel(ExtendedCodegenModel cm) {
                 }
             }
         }
+
+        cm.hasStringOneOf = cm.oneOf.contains("string");
+        cm.hasStringArrayOneOf = cm.oneOf.contains("Array<string>");
+
+        List<CodegenProperty> oneOfsList = Optional.ofNullable(cm.getComposedSchemas())
+                .map(CodegenComposedSchemas::getOneOf)
+                .orElse(Collections.emptyList());
+
+        cm.oneOfModels = oneOfsList.stream()
+                .filter(CodegenProperty::getIsModel)
+                .map(CodegenProperty::getBaseType)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toCollection(TreeSet::new));
+
+        cm.oneOfStringEnums = oneOfsList.stream()
+                .filter(CodegenProperty::getIsEnum)
+                .map(CodegenProperty::getAllowableValuesList)
+                .flatMap(Collection::stream)
+                .collect(Collectors.toCollection(TreeSet::new));
+
+        cm.oneOfArrays = oneOfsList.stream()
+                .filter(CodegenProperty::getIsArray)
+                .map(CodegenProperty::getComplexType)
+                .filter(Objects::nonNull)
+                .collect(Collectors.toCollection(TreeSet::new));
+
         if (!cm.oneOf.isEmpty()) {
             // For oneOfs only import $refs within the oneOf
-            TreeSet<String> oneOfRefs = new TreeSet<>();
-            for (String im : cm.imports) {
-                if (cm.oneOf.contains(im)) {
-                    oneOfRefs.add(im);
-                }
-            }
-            cm.imports = oneOfRefs;
+            cm.imports = cm.imports.stream()
+                    .filter(im -> cm.oneOfModels.contains(im) || cm.oneOfArrays.contains(im))
+                    .collect(Collectors.toCollection(TreeSet::new));
         }
+
         return cm;
     }
 
@@ -1472,6 +1495,16 @@ public String toString() {
     public class ExtendedCodegenModel extends CodegenModel {
         @Getter @Setter
         public Set<String> modelImports = new TreeSet<String>();
+
+        @Getter @Setter
+        public Set<String> oneOfModels = new TreeSet<>();
+        @Getter @Setter
+        public Set<String> oneOfStringEnums = new TreeSet<>();
+        @Getter @Setter
+        public Set<String> oneOfArrays = new TreeSet<>();
+
+        public boolean hasStringOneOf;
+        public boolean hasStringArrayOneOf;
         public boolean isEntity; // Is a model containing an "id" property marked as isUniqueId
         public String returnPassthrough;
         public boolean hasReturnPassthroughVoid;
@@ -1568,6 +1601,7 @@ public ExtendedCodegenModel(CodegenModel cm) {
             this.setItems(cm.getItems());
             this.setAdditionalProperties(cm.getAdditionalProperties());
             this.setIsModel(cm.getIsModel());
+            this.setComposedSchemas(cm.getComposedSchemas());
         }
 
         @Override

modules/openapi-generator/src/main/java/org/openapitools/codegen/languages/TypeScriptReduxQueryClientCodegen.java

@@ -32,6 +32,7 @@
 import java.util.List;
 import java.util.Map;
 import java.util.TreeSet;
+import java.util.stream.Collectors;
 
 public class TypeScriptReduxQueryClientCodegen extends AbstractTypeScriptClientCodegen {
 
@@ -145,13 +146,9 @@ public ModelsMap postProcessModels(ModelsMap objs) {
             }
             if (!cm.oneOf.isEmpty()) {
                 // For oneOfs only import $refs within the oneOf
-                TreeSet<String> oneOfRefs = new TreeSet<>();
-                for (String im : cm.imports) {
-                    if (cm.oneOf.contains(im)) {
-                        oneOfRefs.add(im);
-                    }
-                }
-                cm.imports = oneOfRefs;
+                cm.imports = cm.imports.stream()
+                        .filter(cm.oneOf::contains)
+                        .collect(Collectors.toCollection(TreeSet::new));
             }
         }
 

modules/openapi-generator/src/main/resources/typescript-fetch/modelOneOf.mustache

@@ -1,13 +1,13 @@
 {{#hasImports}}
-{{#oneOf}}
+{{#imports}}
 import type { {{{.}}} } from './{{.}}{{importFileExtension}}';
 import {
     instanceOf{{{.}}},
     {{{.}}}FromJSON,
     {{{.}}}FromJSONTyped,
     {{{.}}}ToJSON,
 } from './{{.}}{{importFileExtension}}';
-{{/oneOf}}
+{{/imports}}
 
 {{/hasImports}}
 {{>modelOneOfInterfaces}}
@@ -31,11 +31,40 @@ export function {{classname}}FromJSONTyped(json: any, ignoreDiscriminator: boole
     }
 {{/discriminator}}
 {{^discriminator}}
-    {{#oneOf}}
+    {{#oneOfStringEnums}}
+    if (json === "{{{.}}}") {
+        return json;
+    }
+    {{/oneOfStringEnums}}
+    {{#hasStringOneOf}}
+    if (json instanceof String) {
+        return json as {{classname}};
+    }
+    {{/hasStringOneOf}}
+    if (!(json instanceof Object)){
+        return {} as any;
+    }
+    {{#hasStringArrayOneOf}}
+    if (Array.isArray(json) && json.every(item => item instanceof String)) {
+        return json as Array<string>;
+    }
+    {{/hasStringArrayOneOf}}
+    {{#oneOfModels}}
     if (instanceOf{{{.}}}(json)) {
         return {{{.}}}FromJSONTyped(json, true);
     }
-    {{/oneOf}}
+    {{/oneOfModels}}
+    {{#oneOfArrays}}
+    {{#-first}}
+    if (Array.isArray(json) && json.every(item => item instanceof Object)) {
+    {{/-first}}
+        if (json.every(item => instanceOf{{{.}}}(item as Object))) {
+            return json.map(value => {{{.}}}FromJSONTyped(value, true));
+        }
+    {{#-last}}
+    }
+    {{/-last}}
+    {{/oneOfArrays}}
 
     return {} as any;
 {{/discriminator}}
@@ -61,11 +90,40 @@ export function {{classname}}ToJSONTyped(value?: {{classname}} | null, ignoreDis
 {{/discriminator}}
 
 {{^discriminator}}
-    {{#oneOf}}
+    {{#oneOfStringEnums}}
+    if (value === "{{{.}}}") {
+        return value;
+    }
+    {{/oneOfStringEnums}}
+    {{#hasStringOneOf}}
+    if (value instanceof String) {
+        return value;
+    }
+    {{/hasStringOneOf}}
+    if (!(value instanceof Object)){
+        return {};
+    }
+    {{#hasStringArrayOneOf}}
+    if (Array.isArray(value) && value.every(item => item instanceof String)) {
+        return value;
+    }
+    {{/hasStringArrayOneOf}}
+    {{#oneOfModels}}
     if (instanceOf{{{.}}}(value)) {
         return {{{.}}}ToJSON(value as {{{.}}});
     }
-    {{/oneOf}}
+    {{/oneOfModels}}
+    {{#oneOfArrays}}
+    {{#-first}}
+    if (Array.isArray(value) && value.every(item => item instanceof Object)) {
+    {{/-first}}
+        if (value.every(item => instanceOf{{{.}}}(item as Object))) {
+            return value.map(value => {{{.}}}ToJSON(value as {{{.}}}));
+        }
+    {{#-last}}
+    }
+    {{/-last}}
+    {{/oneOfArrays}}
 
     return {};
 {{/discriminator}}

modules/openapi-generator/src/test/resources/3_0/typescript-fetch/oneOf.yaml

@@ -15,12 +15,38 @@ paths:
             application/json:
               schema:
                 $ref: '#/components/schemas/TestResponse'
+  /test-array:
+    get:
+      operationId: testArray
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                $ref: '#/components/schemas/TestArrayResponse'
 components:
   schemas:
+    TestArrayResponse:
+      oneOf:
+        - type: array
+          items:
+            $ref: "#/components/schemas/TestA"
+        - type: array
+          items:
+            $ref: "#/components/schemas/TestB"
+        - type: array
+          items:
+            type: string
     TestResponse:
       oneOf:
         - $ref: "#/components/schemas/TestA"
         - $ref: "#/components/schemas/TestB"
+        - type: string
+          enum:
+            - StringEnum1
+            - StringEnum2
+        - type: string
     TestA:
       type: object
       properties:

samples/client/petstore/typescript-fetch/builds/oneOf/.openapi-generator/FILES

@@ -2,6 +2,7 @@ apis/DefaultApi.ts
 apis/index.ts
 index.ts
 models/TestA.ts
+models/TestArrayResponse.ts
 models/TestB.ts
 models/TestResponse.ts
 models/index.ts

samples/client/petstore/typescript-fetch/builds/oneOf/apis/DefaultApi.ts

@@ -15,9 +15,12 @@
 
 import * as runtime from '../runtime';
 import type {
+  TestArrayResponse,
   TestResponse,
 } from '../models/index';
 import {
+    TestArrayResponseFromJSON,
+    TestArrayResponseToJSON,
     TestResponseFromJSON,
     TestResponseToJSON,
 } from '../models/index';
@@ -51,4 +54,28 @@ export class DefaultApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     */
+    async testArrayRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TestArrayResponse>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        const response = await this.request({
+            path: `/test-array`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => TestArrayResponseFromJSON(jsonValue));
+    }
+
+    /**
+     */
+    async testArray(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TestArrayResponse> {
+        const response = await this.testArrayRaw(initOverrides);
+        return await response.value();
+    }
+
 }