add generateCustom function

Author: mb21

README.md

@@ -1,5 +1,16 @@
 # OpenAPI Typescript Codegen
 
+Fork ([diff](https://github.com/ferdikoomen/openapi-typescript-codegen/compare/master...mb21:openapi-typescript-codegen:generate-custom))
+which exports a `generateCustom` function that can be used like:
+
+```js
+require('openapi-typescript-codegen').generateCustom('api.yaml', 'outputDir/', 'serviceTemplate.hbs')
+```
+
+To release a new version, run `npm run release` and push everything, including the `dist/index.js` file to GitHub.
+
+---
+
 [![NPM][npm-image]][npm-url]
 [![License][license-image]][license-url]
 [![Coverage][coverage-image]][coverage-url]

src/generateCustom.ts

@@ -0,0 +1,88 @@
+import { mkdir, readFile, remove } from 'fs-extra';
+import Handlebars from 'handlebars';
+import { resolve } from 'path';
+
+import { HttpClient } from './HttpClient';
+import { Indent } from './Indent';
+import { parse as parseV3 } from './openApi/v3';
+import { writeFile } from './utils/fileSystem';
+import { formatCode } from './utils/formatCode';
+import { formatIndentation } from './utils/formatIndentation';
+import { getOpenApiSpec } from './utils/getOpenApiSpec';
+import { postProcessClient } from './utils/postProcessClient';
+import { registerHandlebarTemplates } from './utils/registerHandlebarTemplates';
+import { writeClient } from './utils/writeClient';
+
+export const generateCustom = async (inputPath?: string, outputPath?: string, templatePath?: string) => {
+    if (!inputPath) throw Error('No inputPath provided');
+    if (!outputPath) throw Error('No outputPath provided');
+    if (!templatePath) throw Error('No templatePath provided');
+
+    const httpClient = HttpClient.FETCH;
+    const useUnionTypes = true;
+    const useOptions = false;
+    const exportCore = true;
+    const exportServices = false;
+    const exportModels = true;
+    const exportSchemas = false;
+    const indent = Indent.SPACE_2;
+    const postfix = 'Service';
+
+    // Generate core, models (this is mostly copied from index.ts):
+
+    const openApi = await getOpenApiSpec(inputPath);
+    const templates = registerHandlebarTemplates({
+        httpClient,
+        useUnionTypes,
+        useOptions,
+    });
+
+    const client = parseV3(openApi);
+    const clientFinal = postProcessClient(client);
+
+    await writeClient(
+        clientFinal,
+        templates,
+        outputPath,
+        httpClient,
+        useOptions,
+        useUnionTypes,
+        exportCore,
+        exportServices,
+        exportModels,
+        exportSchemas,
+        indent,
+        postfix
+    );
+
+    // Generate services (this is custom):
+
+    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 serviceTemplate = Handlebars.compile(await readFile(templatePath, 'utf8'));
+
+    const servicesDir = resolve(outputPath, 'services');
+    await remove(servicesDir);
+    await mkdir(servicesDir);
+
+    for (const service of clientFinal.services) {
+        const file = resolve(outputPath, `services/${service.name}${postfix}.ts`);
+        const templateResult = serviceTemplate({
+            ...service,
+            serviceBaseUrl: clientFinal.server,
+            httpClient,
+            useUnionTypes,
+            useOptions,
+            postfix,
+        });
+        await writeFile(file, formatIndentation(formatCode(templateResult), indent));
+    }
+};

src/index.ts

@@ -9,6 +9,7 @@ import { postProcessClient } from './utils/postProcessClient';
 import { registerHandlebarTemplates } from './utils/registerHandlebarTemplates';
 import { writeClient } from './utils/writeClient';
 
+export { generateCustom } from './generateCustom';
 export { HttpClient } from './HttpClient';
 export { Indent } from './Indent';
 

src/utils/registerHandlebarHelpers.ts

@@ -1,5 +1,5 @@
 import camelCase from 'camelcase';
-import Handlebars from 'handlebars/runtime';
+import HandlebarsRuntime from 'handlebars/runtime';
 import { EOL } from 'os';
 
 import type { Enum } from '../client/interfaces/Enum';
@@ -11,7 +11,10 @@ export const registerHandlebarHelpers = (root: {
     httpClient: HttpClient;
     useOptions: boolean;
     useUnionTypes: boolean;
+    handlebars?: typeof HandlebarsRuntime;
 }): void => {
+    const Handlebars = root.handlebars || HandlebarsRuntime;
+
     Handlebars.registerHelper('ifdef', function (this: any, ...args): string {
         const options = args.pop();
         if (!args.every(value => !value)) {

src/utils/registerHandlebarTemplates.ts

@@ -1,4 +1,4 @@
-import Handlebars from 'handlebars/runtime';
+import HandlebarsRuntime from 'handlebars/runtime';
 
 import { HttpClient } from '../HttpClient';
 import templateClient from '../templates/client.hbs';
@@ -113,7 +113,10 @@ export const registerHandlebarTemplates = (root: {
     httpClient: HttpClient;
     useOptions: boolean;
     useUnionTypes: boolean;
+    handlebars?: typeof HandlebarsRuntime;
 }): Templates => {
+    const Handlebars = root.handlebars || HandlebarsRuntime;
+
     registerHandlebarHelpers(root);
 
     // Main templates (entry points for the files we write to disk)