@penkov/swagger-code-gen 1.9.0 → 1.9.2

package/dist/components-parse.js

@@ -1,11 +1,13 @@
-import { Collection, mutable, option } from 'scats';
+import { Collection, mutable, Nil, 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));
-    const sharedBodies = Collection.from(Object.keys(json.components.requestBodies))
+    const sharedBodies = option(json?.components?.requestBodies)
+        .map(x => Collection.from(Object.keys(x)))
+        .getOrElseValue(Nil)
         .toMap(name => {
         const sharedBodyDef = json.components.requestBodies[name];
         const mimeTypes = Collection.from(Object.keys(sharedBodyDef['content']));
@@ -23,7 +25,9 @@ export function resolveSchemasTypes(json) {
 export function resolveSchemas(json, 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))
+        .appendedAll(option(json?.components?.requestBodies)
+        .map(x => Collection.from(Object.keys(x)))
+        .getOrElseValue(Nil)
         .filter(rb => option(json.components.requestBodies[rb]['content']).isDefined)
         .toMap(rb => {
         const sharedBodyDef = json.components.requestBodies[rb];
@@ -85,7 +89,8 @@ export function resolvePaths(json, schemasTypes, options, pool) {
     });
 }
 export function generateInPlace(paths, schemasTypes, options, pool) {
-    return paths.filter(m => option(m.response.inPlace).isDefined)
+    const res = new mutable.ArrayBuffer();
+    res.appendAll(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)
@@ -93,5 +98,14 @@ export function generateInPlace(paths, schemasTypes, options, pool) {
         .map(m => {
         console.log(`Generating inplace body: ${m.inPlaceClassname}`);
         return SchemaObject.fromDefinition(m.inPlaceClassname, m.inPlace, schemasTypes, options, pool);
-    }));
+    })));
+    let pending = res.toCollection.flatMap(s => s.properties).filter(p => p.inPlace.isDefined);
+    while (pending.nonEmpty) {
+        const pass2 = pending.map(p => {
+            return SchemaObject.fromDefinition(p.type, p.inPlace.get, schemasTypes, options, pool);
+        });
+        res.appendAll(pass2);
+        pending = pass2.flatMap(s => s.properties).filter(p => p.inPlace.isDefined);
+    }
+    return res.reverse;
 }

package/dist/method.js

