@penkov/swagger-code-gen 1.9.5 → 1.10.0

package/dist/components-parse.js

@@ -89,16 +89,29 @@ export function resolvePaths(json, schemasTypes, options, pool) {
     });
 }
 export function generateInPlace(paths, schemasTypes, options, pool) {
+    const collectInplaceFromProperty = (p) => {
+        if (p.inPlace.isDefined) {
+            return Collection.of(SchemaObject.fromDefinition(p.items, p.inPlace.get, schemasTypes, options, pool));
+        }
+        else {
+            return Nil;
+        }
+    };
     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)
+    })
+        .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);
-    })));
+    }))
+        .appendedAll(pool.values.filter(s => s.schemaType === 'object')
+        .map(s => s)
+        .flatMap(s => s.properties)
+        .flatMap(p => collectInplaceFromProperty(p))));
     let pending = res.toCollection.flatMap(s => s.properties).filter(p => p.inPlace.isDefined);
     while (pending.nonEmpty) {
         const pass2 = pending.map(p => {

package/dist/name.utils.js

@@ -27,4 +27,7 @@ export class NameUtils {
             return n.replace(/[./]/g, '_');
         }
     }
+    static normalisePropertyName(n) {
+        return n.replace(/[.-]/g, '_');
+    }
 }

package/dist/property.js

@@ -31,7 +31,9 @@ export class Property {
                 .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
         const itemReferencesObject = option(definition.items)
             .flatMap(i => option(i.$ref))
-            .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
+            .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object')) ||
+            option(definition.items).exists(i => option(i.type).contains('object') &&
+                option(i.properties).map(p => Object.keys(p).length).getOrElseValue(0) > 0);
         let inplace = none;
         const type = option(definition.$ref).map(ref => ref.substring(SCHEMA_PREFIX.length))
             .orElse(() => {
@@ -87,6 +89,15 @@ export class Property {
         const required = option(definition.required).contains(true);
         const items = option(definition.items?.$ref)
             .map(ref => ref.substring(SCHEMA_PREFIX.length))
+            .orElse(() => {
+            if (definition.type === 'array' && option(definition.items).exists(i => i.type === 'object')) {
+                inplace = some(definition.items);
+                return some(parentClassname + '$' + name);
+            }
+            else {
+                return none;
+            }
+        })
             .orElseValue(option(definition.items?.type))
             .orElse(() => option(definition.items?.oneOf)
             .map(x => Collection.from(x))
@@ -122,7 +133,7 @@ export class Property {
     }
     static toJsType(tpe, itemTpe = 'any', format = none) {
         return option(tpe)
-            .map(x => Collection.from(x.split('|')))
+            .map(x => Array.isArray(x) ? Collection.from(x) : Collection.from(x.split('|')))
             .getOrElseValue(Nil)
             .map(x => x.trim())
             .map(t => {
@@ -141,6 +152,8 @@ export class Property {
                     return 'File';
                 case 'any':
                     return 'any';
+                case 'null':
+                    return 'null';
                 case 'String':
                 case 'string':
                     if (format.contains('binary')) {
@@ -160,6 +173,9 @@ export class Property {
     get normalType() {
         return NameUtils.normaliseClassname(this.type);
     }
+    get normalisedName() {
+        return NameUtils.normalisePropertyName(this.name);
+    }
     get itemScatsWrapperType() {
         if (this.isArray) {
             if (this.itemReferencesObject) {

package/dist/templates/scats-schema.ejs

@@ -8,7 +8,7 @@ export class <%= schema.normalName %>Dto {
      */
     constructor(
         <%_ schema.properties.foreach(p => { -%>
-        readonly <%= p.name %>: <%- p.scatsWrapperType %>,
+        readonly <%= p.normalisedName %>: <%- p.scatsWrapperType %>,
         <%_ }); -%>
     ) {}
 
@@ -18,17 +18,17 @@ export class <%= schema.normalName %>Dto {
             <%_ schema.properties.foreach(p => { _%>
             <%_ if (p.referencesObject) { _%>
             <%_ if (p.required && !p.nullable) { _%>
-            <%- p.scatsWrapperType %>.fromJson(json.<%= p.name %>),
+            <%- p.scatsWrapperType %>.fromJson(json['<%= p.name %>']),
             <%_ } else { _%>
-            option(json.<%= p.name %>).map(_ => <%- p.normalType %>Dto.fromJson(_)),
+            option(json['<%= p.name %>']).map(_ => <%- p.normalType %>Dto.fromJson(_)),
             <%_ } _%>
             <%_ } else if (p.isArray) { _%>
-            Collection.from(option(json.<%= p.name %>).getOrElseValue([]))
+            Collection.from(option(json['<%= p.name %>']).getOrElseValue([]))
                 <% if (p.itemReferencesObject) { _%>.map(i => <%- p.itemScatsWrapperType %>.fromJson(i))<%_ }  _%>,
             <%_ } else if (p.required && !p.nullable) { _%>
             json.<%= p.name %>,
             <%_ } else { _%>
-            option(json.<%= p.name %>),
+            option(json['<%= p.name %>']),
             <%_ } _%>
             <%_ }); _%>
         );
@@ -37,7 +37,7 @@ export class <%= schema.normalName %>Dto {
     copy(fields: Partial<<%= schema.normalName %>Dto>): <%= schema.normalName %>Dto {
         return new <%= schema.normalName %>Dto(
         <%_ schema.properties.foreach(p => { -%>
-            option(fields.<%= p.name %>).getOrElseValue(this.<%= p.name %>),
+            option(fields.<%= p.normalisedName %>).getOrElseValue(this.<%= p.normalisedName %>),
         <%_ });  -%>
         );
     }
@@ -47,18 +47,18 @@ export class <%= schema.normalName %>Dto {
             <%_ schema.properties.foreach(p => { _%>
             <%_ if (p.referencesObject) { _%>
             <%_ if (p.required && !p.nullable) { _%>
-            <%= p.name %>: this.<%= p.name %>.toJson,
+            '<%= p.name %>': this.<%= p.normalisedName %>.toJson,
             <%_ } else { _%>
-            <%= p.name %>: this.<%= p.name %>.map(_ => _.toJson).orUndefined,
+            '<%= p.name %>': this.<%= p.normalisedName %>.map(_ => _.toJson).orUndefined,
             <%_ } _%>
             <%_ } else if (p.isArray) { _%>
-            <%= p.name %>: this.<%= p.name %>
+            '<%= p.name %>': this.<%= p.normalisedName %>
                 <% if (p.itemReferencesObject) { _%>.map(_ => _.toJson)<%_ } _%>
                 .toArray,
             <%_ } else if (p.required && !p.nullable) { _%>
-            <%= p.name %>: this.<%= p.name %>,
+            '<%= p.name %>': this.<%= p.normalisedName %>,
             <%_ } else { _%>
-            <%= p.name %>: this.<%= p.name %>.orUndefined,
+            '<%= p.name %>': this.<%= p.normalisedName %>.orUndefined,
             <%_ } _%>
             <%_ }); _%>
         };

package/dist/templates/schema.ejs

@@ -6,7 +6,7 @@ export interface <%= schema.normalName %><%= schema.parentsString%> {
      * <%= d %>
      */
     <%_ }); -%>
-    readonly <%= p.name %><%= !p.required ? '?' : '' %>: <%- p.jsType %>;
+    readonly '<%= p.name %>'<%= !p.required ? '?' : '' %>: <%- p.jsType %>;
     <%_ }); -%>
 }
 <%_ } if (schema.schemaType === 'enum') { -%>

package/package.json

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