First part of changes

Author: Havasjethi

.gitignore

@@ -1,14 +1,19 @@
-node_modules
+# Package Management related stuff
+dist/
+node_modules/
+package-lock.json
+
+# IDE folder
+.idea/
+.vscode/
+
 npm-debug.log*
 yarn-debug.log*
 yarn-error.log*
 junit.xml
 .DS_Store
 .tmp
-.idea
-.vscode
 *.iml
-dist
 coverage
 test/generated
 test/e2e/generated

src/index.ts

@@ -7,6 +7,9 @@ import { isString } from './utils/isString';
 import { postProcessClient } from './utils/postProcessClient';
 import { registerHandlebarTemplates } from './utils/registerHandlebarTemplates';
 import { writeClient } from './utils/writeClient';
+import { Client } from "./client/interfaces/Client";
+import { OpenApi as OpenApiV3 } from "./openApi/v3/interfaces/OpenApi";
+import { OpenApi as OpenApiV2 } from "./openApi/v2/interfaces/OpenApi";
 
 export { HttpClient } from './HttpClient';
 
@@ -61,21 +64,25 @@ export async function generate({
         useOptions,
     });
 
+    const clientFinal = getClient(openApiVersion, openApi);
+    if (write) {
+        await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request);
+    }
+}
+
+function getClient (openApiVersion: OpenApiVersion, openApi: OpenApiV3 | OpenApiV2): Client {
+    let parsed_client = null;
+
     switch (openApiVersion) {
-        case OpenApiVersion.V2: {
-            const client = parseV2(openApi);
-            const clientFinal = postProcessClient(client);
-            if (!write) break;
-            await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request);
+        case OpenApiVersion.V2:
+        case OpenApiVersion.V3:
+            //@ts-ignore
+            parsed_client = parseV3(openApi);
             break;
-        }
 
-        case OpenApiVersion.V3: {
-            const client = parseV3(openApi);
-            const clientFinal = postProcessClient(client);
-            if (!write) break;
-            await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request);
-            break;
-        }
+        default:
+            throw new Error('Invalid API number');
     }
+
+    return postProcessClient(parsed_client);
 }

src/templates/exportController.hbs

@@ -0,0 +1 @@
+console.log('Hello world');

src/utils/registerHandlebarTemplates.ts

@@ -35,6 +35,7 @@ import xhrGetResponseBody from '../templates/core/xhr/getResponseBody.hbs';
 import xhrGetResponseHeader from '../templates/core/xhr/getResponseHeader.hbs';
 import xhrRequest from '../templates/core/xhr/request.hbs';
 import xhrSendRequest from '../templates/core/xhr/sendRequest.hbs';
+import templateExportController from '../templates/exportController.hbs';
 import templateExportModel from '../templates/exportModel.hbs';
 import templateExportSchema from '../templates/exportSchema.hbs';
 import templateExportService from '../templates/exportService.hbs';
