@penkov/swagger-code-gen 1.8.9 → 1.9.0

package/dist/components-parse.js

@@ -1,25 +1,97 @@
-import { Collection } from 'scats';
-import { SchemaFactory } from './schemas.js';
-import { Method } from './method.js';
+import { Collection, mutable, option } from 'scats';
+import { SchemaFactory, SchemaObject } from './schemas.js';
+import { SCHEMA_PREFIX } from './property.js';
+import { Method, supportedBodyMimeTypes } from './method.js';
 export function resolveSchemasTypes(json) {
     const jsonSchemas = json.components.schemas;
     const schemasNames = Collection.from(Object.keys(jsonSchemas));
-    return schemasNames.toMap(name => [name, SchemaFactory.resolveSchemaType(jsonSchemas[name])]);
+    const sharedBodies = Collection.from(Object.keys(json.components.requestBodies))
+        .toMap(name => {
+        const sharedBodyDef = json.components.requestBodies[name];
+        const mimeTypes = Collection.from(Object.keys(sharedBodyDef['content']));
+        const supportedMimeTypes = mimeTypes.filter(_ => supportedBodyMimeTypes.containsKey(_));
+        if (sharedBodyDef['content'][supportedMimeTypes.head]['schema']['$ref']) {
+            return [name + '$RequestBody', 'object'];
+        }
+        else {
+            return [name + '$RequestBody', 'property'];
+        }
+    });
+    return schemasNames.toMap(name => [name, SchemaFactory.resolveSchemaType(jsonSchemas[name])])
+        .appendedAll(sharedBodies);
 }
 export function resolveSchemas(json, schemasTypes, options) {
-    const jsonSchemas = json.components.schemas;
-    const schemasNames = Collection.from(Object.keys(jsonSchemas));
-    return schemasNames
-        .toMap(name => [name, SchemaFactory.build(name, jsonSchemas[name], schemasTypes, options)]);
+    const schemas = Collection.from(Object.keys(json.components.schemas))
+        .toMap(schemaName => [schemaName, json.components.schemas[schemaName]])
+        .appendedAll(Collection.from(Object.keys(json.components.requestBodies))
+        .filter(rb => option(json.components.requestBodies[rb]['content']).isDefined)
+        .toMap(rb => {
+        const sharedBodyDef = json.components.requestBodies[rb];
+        const mimeTypes = Collection.from(Object.keys(sharedBodyDef['content']));
+        const supportedMimeTypes = mimeTypes.filter(_ => supportedBodyMimeTypes.containsKey(_));
+        if (sharedBodyDef['content'][supportedMimeTypes.head]['schema']['$ref']) {
+            return [rb + '$RequestBody', sharedBodyDef['content'][supportedMimeTypes.head]['schema']];
+        }
+        else if (sharedBodyDef['content'][supportedMimeTypes.head]['schema']['anyOf']) {
+            return [rb + '$RequestBody', {
+                    type: Collection.from(sharedBodyDef['content'][supportedMimeTypes.head]['schema']['anyOf'])
+                        .map(x => x['$ref'].toString().substring(SCHEMA_PREFIX.length)).mkString(' | ')
+                }];
+        }
+        else {
+            return [rb + '$RequestBody', {
+                    type: 'any'
+                }];
+        }
+    }));
+    const pool = new mutable.HashMap();
+    pool.addAll(schemas.keySet
+        .filter(s => schemasTypes.get(s).contains('enum') || schemasTypes.get(s).contains('property'))
+        .toMap(name => [name, SchemaFactory.build(name, schemas.get(name).getOrElseThrow(() => new Error(`No schema for ${name}`)), schemasTypes, options)]));
+    const emptyArrayToObj = (x) => SchemaFactory.isEmptyObjectOrArray(x) ? {} : x;
+    pool.addAll(schemas.keySet
+        .filter(s => schemasTypes.get(s).contains('object') &&
+        SchemaObject.allSuperClassDefined(schemas.get(s)
+            .getOrElseThrow(() => new Error(`No schema for ${s}`)), schemasTypes, pool.keySet))
+        .toMap(name => {
+        const schema = schemas.get(name).getOrElseThrow(() => new Error(`No schema for ${name}`));
+        return [name, SchemaObject.fromDefinition(name, emptyArrayToObj(schema), schemasTypes, options, pool.toImmutable)];
+    }));
+    let currentSize = pool.size;
+    let unprocessed = schemas.keySet
+        .filter(s => !pool.containsKey(s) && schemasTypes.get(s).contains('object'));
+    while (unprocessed.nonEmpty) {
+        pool.addAll(unprocessed.filter(s => SchemaObject.allSuperClassDefined(emptyArrayToObj(schemas.get(s).get), schemasTypes, pool.keySet))
+            .toMap(name => [name, SchemaObject.fromDefinition(name, emptyArrayToObj(schemas.get(name).get), schemasTypes, options, pool.toImmutable)]));
+        unprocessed = schemas.keySet
+            .filter(s => !pool.containsKey(s) && schemasTypes.get(s).contains('object'));
+        const newSize = pool.size;
+        if (newSize <= currentSize) {
+            throw new Error(`No superclass definitions were found for ${unprocessed.mkString(', ')}`);
+        }
+        currentSize = newSize;
+    }
+    return pool.toImmutable;
 }
