@penkov/swagger-code-gen 1.7.10 → 1.8.0

package/dist/method.js

@@ -2,6 +2,7 @@ import { Collection, HashMap, HashSet, identity, Nil, option } from 'scats';
 import { Property } from './property.js';
 import { Parameter } from './parameter.js';
 import { SchemaFactory } from './schemas.js';
+import { NameUtils } from './name.utils.js';
 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 class Method {
@@ -89,7 +90,7 @@ export class Method {
         this.wrapParamsInObject = this.parameters.size > 2 || (this.body.nonEmpty) && this.parameters.nonEmpty;
     }
     get endpointName() {
-        return this.operationId.getOrElse(() => `${this.method}${Method.pathToName(this.path)}`);
+        return NameUtils.normaliseMethodName(this.operationId.getOrElse(() => `${this.method}${Method.pathToName(this.path)}`));
     }
     get pathWithSubstitutions() {
         const paramPrefix = `${this.wrapParamsInObject ? 'params.' : ''}`;

package/dist/name.utils.js

@@ -0,0 +1,28 @@
+export class NameUtils {
+    static normaliseClassname(n) {
+        let res = '';
+        let needUpperCase = true;
+        for (let i = 0; i < n.length; i++) {
+            const c = n[i];
+            if (c === '.' || c === '-') {
+                needUpperCase = true;
+            }
+            else if (needUpperCase) {
+                res += c.toUpperCase();
+                needUpperCase = false;
+            }
+            else {
+                res += c;
+            }
+        }
+        return res;
+    }
+    static normaliseMethodName(n) {
+        if (n === 'delete') {
+            return `$${n}`;
+        }
+        else {
+            return n;
+        }
+    }
+}

package/dist/property.js

@@ -1,4 +1,5 @@
 import { Collection, none, option } from 'scats';
+import { NameUtils } from './name.utils.js';
 const SCHEMA_PREFIX = '#/components/schemas/';
 export class Property {
     constructor(name, type, format, description, defaultValue, nullable, required, items, referencesObject, itemReferencesObject, enumValues) {
@@ -32,6 +33,12 @@ export class Property {
             .map(x => x.flatMapOption(oneOfItem => option(oneOfItem.$ref)
             .map(ref => ref.substring(SCHEMA_PREFIX.length))
             .orElseValue(option(oneOfItem.type))).mkString(' & ')))
+            .orElse(() => option(definition.oneOf)
+            .map(x => Collection.from(x))
+            .filter(x => x.nonEmpty)
+            .map(x => x.flatMapOption(oneOfItem => option(oneOfItem.$ref)
+            .map(ref => ref.substring(SCHEMA_PREFIX.length))
+            .orElseValue(option(oneOfItem.type))).mkString(' | ')))
             .orElse(() => option(definition.anyOf)
             .map(x => Collection.from(x))
             .filter(x => x.nonEmpty)
@@ -90,6 +97,7 @@ export class Property {
         switch (tpe) {
             case 'integer': return 'number';
             case 'file': return 'File';
+            case 'any': return 'any';
             case 'string':
                 if (format.contains('binary')) {
                     return 'Blob | Buffer';
@@ -98,7 +106,7 @@ export class Property {
                     return 'string';
                 }
             case 'array': return `ReadonlyArray<${Property.toJsType(itemTpe)}>`;
-            default: return tpe;
+            default: return NameUtils.normaliseClassname(tpe);
         }
     }
     get itemScatsWrapperType() {

package/dist/schemas.js

@@ -1,5 +1,6 @@
 import { Collection, Nil, option } from 'scats';
 import { Property } from './property.js';
+import { NameUtils } from './name.utils.js';
 export class SchemaFactory {
     static resolveSchemaType(def) {
         if (def.type === 'object') {
@@ -13,7 +14,7 @@ export class SchemaFactory {
         }
     }
     static build(name, def, schemasTypes, options) {
-        if (def.type === 'object') {
+        if (def.type === 'object' || option(def.properties).exists(p => Object.keys(p).length > 0)) {
             return SchemaObject.fromDefinition(name, def, schemasTypes, options);
         }
         else if (def.enum) {
@@ -88,4 +89,7 @@ export class SchemaObject {
         });
         return new SchemaObject(name, def.title, def.type, properties);
     }
+    get normalName() {
+        return NameUtils.normaliseClassname(this.name);
+    }
 }

package/dist/templates/scats-schema.ejs

@@ -1,5 +1,5 @@
 <%_ if (schema.schemaType === 'object') { -%>
-export class <%= schema.name %>Dto {
+export class <%= schema.normalName %>Dto {
 
     constructor(
         <%_ schema.properties.foreach(p => { -%>
@@ -8,8 +8,8 @@ export class <%= schema.name %>Dto {
     ) {}
 
 
-    static fromJson(json: <%= schema.name %>): <%= schema.name %>Dto {
-        return new <%= schema.name %>Dto(
+    static fromJson(json: <%= schema.normalName %>): <%= schema.normalName %>Dto {
+        return new <%= schema.normalName %>Dto(
             <%_ schema.properties.foreach(p => { _%>
             <%_ if (p.referencesObject) { _%>
             <%_ if (p.required && !p.nullable) { _%>
@@ -29,15 +29,15 @@ export class <%= schema.name %>Dto {
         );
     }
 
-    copy(fields: Partial<<%= schema.name %>Dto>): <%= schema.name %>Dto {
-        return new <%= schema.name %>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 %>),
         <%_ });  -%>
         );
     }
 
-    get toJson(): <%= schema.name %> {
+    get toJson(): <%= schema.normalName %> {
         return {
             <%_ schema.properties.foreach(p => { _%>
             <%_ if (p.referencesObject) { _%>

package/dist/templates/schema.ejs

@@ -1,11 +1,11 @@
 <%_ if (schema.schemaType === 'object') { -%>
-export interface <%= schema.name %> {
+export interface <%= schema.normalName %> {
     <%_ schema.properties.foreach(p => { -%>
     readonly <%= p.name %><%= !p.required ? '?' : '' %>: <%- p.jsType %>;
     <%_ }); -%>
 }
 <%_ } if (schema.schemaType === 'enum') { -%>
-export enum <%= schema.name %> {
+export enum <%= schema.normalName %> {
     <%_ schema.values.foreach(p => { -%>
     <%= p %> = '<%= p %>',
     <%_ }); -%>

package/package.json

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