Config model + template path:

- Added config model
- Model is instantiated as Singleton
- Yargs is parsed to config, so yargs is not used directly anymore
- Added argument to specify the template or template path

Author: ProtocolNebula

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,23 +8,21 @@ 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.table({
+  OUTPUT_PATH: config.outputPath,
+  BASE_FOLDER: config.exportPath,
+  MODELS: config.exportPath,
+  APIS: config.exportPath,
+});
 
 console.log('');
 if (argumentsInstance.clean) {
   console.log('Removing previously generated data...');
-  fs.removeSync(GENERATED_FOLDER);
+  fs.removeSync(config.exportPath);
 } else {
   console.log('no-clean flag recevived, clean folder skipped');
 }
@@ -34,10 +32,7 @@ console.log('');
 async function run() {
   try {
     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 +46,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/config.model.ts

@@ -0,0 +1,79 @@
+import { existsSync } from 'fs';
+import { resolve as pathResolve } from 'path';
+
+export interface ConfigI {
+  outputPath: string;
+  exportPath: string;
+  outputModelsPath: string;
+  outputApisPath: string;
+}
+
+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;
+
+  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;
+  }
+
+  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;
+  }
+
+  constructor() {}
+
+  parseYargs(yargs): void {
+    this._outputPath = yargs.outputFolder;
+    this.template = yargs.template;
+  }
+}
+
+export const config = new ConfigModel();

src/services/arguments.service.ts

@@ -8,13 +8,17 @@ export const argumentsInstance = yargs
     '$0 -f swagger.js',
     '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)',

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/writters/api-writter.service.ts

@@ -1,6 +1,7 @@
 import * as mustache from 'mustache';
 import { resolve as pathResolve } from 'path';
-import { ApiModel } from 'src/models/api.model';
+import { ApiModel } from '../../models/api.model';
+import { config, ConfigI } from '../../models/config.model';
 import { StoreI } from '../../stores/entities.store';
 import { generateFileSync, getTemplate, makeDir } from '../../utils/files.util';
 
@@ -14,12 +15,12 @@ export class ApiWritterService {
   private template = 'api.ts';
   private exportExtension = 'ts';
 
-  constructor(private outputFolders: any, private store: StoreI) {}
+  constructor(private store: StoreI, private configuration: ConfigI = config) {}
 
   write(): void {
     this.prepareMustacheInstance();
     console.group('Generating api files');
-    const folder = this.outputFolders.APIS;
+    const folder = this.configuration.outputApisPath;
     makeDir(folder);
 
     const groups = this.store.apis.sort().apisGrouped;

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

@@ -1,5 +1,6 @@
 import * as mustache from 'mustache';
 import { resolve as pathResolve } from 'path';
+import { config, ConfigI } from '../../models/config.model';
 import { EnumModel } from '../../models/enum.model';
 import { StoreI } from '../../stores/entities.store';
 import { ModelType } from '../../stores/model.store';
@@ -17,19 +18,19 @@ export class ModelWritterService {
   private enumTemplate = 'enumModel.ts';
   private exportExtension = 'ts';
 
-  constructor(private outputFolders: any, private store: StoreI) {}
+  constructor(private store: StoreI, private configuration: ConfigI = config) {}
 
   write(): void {
     this.prepareMustacheInstance();
     console.group('Generating model files');
-    makeDir(this.outputFolders.MODELS);
+    makeDir(this.configuration.outputModelsPath);
 
     for (const model of this.store.models.models) {
       const exportFileName = `${model.fileName}.${this.exportExtension}`;
       console.info(model.name, '->', exportFileName);
       console.group();
       generateFileSync(
-        pathResolve(this.outputFolders.MODELS, exportFileName),
+        pathResolve(this.configuration.outputModelsPath, exportFileName),
         this.getGeneratedTemplate(model),
       );
       console.groupEnd();

src/utils/files.util.ts

@@ -1,8 +1,9 @@
-import { createWriteStream, readFileSync, writeFileSync } from 'fs';
+import { createWriteStream, readdirSync, readFileSync, writeFileSync } from 'fs';
 import * as http from 'http';
 import * as yaml from 'js-yaml';
 import { mkdirSync } from 'mkdir-recursive';
 import { basename, dirname, extname, resolve as pathResolve } from 'path';
+import { config } from '../models/config.model';
 
 const getExtensionRegex = /(\.[a-z0-9]+).*/i;
 
@@ -38,7 +39,7 @@ export async function downloadFile(url, dest): Promise<string> {
 }
 
 export function getTemplate(templateFile) {
-  const fullPath = pathResolve(__dirname, '..', '..', 'templates', templateFile);
+  const fullPath = pathResolve(config.templatePath, templateFile);
   return readFileSync(fullPath, 'utf-8');
 }