Merge pull request #14 from ProtocolNebula/feature/3-custom-templates

Feature/3 custom templates
Feature/6 custom types mapping
Feature/7 multi language support natively (through templates)

Author: ProtocolNebula

Readme.md

@@ -33,7 +33,7 @@ Is recommended to add a script to your `package.json` or package manager that yo
 > Change `src/generatedApi` by your desired folder to generate the code.
 
 ```bash
-transform-swagger -f URI/TO/SWAGGER/JSON/OR/YAML -o src/generatedApi/
+transform-swagger -f URI/TO/SWAGGER/JSON/OR/YAML -o src/generatedApi/ -t angular2
 ```
 
 ### Main CLI commands
@@ -42,17 +42,19 @@ transform-swagger -f URI/TO/SWAGGER/JSON/OR/YAML -o src/generatedApi/
 Usage: transform-swagger [options]
 
 Options:
-  --version            Show version number                             [boolean]
+  --version, -v        Show version number                         [boolean]
   --clean              No clean the output-folder, so old files will remain
-                                                       [boolean] [default: true]
-  -f, --file           Path OR URL to the swagger document to parse   [required]
+                                                   [boolean] [default: true]
+  -f, --file           Path OR URL to the swagger document to parse
+                                                                  [required]
   -o, --output-folder  Specify the output folder (generated folders will be
-                       replaced)                             [default: "output"]
-  -h, --help           Show help                                       [boolean]
+                       replaced)                         [default: "output"]
+  -t, --template       Template (preset) name or path to a template
+  -h, --help           Show help                                   [boolean]
 
 Examples:
-  transform-swagger -f swagger.js  Convert a Swagger JSON file to
-                                   compatible-angular API
+  transform-swagger -f swagger.js -o      Convert a Swagger JSON file to
+  api/ -t angular2                        compatible-angular API
 ```
 
 ## Development
@@ -71,6 +73,6 @@ npm run start:dev -- -f URL_TO_SWAGGER.JSON/YAML
 > You can re-use the downloaded file or specify another folder
 
 ```
