feat: Improve support for allOf, oneOf, and anyOf

Author: budde377

src/client/interfaces/Model.d.ts

@@ -3,7 +3,7 @@ import type { Schema } from './Schema';
 
 export interface Model extends Schema {
     name: string;
-    export: 'reference' | 'generic' | 'enum' | 'array' | 'dictionary' | 'interface';
+    export: 'reference' | 'generic' | 'enum' | 'array' | 'dictionary' | 'interface' | 'one-of' | 'any-of' | 'all-of';
     type: string;
     base: string;
     template: string | null;

src/openApi/v3/parser/getModel.ts

@@ -126,74 +126,42 @@ export function getModel(openApi: OpenApi, definition: OpenApiSchema, isDefiniti
             return model;
         }
     }
-
     // TODO:
-    //  Add correct support for oneOf, anyOf, allOf
+    //  Add correct support for oneOf
     //  https://swagger.io/docs/specification/data-models/oneof-anyof-allof-not/
 
-    if (definition.anyOf && definition.anyOf.length && !definition.properties) {
-        model.export = 'generic';
-        const compositionTypes = definition.anyOf.filter(type => type.$ref).map(type => getType(type.$ref));
-        const composition = compositionTypes
-            .map(type => type.type)
-            .sort()
-            .join(' | ');
-        model.imports.push(...compositionTypes.map(type => type.base));
-        model.type = composition;
-        model.base = composition;
-        return model;
-    }
-
-    if (definition.oneOf && definition.oneOf.length && !definition.properties) {
-        model.export = 'generic';
-        const compositionTypes = definition.oneOf.filter(type => type.$ref).map(type => getType(type.$ref));
-        const composition = compositionTypes
-            .map(type => type.type)
-            .sort()
-            .join(' | ');
-        model.imports.push(...compositionTypes.map(type => type.base));
-        model.type = composition;
-        model.base = composition;
+    if (definition.oneOf?.length || definition.anyOf?.length || definition.allOf?.length) {
+        let types: OpenApiSchema[] = [];
+        if (definition.oneOf?.length) {
+            model.export = 'one-of';
+            types = definition.oneOf;
+        } else if (definition.anyOf?.length) {
+            model.export = 'any-of';
+            types = definition.anyOf;
+        } else if (definition.allOf?.length) {
+            model.export = 'all-of';
+            types = definition.allOf;
+        }
+        const compositionTypes = types.map(model => getModel(openApi, model));
+        model.properties = compositionTypes;
+        model.imports.push(...compositionTypes.reduce((acc: string[], type) => acc.concat(type.imports), []));
+        model.enums.push(...compositionTypes.reduce((acc: Model[], type) => acc.concat(type.enums), []));
         return model;
     }
 
-    if (definition.type === 'object' || definition.allOf) {
+    if (definition.type === 'object') {
         model.export = 'interface';
         model.type = PrimaryType.OBJECT;
         model.base = PrimaryType.OBJECT;
         model.default = getModelDefault(definition, model);
-
-        if (definition.allOf && definition.allOf.length) {
-            definition.allOf.forEach(parent => {
-                if (parent.$ref) {
-                    const parentRef = getType(parent.$ref);
-                    model.extends.push(parentRef.base);
-                    model.imports.push(parentRef.base);
-                }
-                if (parent.type === 'object' && parent.properties) {
-                    const properties = getModelProperties(openApi, parent, getModel);
-                    properties.forEach(property => {
-                        model.properties.push(property);
-                        model.imports.push(...property.imports);
-                        if (property.export === 'enum') {
-                            model.enums.push(property);
-                        }
-                    });
-                }
-            });
-        }
-
-        if (definition.properties) {
-            const properties = getModelProperties(openApi, definition, getModel);
-            properties.forEach(property => {
-                model.properties.push(property);
-                model.imports.push(...property.imports);
-                if (property.export === 'enum') {
-                    model.enums.push(property);
-                }
-            });
-        }
-
+        const properties = getModelProperties(openApi, definition, getModel);
+        properties.forEach(property => {
+            model.properties.push(property);
+            model.imports.push(...property.imports);
+            if (property.export === 'enum') {
+                model.enums.push(property);
+            }
+        });
         return model;
     }
 

src/templates/partials/schema.hbs

@@ -6,6 +6,12 @@
 {{>schemaArray}}
 {{else equals export 'dictionary'}}
 {{>schemaDictionary}}
+{{else equals export 'any-of'}}
+{{>schemaComposition}}
+{{else equals export 'all-of'}}
+{{>schemaComposition}}
+{{else equals export 'one-of'}}
+{{>schemaComposition}}
 {{else}}
 {{>schemaGeneric}}
 {{/equals}}

src/templates/partials/schemaComposition.hbs

@@ -0,0 +1,14 @@
+{
+    type: '{{export}}',
+
+    contains: [{{#each properties}}{{>schema}}, {{/each}}]
+{{#if isReadOnly}}
+    isReadOnly: {{{isReadOnly}}},
+{{/if}}
+{{#if isRequired}}
+    isRequired: {{{isRequired}}},
+{{/if}}
+{{#if isNullable}}
+    isNullable: {{{isNullable}}},
+{{/if}}
+}

src/templates/partials/type.hbs

@@ -8,6 +8,12 @@
 {{>typeArray}}
 {{else equals export 'dictionary'}}
 {{>typeDictionary}}
+{{else equals export 'one-of'}}
+{{>typeUnion}}
+{{else equals export 'any-of'}}
+{{>typeUnion}}
+{{else equals export 'all-of'}}
+{{>typeIntersection}}
 {{else}}
 {{>typeGeneric}}
 {{/equals}}

src/templates/partials/typeIntersection.hbs

@@ -0,0 +1 @@
+({{#each properties}} & {{>type}}{{/each}}){{>isNullable}}

src/templates/partials/typeUnion.hbs

@@ -0,0 +1 @@
+({{#each properties}} | {{>type}}{{/each}}){{>isNullable}}

src/utils/registerHandlebarTemplates.ts

@@ -50,6 +50,7 @@ import partialParameters from '../templates/partials/parameters.hbs';
 import partialResult from '../templates/partials/result.hbs';
 import partialSchema from '../templates/partials/schema.hbs';
 import partialSchemaArray from '../templates/partials/schemaArray.hbs';
+import partialSchemaComposition from '../templates/partials/schemaComposition.hbs';
 import partialSchemaDictionary from '../templates/partials/schemaDictionary.hbs';
 import partialSchemaEnum from '../templates/partials/schemaEnum.hbs';
 import partialSchemaGeneric from '../templates/partials/schemaGeneric.hbs';
@@ -60,7 +61,9 @@ import partialTypeDictionary from '../templates/partials/typeDictionary.hbs';
 import partialTypeEnum from '../templates/partials/typeEnum.hbs';
 import partialTypeGeneric from '../templates/partials/typeGeneric.hbs';
 import partialTypeInterface from '../templates/partials/typeInterface.hbs';
+import partialTypeIntersection from '../templates/partials/typeIntersection.hbs';
 import partialTypeReference from '../templates/partials/typeReference.hbs';
+import partialTypeUnion from '../templates/partials/typeUnion.hbs';
 import { registerHandlebarHelpers } from './registerHandlebarHelpers';
 
 export interface Templates {
@@ -120,13 +123,16 @@ export function registerHandlebarTemplates(): Templates {
     Handlebars.registerPartial('schemaEnum', Handlebars.template(partialSchemaEnum));
     Handlebars.registerPartial('schemaGeneric', Handlebars.template(partialSchemaGeneric));
     Handlebars.registerPartial('schemaInterface', Handlebars.template(partialSchemaInterface));
+    Handlebars.registerPartial('schemaComposition', Handlebars.template(partialSchemaComposition));
     Handlebars.registerPartial('type', Handlebars.template(partialType));
     Handlebars.registerPartial('typeArray', Handlebars.template(partialTypeArray));
     Handlebars.registerPartial('typeDictionary', Handlebars.template(partialTypeDictionary));
     Handlebars.registerPartial('typeEnum', Handlebars.template(partialTypeEnum));
     Handlebars.registerPartial('typeGeneric', Handlebars.template(partialTypeGeneric));
     Handlebars.registerPartial('typeInterface', Handlebars.template(partialTypeInterface));
     Handlebars.registerPartial('typeReference', Handlebars.template(partialTypeReference));
+    Handlebars.registerPartial('typeUnion', Handlebars.template(partialTypeUnion));
+    Handlebars.registerPartial('typeIntersection', Handlebars.template(partialTypeIntersection));
     Handlebars.registerPartial('base', Handlebars.template(partialBase));
 
     // Generic functions used in 'request' file @see src/templates/core/request.hbs for more info