-export function resolvePaths(json, schemasTypes, options) {
+export function resolvePaths(json, schemasTypes, options, pool) {
     const jsonSchemas = json.paths;
     return Collection.from(Object.keys(jsonSchemas)).flatMap(path => {
         const methods = jsonSchemas[path];
-        return Collection.from(Object.keys(methods)).map(methodName => new Method(path, methodName, methods[methodName], schemasTypes, options));
+        return Collection.from(Object.keys(methods)).map(methodName => new Method(path, methodName, methods[methodName], schemasTypes, options, pool));
     }).filter(m => {
         const included = options.includeTags.isEmpty || options.includeTags.intersect(m.tags).nonEmpty;
         const excluded = options.excludeTags.nonEmpty && options.excludeTags.intersect(m.tags).nonEmpty;
         return included && !excluded;
     });
 }
+export function generateInPlace(paths, schemasTypes, options, pool) {
+    return paths.filter(m => option(m.response.inPlace).isDefined)
+        .map(m => {
+        return SchemaObject.fromDefinition(m.response.responseType, m.response.inPlace, schemasTypes, options, pool);
+    }).appendedAll(paths.flatMap(m => m.body)
+        .filter(b => option(b.inPlace).isDefined)
+        .map(m => {
+        console.log(`Generating inplace body: ${m.inPlaceClassname}`);
+        return SchemaObject.fromDefinition(m.inPlaceClassname, m.inPlace, schemasTypes, options, pool);
+    }));
+}

package/dist/index.js

@@ -1,7 +1,7 @@
 import log4js from 'log4js';
 import fetch from 'node-fetch';
 import { Renderer } from './renderer.js';
-import { resolvePaths, resolveSchemas, resolveSchemasTypes } from './components-parse.js';
+import { generateInPlace, resolvePaths, resolveSchemas, resolveSchemasTypes } from './components-parse.js';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import https from 'https';
@@ -27,9 +27,10 @@ export async function main(url, enableScats, targetNode, outputFile, ignoreSSLEr
         .then(async (json) => {
         const schemasTypes = resolveSchemasTypes(json);
         const schemas = resolveSchemas(json, schemasTypes, options);
-        const paths = resolvePaths(json, schemasTypes, options);
+        const paths = resolvePaths(json, schemasTypes, options, schemas);
+        const inplace = generateInPlace(paths, schemasTypes, options, schemas);
         logger.debug(`Downloaded swagger: ${schemas.size} schemas, ${paths.size} paths`);
-        await renderer.renderToFile(schemas.values, paths, enableScats, targetNode, outputFile);
+        await renderer.renderToFile(schemas.appendedAll(inplace.toMap(s => [s.name, s])).values, paths, enableScats, targetNode, outputFile);
         logger.debug(`Wrote client to ${outputFile}`);
     });
 }

package/dist/method.js

@@ -1,12 +1,13 @@
 import { Collection, HashMap, HashSet, identity, Nil, option } from 'scats';
-import { Property } from './property.js';
+import { Property, SCHEMA_PREFIX } from './property.js';
 import { Parameter } from './parameter.js';
 import { SchemaFactory } from './schemas.js';
 import { NameUtils } from './name.utils.js';
+export const SHARED_BODIES_PREFIX = '#/components/requestBodies/';
 const sortByIn = HashMap.of(['path', 0], ['query', 1], ['header', 2], ['cookie', 3], ['body', 4]);
-const supportedBodyMimeTypes = HashMap.of(['application/json', 'Json'], ['application/x-www-form-urlencoded', 'Form'], ['multipart/form-data', 'File'], ['application/octet-stream', 'Binary']);
+export const supportedBodyMimeTypes = HashMap.of(['application/json', 'Json'], ['application/x-www-form-urlencoded', 'Form'], ['multipart/form-data', 'File'], ['application/octet-stream', 'Binary']);
 export class Method {
-    constructor(path, method, def, schemasTypes, options) {
+    constructor(path, method, def, schemasTypes, options, pool) {
         this.path = path;
         this.method = method;
         this.tags = HashSet.from(option(def.tags).getOrElseValue([]));
@@ -38,14 +39,70 @@ export class Method {
             }
         });
         this.body = option(def.requestBody)
-            .flatMap(body => option(body.content))
+            .flatMap(body => option(body.content)
+            .orElse(() => {
+            return option(body).filter(x => {
+                const sharedRef = option(x['$ref']).exists(ref => ref.toString().startsWith(SHARED_BODIES_PREFIX));
+                return sharedRef;
+            })
+                .map(x => {
+                const referenced = pool.get(x['$ref'].substring(SHARED_BODIES_PREFIX.length) + '$RequestBody');
+                if (referenced.exists(o => o instanceof Property)) {
+                    return {
+                        'application/json': {
+                            'schema': {
+                                type: referenced.get.type
+                            },
+                        }
+                    };
+                }
+                else {
+                    return {
+                        'application/json': {
+                            'schema': {
+                                $ref: x['$ref'] + '$RequestBody'
+                            },
+                        }
+                    };
+                }
+            });
+        }))
             .map(body => {
             const bodyRequired = option(def.requestBody.required).contains(true);
             const mimeTypes = Collection.from(Object.keys(body));
             const supportedMimeTypes = mimeTypes.filter(_ => supportedBodyMimeTypes.containsKey(_));
             return supportedMimeTypes.map(mt => {
                 const bodySchemaDef = body[mt].schema;
-                let res = SchemaFactory.build('body', bodySchemaDef, schemasTypes, options);
+                let res;
+                let inPlaceClassname = null;
+                if (SchemaFactory.isEmptyObjectOrArray(bodySchemaDef)) {
+                    res = Property.fromDefinition('body', {
+                        ...bodySchemaDef,
+                        required: bodyRequired,
+                        type: 'object'
+                    }, schemasTypes, options);
+                }
+                else if (bodySchemaDef['$ref']) {
+                    const ref = bodySchemaDef['$ref'].toString();
+                    res = Property.fromDefinition('body', {
+                        ...bodySchemaDef,
+                        $ref: ref.startsWith(SHARED_BODIES_PREFIX) ? SCHEMA_PREFIX + ref.substring(SHARED_BODIES_PREFIX.length, ref.length) : ref,
+                        required: bodyRequired
+                    }, schemasTypes, options);
+                }
+                else if (bodySchemaDef['type']) {
+                    res = Property.fromDefinition('body', {
+                        type: bodySchemaDef['type'],
+                        required: bodyRequired
+                    }, schemasTypes, options);
+                }
+                else {
+                    inPlaceClassname = NameUtils.normaliseClassname(def.operationId + 'Body$' + method);
+                    res = Property.fromDefinition('body', {
+                        ...bodySchemaDef,
+                        $ref: SCHEMA_PREFIX + inPlaceClassname
+                    }, schemasTypes.appended(inPlaceClassname, 'object'), options);
+                }
                 if (res.schemaType === 'property') {
                     const bProperty = res;
                     res = bProperty.copy({
@@ -56,7 +113,9 @@ export class Method {
                 return {
                     body: res,
                     mimeType: mt,
-                    suffix: supportedMimeTypes.size > 1 ? supportedBodyMimeTypes.get(mt).getOrElseValue(mt) : ''
+                    suffix: supportedMimeTypes.size > 1 ? supportedBodyMimeTypes.get(mt).getOrElseValue(mt) : '',
+                    inPlace: inPlaceClassname ? bodySchemaDef : undefined,
+                    inPlaceClassname: inPlaceClassname,
                 };
             });
         })
@@ -69,23 +128,45 @@ export class Method {
             .minByOption(identity);
         const respDef = successCode.map(_ => def.responses[_])
             .orElse(() => option(def.responses['default']))
-            .getOrElseValue(def.responses[statusCodes.head]);
+            .orElse(() => statusCodes.headOption.flatMap(code => option(def.responses[code])))
+            .getOrElseValue({});
         const mimeTypes = option(respDef.content)
             .map(content => Collection.from(Object.keys(content)).toMap(mimeType => [mimeType, content[mimeType]])).getOrElseValue(HashMap.empty);
         this.response = mimeTypes.get('application/json')
             .orElseValue(mimeTypes.values.headOption)
-            .map(p => Property.fromDefinition('', p.schema, schemasTypes, options).copy({
-            nullable: false,
-            required: true
-        }))
-            .map(r => ({
-            asProperty: r,
-            responseType: r.jsType,
-            description: respDef.description
-        }))
+            .filter(p => option(p.schema).isDefined)
+            .map(p => {
+            if (p.schema.type === 'object' && p.schema['properties'] && Object.keys(p.schema['properties']).length > 0) {
+                const inPlaceObject = NameUtils.normaliseClassname(def.operationId + 'Response$' + method);
+                const r = Property.fromDefinition('', {
+                    ...p.schema,
+                    $ref: SCHEMA_PREFIX + inPlaceObject
+                }, schemasTypes.appended(inPlaceObject, 'object'), options).copy({
+                    nullable: false,
+                    required: true
+                });
+                return {
+                    asProperty: r,
+                    responseType: inPlaceObject,
+                    description: respDef.description,
+                    inPlace: p.schema
+                };
+            }
+            else {
+                const r = Property.fromDefinition('', p.schema, schemasTypes, options).copy({
+                    nullable: false,
+                    required: true,
+                });
+                return {
+                    asProperty: r,
+                    responseType: r.jsType,
+                    description: respDef.description,
+                };
+            }
+        })
             .getOrElseValue(({
             asProperty: Property.fromDefinition('UNKNOWN', { type: 'any' }, schemasTypes, options),
-            responseType: 'any'
+            responseType: 'any',
         }));
         this.wrapParamsInObject = this.parameters.size > 2 || (this.body.nonEmpty) && this.parameters.nonEmpty;
     }

package/dist/name.utils.js

@@ -1,5 +1,7 @@
 export class NameUtils {
     static normaliseClassname(n) {
+        if (!n)
+            return '';
         let res = '';
         let needUpperCase = true;
         for (let i = 0; i < n.length; i++) {
@@ -22,7 +24,7 @@ export class NameUtils {
             return `$${n}`;
         }
         else {
-            return n.replace(/\./g, '_');
+            return n.replace(/[./]/g, '_');
         }
     }
 }

package/dist/parameter.js

@@ -32,6 +32,9 @@ export class Parameter {
         let jsType;
         if (schema instanceof SchemaObject) {
             jsType = schema.type;
+            if (schema.type === 'integer') {
+                jsType = 'number';
+            }
         }
         else if (schema instanceof SchemaEnum) {
             if (schemas.containsKey(schema.name)) {

package/dist/property.js

@@ -1,6 +1,7 @@
-import { Collection, none, option } from 'scats';
+import { Collection, Nil, none, option, some } from 'scats';
+import { SchemaFactory } from './schemas.js';
 import { NameUtils } from './name.utils.js';
-const SCHEMA_PREFIX = '#/components/schemas/';
+export const SCHEMA_PREFIX = '#/components/schemas/';
 export class Property {
     constructor(name, type, format, description, defaultValue, nullable, required, items, referencesObject, itemReferencesObject, enumValues) {
         this.name = name;
@@ -30,8 +31,7 @@ export class Property {
         const itemReferencesObject = option(definition.items)
             .flatMap(i => option(i.$ref))
             .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
-        const type = option(definition.$ref)
-            .map(ref => ref.substring(SCHEMA_PREFIX.length))
+        const type = option(definition.$ref).map(ref => ref.substring(SCHEMA_PREFIX.length))
             .orElse(() => option(definition.allOf)
             .map(x => Collection.from(x))
             .filter(x => x.nonEmpty)
@@ -52,9 +52,20 @@ export class Property {
                 .filter(t => t.type !== 'null')
                 .flatMapOption(oneOfItem => option(oneOfItem.$ref)
                 .map(ref => ref.substring(SCHEMA_PREFIX.length))
-                .orElseValue(option(oneOfItem.type))).mkString(' | ');
+                .orElseValue(option(oneOfItem.type)))
+                .map(tpe => this.toJsType(tpe))
+                .mkString(' | ');
         }))
-            .getOrElseValue(definition.type);
+            .orElse(() => {
+            if (SchemaFactory.isEmptyObjectOrArray(definition)) {
+                return some('object');
+            }
+            else {
+                return none;
+            }
+        })
+            .orElse(() => option(definition.type))
+            .getOrElseValue('any');
         const nullable = option(definition.nullable).contains(true) ||
             (referencesObject && options.referencedObjectsNullableByDefault && !option(definition.nullable).contains(false)) ||
             option(definition.anyOf)
@@ -99,29 +110,40 @@ export class Property {
         return this.type === 'array';
     }
     static toJsType(tpe, itemTpe = 'any', format = none) {
-        switch (tpe) {
-            case 'boolean':
-                return 'boolean';
-            case 'number':
-                return 'number';
-            case 'integer':
-                return 'number';
-            case 'file':
-                return 'File';
-            case 'any':
-                return 'any';
-            case 'string':
-                if (format.contains('binary')) {
-                    return 'Blob | Buffer';
-                }
-                else {
-                    return 'string';
-                }
-            case 'array':
-                return `ReadonlyArray<${Property.toJsType(itemTpe)}>`;
-            default:
-                return NameUtils.normaliseClassname(tpe);
-        }
+        return option(tpe)
+            .map(x => Collection.from(x.split('|')))
+            .getOrElseValue(Nil)
+            .map(x => x.trim())
+            .map(t => {
+            switch (t) {
+                case 'boolean':
+                    return 'boolean';
+                case 'number':
+                    return 'number';
+                case 'integer':
+                    return 'number';
+                case 'Object':
+                case 'object':
+                    return 'object';
+                case 'file':
+                    return 'File';
+                case 'any':
+                    return 'any';
+                case 'String':
+                case 'string':
+                    if (format.contains('binary')) {
+                        return 'Blob | Buffer';
+                    }
+                    else {
+                        return 'string';
+                    }
+                case 'array':
+                    return `ReadonlyArray<${Property.toJsType(itemTpe)}>`;
+                default:
+                    return NameUtils.normaliseClassname(tpe);
+            }
+        })
+            .distinct.mkString(' | ');
     }
     get normalType() {
         return NameUtils.normaliseClassname(this.type);

package/dist/schemas.js

@@ -1,9 +1,19 @@
-import { Collection, Nil, option } from 'scats';
-import { Property } from './property.js';
+import { Collection, HashMap, HashSet, Nil, option } from 'scats';
+import { Property, SCHEMA_PREFIX } from './property.js';
 import { NameUtils } from './name.utils.js';
 export class SchemaFactory {
+    static isEmptyObjectOrArray(x) {
+        if (Array.isArray(x) && x.length === 0)
+            return true;
+        if (typeof x === 'object' && Object.keys(x).length === 0)
+            return true;
+        return false;
+    }
     static resolveSchemaType(def) {
-        if (def.type === 'object' || option(def.properties).exists(p => Object.keys(p).length > 0)) {
+        if (def.type === 'object' ||
+            option(def.properties).exists(p => Object.keys(p).length > 0) ||
+            option(def.allOf).exists(x => x.length > 0) ||
+            SchemaFactory.isEmptyObjectOrArray(def)) {
             return 'object';
         }
         else if (def.enum) {
@@ -14,8 +24,10 @@ export class SchemaFactory {
         }
     }
     static build(name, def, schemasTypes, options) {
-        if (def.type === 'object' || option(def.properties).exists(p => Object.keys(p).length > 0)) {
-            return SchemaObject.fromDefinition(name, def, schemasTypes, options);
+        if (def.type === 'object' ||
+            option(def.properties).exists(p => Object.keys(p).length > 0) ||
+            schemasTypes.get(name).contains('object')) {
+            return SchemaObject.fromDefinition(name, def, schemasTypes, options, HashMap.empty);
         }
         else if (def.enum) {
             return SchemaEnum.fromDefinition(name, def);
@@ -72,23 +84,70 @@ export class SchemaEnum {
     }
 }
 export class SchemaObject {
-    constructor(name, title, type, properties) {
+    constructor(name, title, type, properties, parents, explicitlyRequiredProperties) {
         this.name = name;
         this.title = title;
         this.type = type;
         this.properties = properties;
+        this.parents = parents;
+        this.explicitlyRequiredProperties = explicitlyRequiredProperties;
         this.schemaType = 'object';
     }
-    static fromDefinition(name, def, schemasTypes, options) {
+    get parentsString() {
+        return this.parents.nonEmpty ? ' extends ' + this.parents.keySet.map(n => NameUtils.normaliseClassname(n)).mkString(', ') : '';
+    }
+    propsIncludingInherited() {
+        const pendingParents = this.parents.values.toArray;
+        const props = this.properties.toBuffer;
+        const propNames = props.map(p => p.name).toSet.toMutable;
+        while (pendingParents.length > 0) {
+            const parent = pendingParents.shift();
+            props.appendAll(parent.properties.filter(parentProp => !propNames.contains(parentProp.name)));
+            parent.parents.values.foreach(pp => pendingParents.push(pp));
+        }
+        return props.toCollection;
+    }
+    static allSuperClassDefined(def, schemasTypes, pool) {
+        const parents = option(def.allOf)
+            .orElse(() => option(def['$ref']).map(x => [{ $ref: x }]))
+            .map(x => Collection.from(x))
+            .filter(x => x.nonEmpty)
+            .getOrElseValue(Nil)
+            .flatMapOption(x => option(x['$ref']))
+            .map(x => x.substring(SCHEMA_PREFIX.length))
+            .filter(p => schemasTypes.get(p).contains('object'))
+            .toSet;
+        return parents.removedAll(pool).isEmpty;
+    }
+    static fromDefinition(name, def, schemasTypes, options, pool) {
+        const allOff = option(def.allOf)
+            .orElse(() => option(def['$ref']).map(x => [{ $ref: x }]))
+            .map(x => Collection.from(x)).filter(x => x.nonEmpty);
+        const parents = allOff.getOrElseValue(Nil)
+            .flatMapOption(x => option(x['$ref']))
+            .map(x => x.substring(SCHEMA_PREFIX.length))
+            .filter(p => schemasTypes.get(p).contains('object'));
         const explicitlyRequired = option(def.required)
-            .map(arr => typeof arr === 'boolean' ? Nil : Collection.from(arr));
-        const properties = Collection.from(Object.keys(def.properties)).map(propName => {
-            const property = Property.fromDefinition(propName, def.properties[propName], schemasTypes, options);
-            return property.copy({
-                required: explicitlyRequired.exists(c => c.contains(propName)) ? true : property.required
+            .map(arr => typeof arr === 'boolean' ? Nil : Collection.from(arr))
+            .getOrElseValue(Nil)
+            .appendedAll(parents.flatMap(p => pool.get(p)
+            .map(o => o.explicitlyRequiredProperties)
+            .getOrElseValue(HashSet.empty)
+            .toCollection))
+            .toSet;
+        const properties = allOff.getOrElseValue(Collection.of(def))
+            .flatMap(subSchema => {
+            return option(subSchema['properties'])
+                .map(props => Collection.from(Object.keys(props)))
+                .getOrElseValue(Nil)
+                .map(propName => {
+                const property = Property.fromDefinition(propName, subSchema['properties'][propName], schemasTypes, options);
+                return property.copy({
+                    required: explicitlyRequired.contains(propName) ? true : property.required
+                });
             });
         });
-        return new SchemaObject(name, def.title, def.type, properties);
+        return new SchemaObject(name, def.title, def.type, properties, parents.toMap(p => [p, pool.get(p).get]), explicitlyRequired);
     }
     get normalName() {
         return NameUtils.normaliseClassname(this.name);

package/dist/templates/scats-schema.ejs

@@ -2,7 +2,7 @@
 export class <%= schema.normalName %>Dto {
 
     /**
-    <%_ schema.properties.foreach(p => { -%>
+    <%_ schema.propsIncludingInherited().foreach(p => { -%>
      * @param <%= p.name %> <%- p.description.getOrElseValue('') %>
     <%_ }); -%>
      */

package/dist/templates/schema.ejs

@@ -1,5 +1,5 @@
 <%_ if (schema.schemaType === 'object') { -%>
-export interface <%= schema.normalName %> {
+export interface <%= schema.normalName %><%= schema.parentsString%> {
     <%_ schema.properties.foreach(p => { -%>
     <%_ p.description.foreach(d => { -%>
     /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@penkov/swagger-code-gen",
-  "version": "1.8.9",
+  "version": "1.9.0",
   "type": "module",
   "bin": {
     "generate-client": "./dist/cli.mjs"