@@ -74,6 +75,7 @@ export interface Templates {
         model: Handlebars.TemplateDelegate;
         schema: Handlebars.TemplateDelegate;
         service: Handlebars.TemplateDelegate;
+        controllers: Handlebars.TemplateDelegate;
     };
     core: {
         settings: Handlebars.TemplateDelegate;
@@ -98,6 +100,7 @@ export function registerHandlebarTemplates(root: { httpClient: HttpClient; useOp
             model: Handlebars.template(templateExportModel),
             schema: Handlebars.template(templateExportSchema),
             service: Handlebars.template(templateExportService),
+            controllers: Handlebars.template(templateExportController),
         },
         core: {
             settings: Handlebars.template(templateCoreSettings),
@@ -108,6 +111,16 @@ export function registerHandlebarTemplates(root: { httpClient: HttpClient; useOp
         },
     };
 
+    d();
+    c();
+    b();
+    a();
+    register_node_client();
+
+    return templates;
+}
+
+function d( ) {
     // Partials for the generations of the models, services, etc.
     Handlebars.registerPartial('exportEnum', Handlebars.template(partialExportEnum));
     Handlebars.registerPartial('exportInterface', Handlebars.template(partialExportInterface));
@@ -136,7 +149,9 @@ export function registerHandlebarTemplates(root: { httpClient: HttpClient; useOp
     Handlebars.registerPartial('typeUnion', Handlebars.template(partialTypeUnion));
     Handlebars.registerPartial('typeIntersection', Handlebars.template(partialTypeIntersection));
     Handlebars.registerPartial('base', Handlebars.template(partialBase));
+}
 
+function c () {
     // Generic functions used in 'request' file @see src/templates/core/request.hbs for more info
     Handlebars.registerPartial('functions/catchErrors', Handlebars.template(functionCatchErrors));
     Handlebars.registerPartial('functions/getFormData', Handlebars.template(functionGetFormData));
@@ -149,30 +164,39 @@ export function registerHandlebarTemplates(root: { httpClient: HttpClient; useOp
     Handlebars.registerPartial('functions/isStringWithValue', Handlebars.template(functionIsStringWithValue));
     Handlebars.registerPartial('functions/isSuccess', Handlebars.template(functionIsSuccess));
     Handlebars.registerPartial('functions/resolve', Handlebars.template(functionResolve));
+}
 
+function b () {
     // Specific files for the fetch client implementation
+
     Handlebars.registerPartial('fetch/getHeaders', Handlebars.template(fetchGetHeaders));
     Handlebars.registerPartial('fetch/getRequestBody', Handlebars.template(fetchGetRequestBody));
     Handlebars.registerPartial('fetch/getResponseBody', Handlebars.template(fetchGetResponseBody));
     Handlebars.registerPartial('fetch/getResponseHeader', Handlebars.template(fetchGetResponseHeader));
     Handlebars.registerPartial('fetch/sendRequest', Handlebars.template(fetchSendRequest));
     Handlebars.registerPartial('fetch/request', Handlebars.template(fetchRequest));
 
+
+}
+
+function a () {
     // Specific files for the xhr client implementation
     Handlebars.registerPartial('xhr/getHeaders', Handlebars.template(xhrGetHeaders));
     Handlebars.registerPartial('xhr/getRequestBody', Handlebars.template(xhrGetRequestBody));
     Handlebars.registerPartial('xhr/getResponseBody', Handlebars.template(xhrGetResponseBody));
     Handlebars.registerPartial('xhr/getResponseHeader', Handlebars.template(xhrGetResponseHeader));
     Handlebars.registerPartial('xhr/sendRequest', Handlebars.template(xhrSendRequest));
     Handlebars.registerPartial('xhr/request', Handlebars.template(xhrRequest));
+}
 
-    // Specific files for the node client implementation
+/**
+ * Specific files for the node client implementation
+ */
+function register_node_client () {
     Handlebars.registerPartial('node/getHeaders', Handlebars.template(nodeGetHeaders));
     Handlebars.registerPartial('node/getRequestBody', Handlebars.template(nodeGetRequestBody));
     Handlebars.registerPartial('node/getResponseBody', Handlebars.template(nodeGetResponseBody));
     Handlebars.registerPartial('node/getResponseHeader', Handlebars.template(nodeGetResponseHeader));
     Handlebars.registerPartial('node/sendRequest', Handlebars.template(nodeSendRequest));
     Handlebars.registerPartial('node/request', Handlebars.template(nodeRequest));
-
-    return templates;
 }

src/utils/writeClient.ts

@@ -9,7 +9,7 @@ import { writeClientCore } from './writeClientCore';
 import { writeClientIndex } from './writeClientIndex';
 import { writeClientModels } from './writeClientModels';
 import { writeClientSchemas } from './writeClientSchemas';
-import { writeClientServices } from './writeClientServices';
+import { writeBackendControllers, writeClientServices } from './writeClientServices';
 
 /**
  * Write our OpenAPI client, using the given templates at the given output
@@ -38,11 +38,15 @@ export async function writeClient(
     exportSchemas: boolean,
     request?: string
 ): Promise<void> {
+    // Todo :: Configurable folder names
     const outputPath = resolve(process.cwd(), output);
     const outputPathCore = resolve(outputPath, 'core');
     const outputPathModels = resolve(outputPath, 'models');
     const outputPathSchemas = resolve(outputPath, 'schemas');
     const outputPathServices = resolve(outputPath, 'services');
+    const output_path_controllers = resolve(outputPath, 'controllers');
+
+    const promises: Promise<any>[] = [];
 
     if (!isSubDirectory(process.cwd(), output)) {
         throw new Error(`Output folder is not a subdirectory of the current working directory`);
@@ -51,29 +55,43 @@ export async function writeClient(
     if (exportCore) {
         await rmdir(outputPathCore);
         await mkdir(outputPathCore);
-        await writeClientCore(client, templates, outputPathCore, httpClient, request);
+        const promise = writeClientCore(client, templates, outputPathCore, httpClient, request);
+        promises.push(promise);
     }
 
     if (exportServices) {
         await rmdir(outputPathServices);
         await mkdir(outputPathServices);
-        await writeClientServices(client.services, templates, outputPathServices, httpClient, useUnionTypes, useOptions);
+        const promise = writeClientServices(client.services, templates, outputPathServices, httpClient, useUnionTypes, useOptions);
+        promises.push(promise);
+    }
+
+    if (true) {
+        await rmdir(output_path_controllers);
+        await mkdir(output_path_controllers);
+        const promise = writeBackendControllers(client.services, templates, output_path_controllers, httpClient, useUnionTypes, useOptions);
+        promises.push(promise);
     }
 
     if (exportSchemas) {
         await rmdir(outputPathSchemas);
         await mkdir(outputPathSchemas);
-        await writeClientSchemas(client.models, templates, outputPathSchemas, httpClient, useUnionTypes);
+        const promise = writeClientSchemas(client.models, templates, outputPathSchemas, httpClient, useUnionTypes);
+        promises.push(promise);
     }
 
     if (exportModels) {
         await rmdir(outputPathModels);
         await mkdir(outputPathModels);
-        await writeClientModels(client.models, templates, outputPathModels, httpClient, useUnionTypes);
+        const promise = writeClientModels(client.models, templates, outputPathModels, httpClient, useUnionTypes);
+        promises.push(promise);
     }
 
     if (exportCore || exportServices || exportSchemas || exportModels) {
         await mkdir(outputPath);
-        await writeClientIndex(client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+        const promise = writeClientIndex(client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+        promises.push(promise);
     }
+
+    await Promise.all(promises);
 }

src/utils/writeClientModels.ts

@@ -15,13 +15,19 @@ import { Templates } from './registerHandlebarTemplates';
  * @param useUnionTypes Use union types instead of enums
  */
 export async function writeClientModels(models: Model[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean): Promise<void> {
+    const promises: Promise<any>[] = [];
+
     for (const model of models) {
         const file = resolve(outputPath, `${model.name}.ts`);
         const templateResult = templates.exports.model({
             ...model,
             httpClient,
             useUnionTypes,
         });
-        await writeFile(file, format(templateResult));
+
+        const fileWrite = writeFile(file, format(templateResult));
+        promises.push(fileWrite);
     }
+
+    await Promise.all(promises);
 }

src/utils/writeClientServices.ts

@@ -21,6 +21,7 @@ export async function writeClientServices(services: Service[], templates: Templa
     for (const service of services) {
         const file = resolve(outputPath, `${service.name}.ts`);
         const useVersion = service.operations.some(operation => operation.path.includes(VERSION_TEMPLATE_STRING));
+
         const templateResult = templates.exports.service({
             ...service,
             httpClient,
@@ -31,3 +32,23 @@ export async function writeClientServices(services: Service[], templates: Templa
         await writeFile(file, format(templateResult));
     }
 }
+
+export async function writeBackendControllers (services: Service[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean, useOptions: boolean): Promise<void> {
+    if (templates.exports.controllers === undefined) {
+        throw new Error('Controller template is not defined!');
+    }
+
+    for (const service of services) {
+        const file = resolve(outputPath, `${service.name}.ts`);
+        const useVersion = service.operations.some(operation => operation.path.includes(VERSION_TEMPLATE_STRING));
+
+        const templateResult = templates.exports.controllers({
+            ...service,
+            httpClient,
+            useUnionTypes,
+            useVersion,
+            useOptions,
+        });
+        await writeFile(file, format(templateResult));
+    }
+}