add options for custom templates

Author: josh-hemphill

bin/index.js

@@ -19,11 +19,15 @@ const params = program
     .option('--exportCore <value>', 'Write core files to disk', true)
     .option('--exportServices <value>', 'Write services to disk', true)
     .option('--exportModels <value>', 'Write models to disk', true)
+    .option('--exportClient <value>', 'Write main Client file to disk', true)
+    .option('--exportIndex <value>', 'Write Index to disk', true)
     .option('--exportSchemas <value>', 'Write schemas to disk', false)
     .option('--indent <value>', 'Indentation options [4, 2, tabs]', '4')
     .option('--postfix <value>', 'Service name postfix', 'Service')
     .option('--request <value>', 'Path to custom request file')
     .option('--serviceTemplate <value>', 'Path to custom service handlebars template to generate the service files')
+    .option('--clientTemplate <value>', 'Path to custom client handlebars template to generate the client file')
+    .option('--indexTemplate <value>', 'Path to custom index handlebars template to generate the index file')
     .parse(process.argv)
     .opts();
 
@@ -40,11 +44,15 @@ if (OpenAPI) {
         exportCore: JSON.parse(params.exportCore) === true,
         exportServices: JSON.parse(params.exportServices) === true,
         exportModels: JSON.parse(params.exportModels) === true,
+        exportClient: JSON.parse(params.exportClient) === true,
+        exportIndex: JSON.parse(params.exportIndex) === true,
         exportSchemas: JSON.parse(params.exportSchemas) === true,
         indent: params.indent,
         postfix: params.postfix,
         request: params.request,
         serviceTemplate: params.serviceTemplate,
+        clientTemplate: params.clientTemplate,
+        indexTemplate: params.indexTemplate,
     })
         .then(() => {
             process.exit(0);

src/index.ts

@@ -8,7 +8,9 @@ import { isString } from './utils/isString';
 import { postProcessClient } from './utils/postProcessClient';
 import { registerHandlebarTemplates } from './utils/registerHandlebarTemplates';
 import { writeClient } from './utils/writeClient';
-import { writeClientServicesCustomTemplate } from './utils/writeClientServicesCustomTemplate';
+import { writeClientClassCustomTemplate } from './utils/writeClientCustomTemplate/clientClass';
+import { writeClientIndexCustomTemplate } from './utils/writeClientCustomTemplate/index';
+import { writeClientServicesCustomTemplate } from './utils/writeClientCustomTemplate/services';
 
 export { HttpClient } from './HttpClient';
 export { Indent } from './Indent';
@@ -23,11 +25,15 @@ export type Options = {
     exportCore?: boolean;
     exportServices?: boolean;
     exportModels?: boolean;
+    exportClient?: boolean;
+    exportIndex?: boolean;
     exportSchemas?: boolean;
     indent?: Indent;
     postfix?: string;
     request?: string;
     serviceTemplate?: string;
+    clientTemplate?: string;
+    indexTemplate?: string;
     write?: boolean;
 };
 
@@ -60,11 +66,15 @@ export const generate = async ({
     exportCore = true,
     exportServices = true,
     exportModels = true,
+    exportClient = true,
+    exportIndex = true,
     exportSchemas = false,
     indent = Indent.SPACE_4,
     postfix = 'Service',
     request,
     serviceTemplate,
+    clientTemplate,
+    indexTemplate,
     write = true,
 }: Options): Promise<void> => {
     const openApi = isString(input) ? await getOpenApiSpec(input) : input;
@@ -75,9 +85,9 @@ export const generate = async ({
         useOptions,
     });
 
-    if (serviceTemplate) {
-        exportServices = false;
-    }
+    if (serviceTemplate) exportServices = false;
+    if (clientTemplate) exportClient = false;
+    if (indexTemplate) exportIndex = false;
 
     let clientFinal;
     switch (openApiVersion) {
@@ -95,6 +105,8 @@ export const generate = async ({
                 exportCore,
                 exportServices,
                 exportModels,
+                exportClient,
+                exportIndex,
                 exportSchemas,
                 indent,
                 postfix,
@@ -118,6 +130,8 @@ export const generate = async ({
                 exportCore,
                 exportServices,
                 exportModels,
+                exportClient,
+                exportIndex,
                 exportSchemas,
                 indent,
                 postfix,
@@ -137,7 +151,40 @@ export const generate = async ({
             useUnionTypes,
             indent,
             postfix,
-            serviceTemplate
+            serviceTemplate,
+            exportClient,
+            clientName
+        );
+    }
+    if (clientTemplate) {
+        await writeClientClassCustomTemplate(
+            clientFinal,
+            output,
+            httpClient,
+            useOptions,
+            useUnionTypes,
+            indent,
+            postfix,
+            clientTemplate,
+            clientName
+        );
+    }
+    if (indexTemplate) {
+        await writeClientIndexCustomTemplate(
+            clientFinal,
+            output,
+            httpClient,
+            useOptions,
+            useUnionTypes,
+            indent,
+            postfix,
+            indexTemplate,
+            exportCore,
+            exportServices,
+            exportModels,
+            exportSchemas,
+            exportClient,
+            clientName
         );
     }
 };

src/utils/writeClient.ts

@@ -42,6 +42,8 @@ export const writeClient = async (
     exportCore: boolean,
     exportServices: boolean,
     exportModels: boolean,
+    exportClient: boolean,
+    exportIndex: boolean,
     exportSchemas: boolean,
     indent: Indent,
     postfix: string,
@@ -92,12 +94,12 @@ export const writeClient = async (
         await writeClientModels(client.models, templates, outputPathModels, httpClient, useUnionTypes, indent);
     }
 
-    if (isDefined(clientName)) {
+    if (isDefined(clientName) && exportClient) {
         await mkdir(outputPath);
         await writeClientClass(client, templates, outputPath, httpClient, clientName, indent, postfix);
     }
 
-    if (exportCore || exportServices || exportSchemas || exportModels) {
+    if ((exportCore || exportServices || exportSchemas || exportModels) && exportIndex) {
         await mkdir(outputPath);
         await writeClientIndex(
             client,

src/utils/writeClientCustomTemplate/clientClass.ts

@@ -0,0 +1,55 @@
+import { mkdir, readFile, remove } from 'fs-extra';
+import Handlebars from 'handlebars';
+import { resolve } from 'path';
+
+import { Client } from '../../client/interfaces/Client';
+import { HttpClient } from '../../HttpClient';
+import { Indent } from '../../Indent';
+import { writeFile } from '../fileSystem';
+import { formatCode as f } from '../formatCode';
+import { formatIndentation as i } from '../formatIndentation';
+import { getHttpRequestName } from '../getHttpRequestName.js';
+import { registerHandlebarTemplates } from '../registerHandlebarTemplates';
+import { sortModelsByName } from '../sortModelsByName.js';
+import { sortServicesByName } from '../sortServicesByName.js';
+
+export const writeClientClassCustomTemplate = async (
+    client: Client,
+    outputPath: string,
+    httpClient: HttpClient,
+    useOptions: boolean,
+    useUnionTypes: boolean,
+    indent: Indent,
+    postfix: string,
+    templatePath: string,
+    clientName?: string
+) => {
+    registerHandlebarTemplates({
+        httpClient,
+        useUnionTypes,
+        useOptions,
+        handlebars: Handlebars, // since we're not using precompiled templates, we need a different object here
+    });
+    Handlebars.registerHelper('capitalize', str => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    });
+
+    const clientClassTemplate = Handlebars.compile(await readFile(templatePath, 'utf8'));
+
+    const clientClassDir = resolve(outputPath, 'clientClass');
+    await remove(clientClassDir);
+    await mkdir(clientClassDir);
+
+    const templateResult = clientClassTemplate({
+        clientName,
+        httpClient,
+        postfix,
+        server: client.server,
+        version: client.version,
+        models: sortModelsByName(client.models),
+        services: sortServicesByName(client.services),
+        httpRequest: getHttpRequestName(httpClient),
+    });
+
+    await writeFile(resolve(outputPath, `${clientName}.ts`), i(f(templateResult), indent));
+};

src/utils/writeClientCustomTemplate/index.ts

@@ -0,0 +1,64 @@
+import { mkdir, readFile, remove } from 'fs-extra';
+import Handlebars from 'handlebars';
+import { resolve } from 'path';
+
+import { Client } from '../../client/interfaces/Client';
+import { HttpClient } from '../../HttpClient';
+import { Indent } from '../../Indent';
+import { writeFile } from '../fileSystem';
+import { formatCode as f } from '../formatCode';
+import { formatIndentation as i } from '../formatIndentation';
+import { isDefined } from '../isDefined.js';
+import { registerHandlebarTemplates } from '../registerHandlebarTemplates';
+import { sortModelsByName } from '../sortModelsByName.js';
+import { sortServicesByName } from '../sortServicesByName.js';
+
+export const writeClientIndexCustomTemplate = async (
+    client: Client,
+    outputPath: string,
+    httpClient: HttpClient,
+    useOptions: boolean,
+    useUnionTypes: boolean,
+    indent: Indent,
+    postfix: string,
+    templatePath: string,
+    exportCore: boolean,
+    exportServices: boolean,
+    exportModels: boolean,
+    exportSchemas: boolean,
+    exportClient: boolean,
+    clientName?: string
+) => {
+    registerHandlebarTemplates({
+        httpClient,
+        useUnionTypes,
+        useOptions,
+        handlebars: Handlebars, // since we're not using precompiled templates, we need a different object here
+    });
+    Handlebars.registerHelper('capitalize', str => {
+        return str.charAt(0).toUpperCase() + str.slice(1);
+    });
+
+    const indexTemplate = Handlebars.compile(await readFile(templatePath, 'utf8'));
+
+    const dir = resolve(outputPath);
+    await remove(dir);
+    await mkdir(dir);
+
+    const templateResult = indexTemplate({
+        serviceBaseUrl: client.server,
+        exportCore,
+        exportServices,
+        exportModels,
+        exportSchemas,
+        useUnionTypes,
+        postfix,
+        clientName,
+        server: client.server,
+        version: client.version,
+        models: sortModelsByName(client.models),
+        services: sortServicesByName(client.services),
+        exportClient: isDefined(clientName) && exportClient,
+    });
+    await writeFile(resolve(outputPath, 'index.ts'), i(f(templateResult), indent));
+};

src/utils/writeClientServicesCustomTemplate.ts renamed to src/utils/writeClientCustomTemplate/services.ts

@@ -2,13 +2,14 @@ import { mkdir, readFile, remove } from 'fs-extra';
 import Handlebars from 'handlebars';
 import { resolve } from 'path';
 
-import { Client } from '../client/interfaces/Client';
-import { HttpClient } from '../HttpClient';
-import { Indent } from '../Indent';
-import { writeFile } from './fileSystem';
-import { formatCode } from './formatCode';
-import { formatIndentation } from './formatIndentation';
-import { registerHandlebarTemplates } from './registerHandlebarTemplates';
+import { Client } from '../../client/interfaces/Client';
+import { HttpClient } from '../../HttpClient';
+import { Indent } from '../../Indent';
+import { writeFile } from '../fileSystem';
+import { formatCode as f } from '../formatCode';
+import { formatIndentation as i } from '../formatIndentation';
+import { isDefined } from '../isDefined.js';
+import { registerHandlebarTemplates } from '../registerHandlebarTemplates';
 
 export const writeClientServicesCustomTemplate = async (
     client: Client,
@@ -18,7 +19,9 @@ export const writeClientServicesCustomTemplate = async (
     useUnionTypes: boolean,
     indent: Indent,
     postfix: string,
-    templatePath: string
+    templatePath: string,
+    exportClient: boolean,
+    clientName?: string
 ) => {
     registerHandlebarTemplates({
         httpClient,
@@ -45,7 +48,8 @@ export const writeClientServicesCustomTemplate = async (
             useUnionTypes,
             useOptions,
             postfix,
+            exportClient: isDefined(clientName) && exportClient,
         });
-        await writeFile(file, formatIndentation(formatCode(templateResult), indent));
+        await writeFile(file, i(f(templateResult), indent));
     }
 };