-npm run start:dev -- -f output/temp.json
+npm run start:dev -- -f output/temp.json -o src/generatedApi/ -t angular2
 ```
 

changelog.md

@@ -6,6 +6,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+### Added
+- Issue #3 - Custom templates: Now you can create a custom template and use it without modify the source code.
+- Issue #6 - Custom enums mapping: As part of a template, enums are configurable.
+- Issue #7 - Default templates support. Now current template is named `angular2`, so you must to add `-t angular2` to you `cli script`
+```bash
+transform-swagger -f ...json -o src/generatedApi/ -t angular2
+```
+- `ConfigModel` class
+- `TemplateConfigModel` class
+
+### Changed
+- Output folders now are retrieved from ConfigModel.
+- Now `template` is required as parameter.
+- Default type added.
+- `Yargs` (arguments) are not read directly, are parsed to `ConfigModel`.
 
 ## [2.1.3] - 2021-01-05
 

src/main.ts

@@ -1,5 +1,5 @@
 import * as fs from 'fs-extra';
-import * as path from 'path';
+import { config } from './models/config.model';
 import { argumentsInstance } from './services/arguments.service';
 import { FileReaderService } from './services/parsers/file-reader.service';
 import { APIParserService } from './services/parsers/open-api-v3/api-parser.service';
@@ -8,36 +8,34 @@ import { ApiWritterService } from './services/writters/api-writter.service';
 import { ModelWritterService } from './services/writters/model-writter.service';
 import { Store } from './stores/entities.store';
 
-// FOLDERS INFORMATION
-const OUTPUT_PATH = argumentsInstance.outputFolder + path.sep;
+config.parseYargs(argumentsInstance);
 
-const GENERATED_FOLDER = OUTPUT_PATH + 'generated' + path.sep;
-const OUTPUT_FOLDERS = {
-  OUTPUT_PATH: OUTPUT_PATH,
-  BASE_FOLDER: GENERATED_FOLDER,
-  MODELS: GENERATED_FOLDER + 'models',
-  APIS: GENERATED_FOLDER + 'api',
-};
+// FOLDERS INFORMATION
 console.info('Output folders:');
-console.table(OUTPUT_FOLDERS);
-
-console.log('');
-if (argumentsInstance.clean) {
-  console.log('Removing previously generated data...');
-  fs.removeSync(GENERATED_FOLDER);
-} else {
-  console.log('no-clean flag recevived, clean folder skipped');
-}
-console.log('');
+console.table({
+  OUTPUT_PATH: config.outputPath,
+  BASE_FOLDER: config.exportPath,
+  MODELS: config.exportPath,
+  APIS: config.exportPath,
+});
 
 // Read the file
 async function run() {
   try {
+    // Check if the template does not exist
+    config.templatePath;
+
+    console.log('');
+    if (argumentsInstance.clean) {
+      console.log('Removing previously generated data...');
+      fs.removeSync(config.exportPath);
+    } else {
+      console.log('no-clean flag recevived, clean folder skipped');
+    }
+    console.log('');
+
     console.log('Opening file:', argumentsInstance.file);
-    const fileParser = new FileReaderService(
-      argumentsInstance.file,
-      OUTPUT_FOLDERS,
-    );
+    const fileParser = new FileReaderService(argumentsInstance.file, config);
     console.log('Parsing file...');
     console.log('');
     const documentParsed = await fileParser.readFile();
@@ -51,9 +49,9 @@ async function run() {
 
     console.info('');
     console.info('Generating files');
-    const modelWritter = new ModelWritterService(OUTPUT_FOLDERS, Store);
+    const modelWritter = new ModelWritterService(Store, config);
     modelWritter.write();
-    const apiWritter = new ApiWritterService(OUTPUT_FOLDERS, Store);
+    const apiWritter = new ApiWritterService(Store, config);
     apiWritter.write();
     console.info('Files generation finished');
 

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

@@ -0,0 +1,90 @@
+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 {
+  private _outputPath: string;
+  private _outputBaseFolder: string = 'generated';
+  private _outputModelsFolder: string = 'models';
+  private _outputApisFolder: string = 'apis';
+
+  private _template: string;
+  private _templatePath: string;
+  private _templateConfig: TemplateConfigModel;
+
+  get outputPath(): string {
+    return this._outputPath;
+  }
+
+  get exportPath(): string {
+    return pathResolve(this.outputPath, this._outputBaseFolder);
+  }
+
+  get outputModelsPath(): string {
+    return pathResolve(this.exportPath, this._outputModelsFolder);
+  }
+
+  get outputApisPath(): string {
+    return pathResolve(this.exportPath, this._outputApisFolder);
+  }
+
+  get template(): string {
+    if (!this._template) {
+      throw 'No template defined';
+    }
+    return this._template;
+  }
+
+  set template(template: string) {
+    this._template = template;
+    this._templatePath = null;
+    this._templateConfig = null;
+  }
+
+  get templatePath(): string {
+    if (!this._templatePath) {
+      // Generate the template path
+      const template = this.template;
+      if (existsSync(template)) {
+        this._templatePath = template;
+      } else {
+        this._templatePath = pathResolve(
+          __dirname,
+          '..',
+          '..',
+          'templates',
+          template,
+        );
+      }
+    }
+
+    if (!existsSync(this._templatePath)) {
+      throw `Template ${this.template} not exist`;
+    }
+    return this._templatePath;
+  }
+
+  get templateConfig(): TemplateConfigModel {
+    if (!this._templateConfig) {
+      this._templateConfig = new TemplateConfigModel(pathResolve(this.templatePath, 'config'));
+    }
+    return this._templateConfig;
+  }
+
+  constructor() {}
+
+  parseYargs(yargs): void {
+    this._outputPath = yargs.outputFolder;
+    this.template = yargs.template;
+  }
+}
+
+export const config = new ConfigModel();

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/arguments.service.ts

@@ -5,15 +5,20 @@ export const argumentsInstance = yargs
   .usage('Usage: $0 [options]')
   // .command('count', 'Count the lines in a file')
   .example(
-    '$0 -f swagger.js',
+    '$0 -f swagger.js -o api/ -t angular2',
     'Convert a Swagger JSON file to compatible-angular API',
   )
-  .alias('f', 'file')
   .nargs('file', 1)
+  .alias('f', 'file')
   .describe('file', 'Path OR URL to the swagger document to parse')
   .demandOption(['file'])
   .alias('o', 'output-folder')
   .nargs('output-folder', 1)
+  .nargs('template', 1)
+  .alias('t', 'template')
+  .describe('template', 'Template (preset) name or path to a template')
+  .implies('file', 'output-folder')
+  .implies('file', 'template')
   .describe(
     'output-folder',
     'Specify the output folder (generated folders will be replaced)',
@@ -24,4 +29,5 @@ export const argumentsInstance = yargs
   .default('clean', true)
   .help('help')
   .alias('h', 'help')
-  .epilog('copyright 2020').argv;
+  .epilog('For more info visit: https://github.com/ProtocolNebula/ts-openapi-generator/')
+  .argv;

src/services/parsers/file-reader.service.ts

@@ -1,4 +1,5 @@
 import { OpenAPIV3 } from 'openapi-types';
+import { config, ConfigI } from '../../models/config.model';
 import {
   downloadFile,
   fileExtension,
@@ -25,7 +26,7 @@ export class FileReaderService {
     return this._document;
   }
 
-  constructor(private path, private outputFolders: any) {}
+  constructor(private path, private configuration: ConfigI = config) {}
 
   async readFile(): Promise<OpenAPIV3.Document> {
     await this.prepareFile();
@@ -60,7 +61,7 @@ export class FileReaderService {
     }
 
     if (isURL(this.path)) {
-      this.localFilePath = `${this.outputFolders.OUTPUT_PATH}temp.${extension}`;
+      this.localFilePath = `${this.configuration.outputPath}temp.${extension}`;
       console.log(`${this.path} will be saved as ${this.localFilePath}...`);
       await downloadFile(this.path, this.localFilePath);
       console.log(`${this.localFilePath} saved!`);

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';
       }
     }
   }