Fix nested any-of

Author: nicolas-chaulet

src/openApi/v3/interfaces/OpenApiSchema.d.ts

@@ -26,7 +26,7 @@ export interface OpenApiSchema extends OpenApiReference, WithEnumExtension {
     required?: string[];
     enum?: (string | number)[];
     type?: string | string[];
-    const?: string | number | boolean | null;
+    const?: string | number | null;
     allOf?: OpenApiSchema[];
     oneOf?: OpenApiSchema[];
     anyOf?: OpenApiSchema[];

src/openApi/v3/parser/getModel.spec.ts

@@ -0,0 +1,92 @@
+import { reservedWords } from '../../../utils/reservedWords';
+import { getModel } from './getModel';
+import { getType } from './getType';
+
+const openApi = {
+    openapi: '3.0',
+    info: {
+        title: 'dummy',
+        version: '1.0',
+    },
+    paths: {},
+    servers: [
+        {
+            url: 'https://localhost:8080/api',
+        },
+    ],
+    components: {
+        schemas: {
+            Enum1: {
+                enum: ['Bird', 'Dog'],
+                type: 'string',
+            },
+            ConstValue: {
+                type: 'string',
+                const: 'ConstValue',
+            },
+            CompositionWithAnyOfAndNull: {
+                description:
+                    "This is a model with one property with a 'any of' relationship where the options are not $ref",
+                type: 'object',
+                properties: {
+                    propA: {
+                        anyOf: [
+                            {
+                                items: {
+                                    anyOf: [
+                                        {
+                                            $ref: '#/components/schemas/Enum1',
+                                        },
+                                        {
+                                            $ref: '#/components/schemas/ConstValue',
+                                        },
+                                    ],
+                                },
+                                type: 'array',
+                            },
+                            {
+                                type: 'null',
+                            },
+                        ],
+                    },
+                },
+            },
+            CompositionWithAny: {
+                description:
+                    "This is a model with one property with a 'any of' relationship where the options are not $ref",
+                type: 'object',
+                properties: {
+                    propA: {
+                        anyOf: [
+                            {
+                                $ref: '#/components/schemas/Enum1',
+                            },
+                            {
+                                $ref: '#/components/schemas/ConstValue',
+                            },
+                            {
+                                type: 'null',
+                            },
+                        ],
+                    },
+                },
+            },
+        },
+    },
+};
+
+describe('getModel', () => {
+    it('Parses any of', () => {
+        const definition = openApi.components.schemas.CompositionWithAnyOfAndNull;
+        const definitionType = getType('CompositionWithAnyOfAndNull');
+        const model = getModel(openApi, definition, true, definitionType.base.replace(reservedWords, '_$1'));
+        expect(model.properties[0].properties.length).toBe(2);
+    });
+
+    it('Parses any of 2', () => {
+        const definition = openApi.components.schemas.CompositionWithAny;
+        const definitionType = getType('CompositionWithAny');
+        const model = getModel(openApi, definition, true, definitionType.base.replace(reservedWords, '_$1'));
+        expect(model.properties[0].properties.length).toBe(3);
+    });
+});

src/openApi/v3/parser/getModel.ts

@@ -82,6 +82,8 @@ export const getModel = (
             model.imports.push(...arrayItems.imports);
             model.default = getModelDefault(definition, model);
             return model;
+        } else if (definition.items.anyOf) {
+            return getModel(openApi, definition.items);
         } else {
             const arrayItems = getModel(openApi, definition.items);
             model.export = 'array';

test/__snapshots__/index.spec.ts.snap

@@ -3686,19 +3686,22 @@ export type { CompositionWithAllOfAndNullable } from './models/CompositionWithAl
 export type { CompositionWithAnyOf } from './models/CompositionWithAnyOf';
 export type { CompositionWithAnyOfAndNullable } from './models/CompositionWithAnyOfAndNullable';
 export type { CompositionWithAnyOfAnonymous } from './models/CompositionWithAnyOfAnonymous';
+export type { CompositionWithNestedAnyOfAndNull } from './models/CompositionWithNestedAnyOfAndNull';
 export type { CompositionWithOneOf } from './models/CompositionWithOneOf';
 export type { CompositionWithOneOfAndComplexArrayDictionary } from './models/CompositionWithOneOfAndComplexArrayDictionary';
 export type { CompositionWithOneOfAndNullable } from './models/CompositionWithOneOfAndNullable';
 export type { CompositionWithOneOfAndSimpleArrayDictionary } from './models/CompositionWithOneOfAndSimpleArrayDictionary';
 export type { CompositionWithOneOfAndSimpleDictionary } from './models/CompositionWithOneOfAndSimpleDictionary';
 export type { CompositionWithOneOfAnonymous } from './models/CompositionWithOneOfAnonymous';
 export type { CompositionWithOneOfDiscriminator } from './models/CompositionWithOneOfDiscriminator';
+export type { ConstValue } from './models/ConstValue';
 export type { DeprecatedModel } from './models/DeprecatedModel';
 export type { DictionaryWithArray } from './models/DictionaryWithArray';
 export type { DictionaryWithDictionary } from './models/DictionaryWithDictionary';
 export type { DictionaryWithProperties } from './models/DictionaryWithProperties';
 export type { DictionaryWithReference } from './models/DictionaryWithReference';
 export type { DictionaryWithString } from './models/DictionaryWithString';
+export { Enum1 } from './models/Enum1';
 export type { EnumFromDescription } from './models/EnumFromDescription';
 export { EnumWithExtensions } from './models/EnumWithExtensions';
 export { EnumWithNumbers } from './models/EnumWithNumbers';
@@ -3757,19 +3760,22 @@ export { $CompositionWithAllOfAndNullable } from './schemas/$CompositionWithAllO
 export { $CompositionWithAnyOf } from './schemas/$CompositionWithAnyOf';
 export { $CompositionWithAnyOfAndNullable } from './schemas/$CompositionWithAnyOfAndNullable';
 export { $CompositionWithAnyOfAnonymous } from './schemas/$CompositionWithAnyOfAnonymous';
+export { $CompositionWithNestedAnyOfAndNull } from './schemas/$CompositionWithNestedAnyOfAndNull';
 export { $CompositionWithOneOf } from './schemas/$CompositionWithOneOf';
 export { $CompositionWithOneOfAndComplexArrayDictionary } from './schemas/$CompositionWithOneOfAndComplexArrayDictionary';
 export { $CompositionWithOneOfAndNullable } from './schemas/$CompositionWithOneOfAndNullable';
 export { $CompositionWithOneOfAndSimpleArrayDictionary } from './schemas/$CompositionWithOneOfAndSimpleArrayDictionary';
 export { $CompositionWithOneOfAndSimpleDictionary } from './schemas/$CompositionWithOneOfAndSimpleDictionary';
 export { $CompositionWithOneOfAnonymous } from './schemas/$CompositionWithOneOfAnonymous';
 export { $CompositionWithOneOfDiscriminator } from './schemas/$CompositionWithOneOfDiscriminator';
+export { $ConstValue } from './schemas/$ConstValue';
 export { $DeprecatedModel } from './schemas/$DeprecatedModel';
 export { $DictionaryWithArray } from './schemas/$DictionaryWithArray';
 export { $DictionaryWithDictionary } from './schemas/$DictionaryWithDictionary';
 export { $DictionaryWithProperties } from './schemas/$DictionaryWithProperties';
 export { $DictionaryWithReference } from './schemas/$DictionaryWithReference';
 export { $DictionaryWithString } from './schemas/$DictionaryWithString';
+export { $Enum1 } from './schemas/$Enum1';
 export { $EnumFromDescription } from './schemas/$EnumFromDescription';
 export { $EnumWithExtensions } from './schemas/$EnumWithExtensions';
 export { $EnumWithNumbers } from './schemas/$EnumWithNumbers';
@@ -4107,6 +4113,23 @@ export type CompositionWithAnyOfAnonymous = {
 "
 `;
 
+exports[`v3 should generate: test/generated/v3/models/CompositionWithNestedAnyOfAndNull.ts 1`] = `
+"/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ConstValue } from './ConstValue';
+import type { Enum1 } from './Enum1';
+/**
+ * This is a model with one property with a 'any of' relationship where the options are not $ref
+ */
+export type CompositionWithNestedAnyOfAndNull = {
+    propA?: ((Enum1 | ConstValue) | null);
+};
+
+"
+`;
+
 exports[`v3 should generate: test/generated/v3/models/CompositionWithOneOf.ts 1`] = `
 "/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
@@ -4223,6 +4246,15 @@ export type CompositionWithOneOfDiscriminator = (ModelCircle | ModelSquare);
 "
 `;
 
+exports[`v3 should generate: test/generated/v3/models/ConstValue.ts 1`] = `
+"/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export type ConstValue = "ConstValue";
+"
+`;
+
 exports[`v3 should generate: test/generated/v3/models/DeprecatedModel.ts 1`] = `
 "/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
@@ -4308,6 +4340,18 @@ export type DictionaryWithString = Record<string, string>;
 "
 `;
 
+exports[`v3 should generate: test/generated/v3/models/Enum1.ts 1`] = `
+"/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export enum Enum1 {
+    BIRD = 'Bird',
+    DOG = 'Dog',
+}
+"
+`;
+
 exports[`v3 should generate: test/generated/v3/models/EnumFromDescription.ts 1`] = `
 "/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
@@ -5320,6 +5364,32 @@ export const $CompositionWithAnyOfAnonymous = {
 "
 `;
 
+exports[`v3 should generate: test/generated/v3/schemas/$CompositionWithNestedAnyOfAndNull.ts 1`] = `
+"/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $CompositionWithNestedAnyOfAndNull = {
+    description: \`This is a model with one property with a 'any of' relationship where the options are not $ref\`,
+    properties: {
+        propA: {
+            type: 'any-of',
+            contains: [{
+                type: 'any-of',
+                contains: [{
+                    type: 'Enum1',
+                }, {
+                    type: 'ConstValue',
+                }],
+            }, {
+                type: 'null',
+            }],
+        },
+    },
+} as const;
+"
+`;
+
 exports[`v3 should generate: test/generated/v3/schemas/$CompositionWithOneOf.ts 1`] = `
 "/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
@@ -5505,6 +5575,17 @@ export const $CompositionWithOneOfDiscriminator = {
 "
 `;
 
+exports[`v3 should generate: test/generated/v3/schemas/$ConstValue.ts 1`] = `
+"/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $ConstValue = {
+    type: '"ConstValue"',
+} as const;
+"
+`;
+
 exports[`v3 should generate: test/generated/v3/schemas/$DeprecatedModel.ts 1`] = `
 "/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */
@@ -5605,6 +5686,17 @@ export const $DictionaryWithString = {
 "
 `;
 
+exports[`v3 should generate: test/generated/v3/schemas/$Enum1.ts 1`] = `
+"/* generated using openapi-typescript-codegen -- do no edit */
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+export const $Enum1 = {
+    type: 'Enum',
+} as const;
+"
+`;
+
 exports[`v3 should generate: test/generated/v3/schemas/$EnumFromDescription.ts 1`] = `
 "/* generated using openapi-typescript-codegen -- do no edit */
 /* istanbul ignore file */

test/spec/v3.json

@@ -2071,6 +2071,44 @@
                     }
                 }
             },
+            "Enum1":{
+                "enum": [
+                    "Bird",
+                    "Dog"
+                ],
+                "type": "string"
+            },
+            "ConstValue": {
+                "type": "string",
+                "const": "ConstValue"
+            },
+            "CompositionWithNestedAnyOfAndNull": {
+                "description": "This is a model with one property with a 'any of' relationship where the options are not $ref",
+                "type": "object",
+                "properties": {
+                    "propA": {
+                        "anyOf": [
+                            {
+                                "items": {
+                                    "anyOf": [
+                                        {
+                                            "$ref": "#/components/schemas/Enum1"
+                                        },
+                                        {
+                                            "$ref": "#/components/schemas/ConstValue"
+                                        }
+                                    ]
+                                },
+                                "type": "array"
+                            },
+                            {
+                                "type": "null"
+                            }
+                        ],
+                        "title": "Scopes"
+                    }
+                }
+            },
             "CompositionWithOneOfAndNullable": {
                 "description": "This is a model with one property with a 'one of' relationship",
                 "type": "object",
@@ -2574,4 +2612,4 @@
             }
         }
     }
-}
+}