@penkov/swagger-code-gen 1.7.11 → 1.8.1

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) {
@@ -18,12 +19,12 @@ export class 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));
     }
-    static fromDefinition(name, definition, schemas, options) {
+    static fromDefinition(name, definition, schemaTypes, options) {
         const referencesObject = option(definition.$ref)
-            .exists(ref => schemas.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
+            .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
         const itemReferencesObject = option(definition.items)
             .flatMap(i => option(i.$ref))
-            .exists(ref => schemas.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
+            .exists(ref => schemaTypes.get(ref.substring(SCHEMA_PREFIX.length)).contains('object'));
         const type = option(definition.$ref)
             .map(ref => ref.substring(SCHEMA_PREFIX.length))
             .orElse(() => option(definition.allOf)
@@ -96,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';
@@ -104,13 +106,17 @@ export class Property {
                     return 'string';
                 }
             case 'array': return `ReadonlyArray<${Property.toJsType(itemTpe)}>`;
-            default: return tpe;
+            default: return NameUtils.normaliseClassname(tpe);
         }
     }
+    get normalType() {
+        return NameUtils.normaliseClassname(this.type);
+    }
     get itemScatsWrapperType() {
         if (this.isArray) {
             if (this.itemReferencesObject) {
-                return `${this.items}Dto`;
+                const cls = NameUtils.normaliseClassname(this.items);
+                return `${cls}Dto`;
             }
             else {
                 return Property.toJsType(this.items);
@@ -122,11 +128,13 @@ export class Property {
     }
     get scatsWrapperType() {
         if (this.referencesObject) {
-            return !this.nullable && this.required ? `${this.type}Dto` : `Option<${this.type}Dto>`;
+            const cls = NameUtils.normaliseClassname(this.type);
+            return !this.nullable && this.required ? `${cls}Dto` : `Option<${cls}Dto>`;
         }
         else if (this.isArray) {
             if (this.itemReferencesObject) {
-                return `Collection<${this.items}Dto>`;
+                const cls = NameUtils.normaliseClassname(this.items);
+                return `Collection<${cls}Dto>`;
             }
             else {
                 return `Collection<${Property.toJsType(this.items)}>`;

package/dist/schemas.js

@@ -1,8 +1,9 @@
 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') {
+        if (def.type === 'object' || option(def.properties).exists(p => Object.keys(p).length > 0)) {
             return 'object';
         }
         else if (def.enum) {
@@ -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,14 +8,14 @@ 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) { _%>
             <%- p.scatsWrapperType %>.fromJson(json.<%= p.name %>),
             <%_ } else { _%>
-            option(json.<%= p.name %>).map(_ => <%- p.type %>Dto.fromJson(_)),
+            option(json.<%= p.name %>).map(_ => <%- p.normalType %>Dto.fromJson(_)),
             <%_ } _%>
             <%_ } else if (p.isArray) { _%>
             Collection.from(option(json.<%= p.name %>).getOrElseValue([]))
@@ -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.11",
+  "version": "1.8.1",
   "type": "module",
   "bin": {
     "generate-client": "./dist/cli.mjs"