@@ -76,7 +76,7 @@ export class Method {
                 let res;
                 let inPlaceClassname = null;
                 if (SchemaFactory.isEmptyObjectOrArray(bodySchemaDef)) {
-                    res = Property.fromDefinition('body', {
+                    res = Property.fromDefinition('', 'body', {
                         ...bodySchemaDef,
                         required: bodyRequired,
                         type: 'object'
@@ -84,21 +84,21 @@ export class Method {
                 }
                 else if (bodySchemaDef['$ref']) {
                     const ref = bodySchemaDef['$ref'].toString();
-                    res = Property.fromDefinition('body', {
+                    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', {
+                    res = Property.fromDefinition('', 'body', {
                         type: bodySchemaDef['type'],
                         required: bodyRequired
                     }, schemasTypes, options);
                 }
                 else {
                     inPlaceClassname = NameUtils.normaliseClassname(def.operationId + 'Body$' + method);
-                    res = Property.fromDefinition('body', {
+                    res = Property.fromDefinition(inPlaceClassname, 'body', {
                         ...bodySchemaDef,
                         $ref: SCHEMA_PREFIX + inPlaceClassname
                     }, schemasTypes.appended(inPlaceClassname, 'object'), options);
@@ -138,7 +138,7 @@ export class Method {
             .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('', {
+                const r = Property.fromDefinition(inPlaceObject, '', {
                     ...p.schema,
                     $ref: SCHEMA_PREFIX + inPlaceObject
                 }, schemasTypes.appended(inPlaceObject, 'object'), options).copy({
@@ -153,7 +153,7 @@ export class Method {
                 };
             }
             else {
-                const r = Property.fromDefinition('', p.schema, schemasTypes, options).copy({
+                const r = Property.fromDefinition('', '', p.schema, schemasTypes, options).copy({
                     nullable: false,
                     required: true,
                 });
@@ -165,7 +165,7 @@ export class Method {
             }
         })
             .getOrElseValue(({
-            asProperty: Property.fromDefinition('UNKNOWN', { type: 'any' }, schemasTypes, options),
+            asProperty: Property.fromDefinition('', 'UNKNOWN', { type: 'any' }, schemasTypes, options),
             responseType: 'any',
         }));
         this.wrapParamsInObject = this.parameters.size > 2 || (this.body.nonEmpty) && this.parameters.nonEmpty;

package/dist/parameter.js

@@ -23,7 +23,7 @@ export class Parameter {
         let defaultValue = none;
         const schema = def.schema ?
             SchemaFactory.build(def.name, def.schema, schemas, options) :
-            Property.fromDefinition(name, {
+            Property.fromDefinition('', name, {
                 ...def,
                 type: def['type'],
                 required: option(def.required).filter(x => typeof x === 'boolean')

package/dist/property.js

@@ -3,7 +3,7 @@ import { SchemaFactory } from './schemas.js';
 import { NameUtils } from './name.utils.js';
 export const SCHEMA_PREFIX = '#/components/schemas/';
 export class Property {
-    constructor(name, type, format, description, defaultValue, nullable, required, items, referencesObject, itemReferencesObject, enumValues) {
+    constructor(name, type, format, description, defaultValue, nullable, required, items, referencesObject, itemReferencesObject, enumValues, inPlace) {
         this.name = name;
         this.type = type;
         this.format = format;
@@ -15,12 +15,13 @@ export class Property {
         this.referencesObject = referencesObject;
         this.itemReferencesObject = itemReferencesObject;
         this.enumValues = enumValues;
+        this.inPlace = inPlace;
         this.schemaType = 'property';
     }
     copy(p) {
-        return new Property(option(p.name).getOrElseValue(this.name), option(p.type).getOrElseValue(this.type), option(p.format).getOrElseValue(this.format), option(p.description).getOrElseValue(this.description), option(p.defaultValue).getOrElseValue(this.defaultValue), option(p.nullable).getOrElseValue(this.nullable), option(p.required).getOrElseValue(this.required), option(p.items).getOrElseValue(this.items), option(p.referencesObject).getOrElseValue(this.referencesObject), option(p.itemReferencesObject).getOrElseValue(this.itemReferencesObject), option(p.enumValues).getOrElseValue(this.enumValues));
+        return new Property(option(p.name).getOrElseValue(this.name), option(p.type).getOrElseValue(this.type), option(p.format).getOrElseValue(this.format), option(p.description).getOrElseValue(this.description), option(p.defaultValue).getOrElseValue(this.defaultValue), option(p.nullable).getOrElseValue(this.nullable), option(p.required).getOrElseValue(this.required), option(p.items).getOrElseValue(this.items), option(p.referencesObject).getOrElseValue(this.referencesObject), option(p.itemReferencesObject).getOrElseValue(this.itemReferencesObject), option(p.enumValues).getOrElseValue(this.enumValues), option(p.inPlace).getOrElseValue(this.inPlace));
     }
-    static fromDefinition(name, definition, schemaTypes, options) {
+    static fromDefinition(parentClassname, name, definition, schemaTypes, options) {
         const referencesObject = option(definition.$ref)
             .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object')) ||
             option(definition.allOf)
@@ -31,7 +32,17 @@ export class Property {
         const itemReferencesObject = option(definition.items)
             .flatMap(i => option(i.$ref))
             .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
+        let inplace = none;
         const type = option(definition.$ref).map(ref => ref.substring(SCHEMA_PREFIX.length))
+            .orElse(() => {
+            if (definition.type === 'object' && option(definition.properties).map(p => Object.keys(p).length).getOrElseValue(0) > 0) {
+                inplace = some(definition);
+                return some(parentClassname + '$' + name);
+            }
+            else {
+                return none;
+            }
+        })
             .orElse(() => option(definition.allOf)
             .map(x => Collection.from(x))
             .filter(x => x.nonEmpty)
@@ -85,7 +96,7 @@ export class Property {
             .orElseValue(option(oneOfItem.type))).mkString(' | ')))
             .getOrElseValue('any');
         const enumValues = option(definition.enum).map(x => Collection.from(x));
-        return new Property(name, type, option(definition.format), description, null, nullable, required, items, referencesObject, itemReferencesObject, enumValues);
+        return new Property(name, type, option(definition.format), description, null, nullable, required, items, referencesObject, itemReferencesObject, enumValues, inplace);
     }
     get jsType() {
         let res = Property.toJsType(this.type, this.items, this.format);

package/dist/schemas.js

@@ -33,35 +33,35 @@ export class SchemaFactory {
             return SchemaEnum.fromDefinition(name, def);
         }
         else if (def.type === 'string') {
-            return Property.fromDefinition(name, {
+            return Property.fromDefinition('', name, {
                 ...def,
                 required: option(def.required).filter(x => typeof x === 'boolean')
                     .map(x => x).orUndefined
             }, schemasTypes, options);
         }
         else if (def.type === 'boolean') {
-            return Property.fromDefinition(name, {
+            return Property.fromDefinition('', name, {
                 ...def,
                 required: option(def.required).filter(x => typeof x === 'boolean')
                     .map(x => x).orUndefined
             }, schemasTypes, options);
         }
         else if (def.type === 'integer') {
-            return Property.fromDefinition(name, {
+            return Property.fromDefinition('', name, {
                 ...def,
                 required: option(def.required).filter(x => typeof x === 'boolean')
                     .map(x => x).orUndefined
             }, schemasTypes, options);
         }
         else if (def.type === 'array') {
-            return Property.fromDefinition(name, {
+            return Property.fromDefinition('', name, {
                 ...def,
                 required: option(def.required).filter(x => typeof x === 'boolean')
                     .map(x => x).orUndefined
             }, schemasTypes, options);
         }
         else {
-            return Property.fromDefinition(name, {
+            return Property.fromDefinition('', name, {
                 ...def,
                 required: option(def.required).filter(x => typeof x === 'boolean')
                     .map(x => x).orUndefined
@@ -141,7 +141,7 @@ export class SchemaObject {
                 .map(props => Collection.from(Object.keys(props)))
                 .getOrElseValue(Nil)
                 .map(propName => {
-                const property = Property.fromDefinition(propName, subSchema['properties'][propName], schemasTypes, options);
+                const property = Property.fromDefinition(name, propName, subSchema['properties'][propName], schemasTypes, options);
                 return property.copy({
                     required: explicitlyRequired.contains(propName) ? true : property.required
                 });

package/package.json

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