Add an "injected" HTTP client option

If this option is used, services will be exported as uninstantiated
classes that accept a method that will handle HTTP requests. The
request.ts file will not be generated as it would be unecessary.

Author: iansan5653

src/index.ts

@@ -11,6 +11,7 @@ export enum HttpClient {
     FETCH = 'fetch',
     XHR = 'xhr',
     NODE = 'node',
+    INJECTED = 'injected'
 }
 
 export type Options = {

src/templates/index.hbs

@@ -1,11 +1,13 @@
 {{>header}}
 {{#if @root.exportServices}}
 {{#if services}}
+{{#notEquals @root.httpClient 'injected'}}
 
 {{#each services}}
 import { {{{name}}} as _{{{name}}} } from './services/{{{name}}}';
 {{/each}}
 import { request } from './core/request';
+{{/notEquals}}
 {{/if}}
 {{/if}}
 {{#if @root.exportCore}}
@@ -40,8 +42,15 @@ export { ${{{name}}} } from './schemas/${{{name}}}';
 {{#if @root.exportServices}}
 {{#if services}}
 
+{{#notEquals @root.httpClient 'injected'}}
 {{#each services}}
 export const {{{name}}} = new _{{{name}}}(request);
 {{/each}}
+{{/notEquals}}
+{{~#equals @root.httpClient 'injected'}}
+{{#each services}}
+export { {{{name}}} } from './services/{{{name}}}';
+{{/each}}
+{{/equals~}}
 {{/if}}
 {{/if}}

src/utils/writeClient.ts

@@ -72,6 +72,6 @@ export async function writeClient(
 
     if (exportCore || exportServices || exportSchemas || exportModels) {
         await mkdir(outputPath);
-        await writeClientIndex(client, templates, outputPath, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+        await writeClientIndex(client, templates, outputPath, httpClient, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
     }
 }

src/utils/writeClientCore.spec.ts

@@ -7,30 +7,34 @@ import { writeClientCore } from './writeClientCore';
 jest.mock('./fileSystem');
 
 describe('writeClientCore', () => {
-    it('should write to filesystem', async () => {
-        const client: Client = {
-            server: 'http://localhost:8080',
-            version: '1.0',
-            models: [],
-            services: [],
-        };
-
-        const templates: Templates = {
-            index: () => 'index',
-            exports: {
-                model: () => 'model',
-                schema: () => 'schema',
-                service: () => 'service',
-            },
-            core: {
-                settings: () => 'settings',
-                apiError: () => 'apiError',
-                apiRequestOptions: () => 'apiRequestOptions',
-                apiResult: () => 'apiResult',
-                request: () => 'request',
-            },
-        };
+    const client: Client = {
+        server: 'http://localhost:8080',
+        version: '1.0',
+        models: [],
+        services: [],
+    };
+
+    const templates: Templates = {
+        index: () => 'index',
+        exports: {
+            model: () => 'model',
+            schema: () => 'schema',
+            service: () => 'service',
+        },
+        core: {
+            settings: () => 'settings',
+            apiError: () => 'apiError',
+            apiRequestOptions: () => 'apiRequestOptions',
+            apiResult: () => 'apiResult',
+            request: () => 'request',
+        },
+    };
+
+    afterEach(() => {
+        jest.clearAllMocks();
+    });
 
+    it('should write to filesystem', async () => {
         await writeClientCore(client, templates, '/', HttpClient.FETCH);
 
         expect(writeFile).toBeCalledWith('/OpenAPI.ts', 'settings');
@@ -39,4 +43,14 @@ describe('writeClientCore', () => {
         expect(writeFile).toBeCalledWith('/ApiResult.ts', 'apiResult');
         expect(writeFile).toBeCalledWith('/request.ts', 'request');
     });
+
+    it('should not write request.ts if HTTP client is INJECTED', async () => {
+        await writeClientCore(client, templates, '/', HttpClient.INJECTED);
+
+        expect(writeFile).toBeCalledWith('/OpenAPI.ts', 'settings');
+        expect(writeFile).toBeCalledWith('/ApiError.ts', 'apiError');
+        expect(writeFile).toBeCalledWith('/ApiRequestOptions.ts', 'apiRequestOptions');
+        expect(writeFile).toBeCalledWith('/ApiResult.ts', 'apiResult');
+        expect(writeFile).not.toBeCalledWith('/request.ts', 'request');
+    });
 });

src/utils/writeClientCore.ts

@@ -22,5 +22,8 @@ export async function writeClientCore(client: Client, templates: Templates, outp
     await writeFile(path.resolve(outputPath, 'ApiError.ts'), templates.core.apiError({}));
     await writeFile(path.resolve(outputPath, 'ApiRequestOptions.ts'), templates.core.apiRequestOptions({}));
     await writeFile(path.resolve(outputPath, 'ApiResult.ts'), templates.core.apiResult({}));
-    await writeFile(path.resolve(outputPath, 'request.ts'), templates.core.request(context));
+
+    if (httpClient !== HttpClient.INJECTED) {
+        await writeFile(path.resolve(outputPath, 'request.ts'), templates.core.request(context));
+    }
 }

src/utils/writeClientIndex.ts

@@ -1,6 +1,7 @@
 import * as path from 'path';
 
 import type { Client } from '../client/interfaces/Client';
+import {HttpClient} from '..';
 import { writeFile } from './fileSystem';
 import { Templates } from './registerHandlebarTemplates';
 import { sortModelsByName } from './sortModelsByName';
@@ -23,6 +24,7 @@ export async function writeClientIndex(
     client: Client,
     templates: Templates,
     outputPath: string,
+    httpClient: HttpClient,
     useUnionTypes: boolean,
     exportCore: boolean,
     exportServices: boolean,
@@ -36,6 +38,7 @@ export async function writeClientIndex(
             exportServices,
             exportModels,
             exportSchemas,
+            httpClient,
             useUnionTypes,
             server: client.server,
             version: client.version,