Refactor generation options

Author: Havasjethi

bin/commands/FromSpec/generateDefaultConfig.ts

@@ -30,7 +30,8 @@ function getDefaultConfig (): StructuredOptions {
             exportCore: true,
             exportServices: true,
             exportModels: true,
-            exportSchemas: false,
+            exportSchemas: true,
+            exportControllers: true,
         },
         // write: false,
         // request: false,

src/index.ts

@@ -10,7 +10,7 @@ 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";
-import { GenerationOptions } from "./types/default";
+import { ExportOptions, ExportOptionsMight, GenerationOptions } from "./types/default";
 
 export { HttpClient } from './HttpClient';
 
@@ -23,10 +23,7 @@ export { HttpClient } from './HttpClient';
  * @param httpClient The selected httpClient (fetch or XHR)
  * @param useOptions Use options or arguments functions
  * @param useUnionTypes Use union types instead of enums
- * @param exportCore: Generate core client classes
- * @param exportServices: Generate services
- * @param exportModels: Generate models
- * @param exportSchemas: Generate schemas
+ * @param export_options
  * @param request: Path to custom request file
  * @param write Write the files to disk (true or false)
  */
@@ -36,10 +33,7 @@ export async function generate({
     httpClient = HttpClient.FETCH,
     useOptions = false,
     useUnionTypes = false,
-    exportCore = true,
-    exportServices = true,
-    exportModels = true,
-    exportSchemas = false,
+    export_options = { },
     request,
     write = true,
 }: GenerationOptions): Promise<void> {
@@ -51,10 +45,35 @@ export async function generate({
         useOptions,
     });
 
+    const defined_export_options = fixOptions(export_options);
+
     const clientFinal = getClient(openApiVersion, openApi);
     if (write) {
-        await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request);
+        await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, defined_export_options, request);
+    }
+}
+
+const fixOptions = (some: ExportOptionsMight): ExportOptions => {
+    let a = {...some};
+
+    if (a.exportCore === undefined) {
+        a.exportCore = true;
     }
+    if (a.exportServices === undefined) {
+        a.exportServices = true;
+    }
+    if (a.exportModels === undefined) {
+        a.exportModels = true;
+    }
+    if (a.exportSchemas === undefined) {
+        a.exportSchemas = true;
+    }
+    if (a.exportControllers === undefined) {
+        a.exportControllers = true;
+    }
+
+    //@ts-ignore
+    return a;
 }
 
 function getClient (openApiVersion: OpenApiVersion, openApi: OpenApiV3 | OpenApiV2): Client {

src/types/default.ts

@@ -6,10 +6,25 @@ export type GenerationOptions = {
     httpClient?: HttpClient;
     useOptions?: boolean;
     useUnionTypes?: boolean;
+    export_options?: ExportOptionsMight;
+    request?: string;
+    write?: boolean;
+};
+
+export interface ExportOptions {
+    exportCore: boolean;
+    exportServices: boolean;
+    exportModels: boolean;
+    exportSchemas: boolean;
+    exportControllers: boolean;
+}
+
+export interface ExportOptionsMight {
     exportCore?: boolean;
     exportServices?: boolean;
     exportModels?: boolean;
     exportSchemas?: boolean;
-    request?: string;
-    write?: boolean;
-};
+    exportControllers?: boolean;
+}
+
+

src/utils/common_test_files.ts

@@ -0,0 +1,19 @@
+import { Templates } from "./registerHandlebarTemplates";
+
+export const test_templates: Templates = {
+    index: () => 'index',
+    // TODO :: How to use this??
+    backend_index: () => 'backend_index',
+    exports: {
+        model: () => 'model',
+        schema: () => 'schema',
+        service: () => 'service',
+    },
+    core: {
+        settings: () => 'settings',
+        apiError: () => 'apiError',
+        apiRequestOptions: () => 'apiRequestOptions',
+        apiResult: () => 'apiResult',
+        request: () => 'request',
+    },
+};

src/utils/registerHandlebarTemplates.ts

