Changes for types and templates:

- TemplateConfigModel added
- Template config is readed and mapped to templateConfigModel
- Types mapping now are readed from template/config.json
- Fixs default and empty types

Author: ProtocolNebula

src/models/api.model.ts

@@ -1,4 +1,5 @@
 import { camel, capital } from 'case';
+import { getFixedTypeName } from '../utils/models.util';
 import { ModelStore } from '../stores/model.store';
 import { ApiURLModel } from './api-url.model';
 import { PhysycalFile } from './entities';
@@ -58,7 +59,7 @@ export class ApiModel implements PhysycalFile {
     return this.requestBody?.type;
   }
   get responseType(): string {
-    return this.response?.type || 'void';
+    return this.response?.type || getFixedTypeName('empty');
   }
 
   get verb(): string {

src/models/config.model.ts

@@ -1,11 +1,13 @@
 import { existsSync } from 'fs';
 import { resolve as pathResolve } from 'path';
+import { TemplateConfigModel } from './template-config.model';
 
 export interface ConfigI {
   outputPath: string;
   exportPath: string;
   outputModelsPath: string;
   outputApisPath: string;
+  templateConfig: TemplateConfigModel;
 }
 
 class ConfigModel implements ConfigI {
@@ -16,6 +18,7 @@ class ConfigModel implements ConfigI {
 
   private _template: string;
   private _templatePath: string;
+  private _templateConfig: TemplateConfigModel;
 
   get outputPath(): string {
     return this._outputPath;
@@ -43,6 +46,7 @@ class ConfigModel implements ConfigI {
   set template(template: string) {
     this._template = template;
     this._templatePath = null;
+    this._templateConfig = null;
   }
 
   get templatePath(): string {
@@ -68,6 +72,13 @@ class ConfigModel implements ConfigI {
     return this._templatePath;
   }
 
+  get templateConfig(): TemplateConfigModel {
+    if (!this._templateConfig) {
+      this._templateConfig = new TemplateConfigModel(pathResolve(this.templatePath, 'config'));
+    }
+    return this._templateConfig;
+  }
+
   constructor() {}
 
   parseYargs(yargs): void {

src/models/template-config.model.ts

@@ -0,0 +1,61 @@
+import { fileExtension } from "../utils/files.util";
+
+export interface TypesMapped {
+  /**
+   * Type if NO TYPE (literally nothing)
+   */
+  empty: string;
+
+  [type: string]: string;
+  default: string;
+  boolean: string;
+  file: string;
+  integer: string;
+  number: string;
+  object: string;
+  string: string;
+}
+
+export interface TemplateConfigI {
+  // Template files
+  apiFile: string;
+  modelFile: string;
+  enumModelFile: string;
+
+  /**
+   * Types mapping from 'OpenAPI' to the language template
+   * `default` will be used as default type (if not defined/not in the list)
+   */
+  typesMapped: TypesMapped;
+}
+
+export class TemplateConfigModel implements TemplateConfigI {
+  private configMapped: TemplateConfigI;
+
+  get apiFile(): string {
+    return this.configMapped.apiFile;
+  }
+  get apiExtension(): string {
+    return fileExtension(this.configMapped.apiFile);
+  }
+  get modelFile(): string {
+    return this.configMapped.modelFile;
+  }
+  get modelExtension(): string {
+    return fileExtension(this.configMapped.modelFile);
+  }
+  get enumModelFile(): string {
+    return this.configMapped.enumModelFile;
+  }
+  get enumModelExtension(): string {
+    return fileExtension(this.configMapped.enumModelFile);
+  }
+
+  get typesMapped(): TypesMapped {
+    return this.configMapped.typesMapped;
+  }
+
+  constructor(templatePath: string) {
+    this.configMapped = require(templatePath);
+  }
+}

src/services/parsers/open-api-v3/parser-base.service.ts

@@ -125,7 +125,7 @@ export abstract class ParserBaseService {
       console.warn('WARNING: No schema defined! Any will be use instead');
       console.warn('TIP: Don\'t fill "content" for responses if void');
       const instance = new ModelAttributessModel(null);
-      instance.typeURI = 'any';
+      instance.typeURI = 'default';
       return instance;
     }
     if (this.isRefObject(schema)) {
@@ -227,9 +227,9 @@ export abstract class ParserBaseService {
         console.warn(
           `WARNING: ${attrName} not recognized OpenAPIV3 Schema type ${JSON.stringify(
             rawAttribute,
-          )}. Any will be used instead.`,
+          )}. DEFAULT will be used instead.`,
         );
-        attribute.typeURI = 'any';
+        attribute.typeURI = 'default';
       }
     }
   }

src/services/writters/api-writter.service.ts

@@ -12,8 +12,7 @@ import { generateFileSync, getTemplate, makeDir } from '../../utils/files.util';
 export class ApiWritterService {
   private mustacheTemplate;
 
-  private template = 'api.ts';
-  private exportExtension = 'ts';
+  private exportExtension;
 
   constructor(private store: StoreI, private configuration: ConfigI = config) {}
 
@@ -40,8 +39,9 @@ export class ApiWritterService {
   }
 
   private prepareMustacheInstance(): void {
-    this.mustacheTemplate = getTemplate(this.template);
+    this.mustacheTemplate = getTemplate(this.configuration.templateConfig.apiFile);
     mustache.parse(this.mustacheTemplate);
+    this.exportExtension = this.configuration.templateConfig.apiExtension;
   }
 
   private getGeneratedTemplate(groupName: string, apis: ApiModel[]): string {

src/services/writters/model-writter.service.ts

@@ -14,9 +14,7 @@ export class ModelWritterService {
   private modelMustacheTemplate;
   private enumMustacheTemplate;
 
-  private modelTemplate = 'model.ts';
-  private enumTemplate = 'enumModel.ts';
-  private exportExtension = 'ts';
+  private exportExtension;
 
   constructor(private store: StoreI, private configuration: ConfigI = config) {}
 
@@ -40,10 +38,11 @@ export class ModelWritterService {
   }
 
   private prepareMustacheInstance(): void {
-    this.modelMustacheTemplate = getTemplate(this.modelTemplate);
+    this.modelMustacheTemplate = getTemplate(this.configuration.templateConfig.modelFile);
     mustache.parse(this.modelMustacheTemplate);
-    this.enumMustacheTemplate = getTemplate(this.enumTemplate);
+    this.enumMustacheTemplate = getTemplate(this.configuration.templateConfig.enumModelFile);
     mustache.parse(this.enumMustacheTemplate);
+    this.exportExtension = this.configuration.templateConfig.modelExtension;
   }
 
   private getGeneratedTemplate(model: ModelType): string {

src/utils/models.util.ts

@@ -1,45 +1,30 @@
 import { capital } from 'case';
 import { ApiModel } from '../models/api.model';
+import { config } from '../models/config.model';
 import { PhysycalFile } from '../models/entities';
 import { Store } from '../stores/entities.store';
 
 export function getFixedTypeName(type: string): string {
-  let parsedTypes = {
-    '': 'any',
-    any: 'any',
-    array: 'any[]',
-    bool: 'boolean',
-    boolean: 'boolean',
-    double: 'number',
-    empty: 'void',
-    file: 'File',
-    float: 'number',
-    integer: 'number',
-    number: 'number',
-    object: 'any',
-    string: 'string',
-    undefined: 'any',
-    void: 'void',
-  };
+  const typesMapped = config.templateConfig.typesMapped;
 
-  let newType = parsedTypes[type];
+  let newType = typesMapped[type];
   if (newType !== undefined) {
     if (newType !== type) {
       console.debug('Type', type, 'changed to', newType);
     }
-    return parsedTypes[type];
+    return typesMapped[type];
   }
 
   if (type.indexOf('#/') === 0) {
     if (Store.models.getByUri(type)) {
       newType = type.substring(type.lastIndexOf('/') + 1);
     } else {
-      newType = 'any';
-      console.error('ERROR: Type', type, 'not defined. Any will be used.');
+      newType = typesMapped.default;
+      console.error(`ERROR: Type ${type}, not defined. ${newType} will be used.`);
     }
   } else {
-    newType = 'any';
-    console.warn('WARNING: Type', type, 'not defined. Any will be used.');
+    newType = typesMapped.default;
+    console.warn(`WARNING: Type ${type}, not defined. ${newType} will be used.`);
   }
 
   return newType;