@@ -22,6 +22,7 @@ import { register_partials, register_generic_functions, register_fetch_files, re
 
 export interface Templates {
     index: Handlebars.TemplateDelegate;
+    backend_index: Handlebars.TemplateDelegate;
     exports: {
         model: Handlebars.TemplateDelegate;
         schema: Handlebars.TemplateDelegate;
@@ -48,6 +49,7 @@ export function registerHandlebarTemplates(root: { httpClient: HttpClient; useOp
     // Main templates (entry points for the files we write to disk)
     const templates: Templates = {
         index: Handlebars.template(templateIndex),
+        backend_index: Handlebars.template(templateIndex),
         exports: {
             model: Handlebars.template(templateExportModel),
             schema: Handlebars.template(templateExportSchema),

src/utils/writeClient.spec.ts

@@ -1,8 +1,8 @@
 import type { Client } from '../client/interfaces/Client';
 import { HttpClient } from '../HttpClient';
 import { mkdir, rmdir, writeFile } from './fileSystem';
-import { Templates } from './registerHandlebarTemplates';
 import { writeClient } from './writeClient';
+import { test_templates } from "./common_test_files";
 
 jest.mock('./fileSystem');
 
@@ -15,23 +15,13 @@ describe('writeClient', () => {
             services: [],
         };
 
-        const templates: Templates = {
-            index: () => 'index',
-            exports: {
-                model: () => 'model',
-                schema: () => 'schema',
-                service: () => 'service',
-            },
-            core: {
-                settings: () => 'settings',
-                apiError: () => 'apiError',
-                apiRequestOptions: () => 'apiRequestOptions',
-                apiResult: () => 'apiResult',
-                request: () => 'request',
-            },
-        };
-
-        await writeClient(client, templates, './dist', HttpClient.FETCH, false, false, true, true, true, true);
+        await writeClient(client, test_templates, './dist', HttpClient.FETCH, false, false, {
+            exportCore: true,
+            exportServices: true,
+            exportModels: true,
+            exportSchemas: true,
+            exportControllers: false
+        });
 
         expect(rmdir).toBeCalled();
         expect(mkdir).toBeCalled();

src/utils/writeClient.ts

@@ -10,6 +10,7 @@ import { writeClientIndex } from './writeClientIndex';
 import { writeClientModels } from './writeClientModels';
 import { writeClientSchemas } from './writeClientSchemas';
 import { writeBackendControllers, writeClientServices } from './writeClientServices';
+import { ExportOptions } from "../types/default";
 
 /**
  * Write our OpenAPI client, using the given templates at the given output
@@ -19,10 +20,7 @@ import { writeBackendControllers, writeClientServices } from './writeClientServi
  * @param httpClient The selected httpClient (fetch, xhr or node)
  * @param useOptions Use options or arguments functions
  * @param useUnionTypes Use union types instead of enums
- * @param exportCore: Generate core client classes
- * @param exportServices: Generate services
- * @param exportModels: Generate models
- * @param exportSchemas: Generate schemas
+ * @param exportOptions
  * @param request: Path to custom request file
  */
 export async function writeClient(
@@ -32,10 +30,7 @@ export async function writeClient(
     httpClient: HttpClient,
     useOptions: boolean,
     useUnionTypes: boolean,
-    exportCore: boolean,
-    exportServices: boolean,
-    exportModels: boolean,
-    exportSchemas: boolean,
+    exportOptions: ExportOptions,
     request?: string
 ): Promise<void> {
     // Todo :: Configurable folder names
@@ -52,44 +47,45 @@ export async function writeClient(
         throw new Error(`Output folder is not a subdirectory of the current working directory`);
     }
 
-    if (exportCore) {
+    if (exportOptions.exportCore) {
         await rmdir(outputPathCore);
         await mkdir(outputPathCore);
         const promise = writeClientCore(client, templates, outputPathCore, httpClient, request);
         promises.push(promise);
     }
 
-    if (exportServices) {
+    if (exportOptions.exportServices) {
         await rmdir(outputPathServices);
         await mkdir(outputPathServices);
         const promise = writeClientServices(client.services, templates, outputPathServices, httpClient, useUnionTypes, useOptions);
         promises.push(promise);
     }
 
-    if (client.controllers) {
+    if (exportOptions.exportControllers && client.controllers) {
         await rmdir(output_path_controllers);
         await mkdir(output_path_controllers);
         const promise = writeBackendControllers(client.controllers, templates, output_path_controllers, httpClient, useUnionTypes, useOptions);
         promises.push(promise);
     }
 
-    if (exportSchemas) {
+    if (exportOptions.exportControllers) {
         await rmdir(outputPathSchemas);
         await mkdir(outputPathSchemas);
         const promise = writeClientSchemas(client.models, templates, outputPathSchemas, httpClient, useUnionTypes);
         promises.push(promise);
     }
 
-    if (exportModels) {
+    if (exportOptions.exportControllers) {
         await rmdir(outputPathModels);
         await mkdir(outputPathModels);
         const promise = writeClientModels(client.models, templates, outputPathModels, httpClient, useUnionTypes);
         promises.push(promise);
     }
 
-    if (exportCore || exportServices || exportSchemas || exportModels) {
+    if ( exportOptions.exportCore || exportOptions.exportServices
+         || exportOptions.exportSchemas || exportOptions.exportModels) {
         await mkdir(outputPath);
-        const promise = writeClientIndex(client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+        const promise = writeClientIndex(client, templates, outputPath, useUnionTypes, exportOptions);
         promises.push(promise);
     }
 

src/utils/writeClientCore.spec.ts

@@ -1,8 +1,8 @@
 import type { Client } from '../client/interfaces/Client';
 import { HttpClient } from '../HttpClient';
 import { writeFile } from './fileSystem';
-import { Templates } from './registerHandlebarTemplates';
 import { writeClientCore } from './writeClientCore';
+import { test_templates } from "./common_test_files";
 
 jest.mock('./fileSystem');
 
@@ -15,23 +15,7 @@ describe('writeClientCore', () => {
             services: [],
         };
 
-        const templates: Templates = {
-            index: () => 'index',
-            exports: {
-                model: () => 'model',
-                schema: () => 'schema',
-                service: () => 'service',
-            },
-            core: {
-                settings: () => 'settings',
-                apiError: () => 'apiError',
-                apiRequestOptions: () => 'apiRequestOptions',
-                apiResult: () => 'apiResult',
-                request: () => 'request',
-            },
-        };
-
-        await writeClientCore(client, templates, '/', HttpClient.FETCH);
+        await writeClientCore(client, test_templates, '/', HttpClient.FETCH);
 
         expect(writeFile).toBeCalledWith('/OpenAPI.ts', 'settings');
         expect(writeFile).toBeCalledWith('/ApiError.ts', 'apiError');

src/utils/writeClientIndex.spec.ts

@@ -1,7 +1,7 @@
 import type { Client } from '../client/interfaces/Client';
 import { writeFile } from './fileSystem';
-import { Templates } from './registerHandlebarTemplates';
 import { writeClientIndex } from './writeClientIndex';
+import { test_templates } from "./common_test_files";
 
 jest.mock('./fileSystem');
 
@@ -14,23 +14,13 @@ describe('writeClientIndex', () => {
             services: [],
         };
 
-        const templates: Templates = {
-            index: () => 'index',
-            exports: {
-                model: () => 'model',
-                schema: () => 'schema',
-                service: () => 'service',
-            },
-            core: {
-                settings: () => 'settings',
-                apiError: () => 'apiError',
-                apiRequestOptions: () => 'apiRequestOptions',
-                apiResult: () => 'apiResult',
-                request: () => 'request',
-            },
-        };
-
-        await writeClientIndex(client, templates, '/', true, true, true, true, true);
+        await writeClientIndex(client, test_templates, '/', true, {
+            exportCore: true,
+            exportServices: true,
+            exportModels: true,
+            exportSchemas: true,
+            exportControllers: false,
+        });
 
         expect(writeFile).toBeCalledWith('/index.ts', 'index');
     });