- Custom client changes

ferdikoomen · ferdikoomen · commit 56f9289ff118 · 2020-12-17T16:24:49.000+01:00
diff --git a/bin/index.js b/bin/index.js
@@ -12,7 +12,7 @@ program
     .version(pkg.version)
     .requiredOption('-i, --input <value>', 'OpenAPI specification, can be a path, url or string content (required)')
     .requiredOption('-o, --output <value>', 'Output directory (required)')
-    .option('-c, --client <value>', 'HTTP client to generate [fetch, xhr, node]', 'fetch')
+    .option('-c, --client <value>', 'HTTP client to generate [fetch, xhr, node] or path to custom request file', 'fetch')
     .option('--useOptions', 'Use options instead of arguments')
     .option('--useUnionTypes', 'Use union types instead of enums')
     .option('--exportCore <value>', 'Write core files to disk', true)
diff --git a/package.json b/package.json
@@ -80,6 +80,7 @@
         "@types/js-yaml": "3.12.5",
         "@types/node": "14.14.13",
         "@types/node-fetch": "2.5.7",
+        "@types/qs": "6.9.4",
         "@typescript-eslint/eslint-plugin": "4.9.1",
         "@typescript-eslint/parser": "4.9.1",
         "codecov": "3.8.1",
@@ -90,11 +91,13 @@
         "express": "4.17.1",
         "form-data": "3.0.0",
         "glob": "7.1.6",
+        "httpntlm": "1.7.6",
         "jest": "26.6.3",
         "jest-cli": "26.6.3",
         "node-fetch": "2.6.1",
         "prettier": "2.2.1",
         "puppeteer": "5.5.0",
+        "qs": "6.9.4",
         "rollup": "2.34.2",
         "rollup-plugin-terser": "7.0.2",
         "rollup-plugin-typescript2": "0.29.0",
diff --git a/src/HttpClient.ts b/src/HttpClient.ts
@@ -0,0 +1,5 @@
+export enum HttpClient {
+    FETCH = 'fetch',
+    XHR = 'xhr',
+    NODE = 'node',
+}
diff --git a/src/index.ts b/src/index.ts
@@ -1,3 +1,4 @@
+import { HttpClient } from './HttpClient';
 import { parse as parseV2 } from './openApi/v2';
 import { parse as parseV3 } from './openApi/v3';
 import { getOpenApiSpec } from './utils/getOpenApiSpec';
@@ -7,16 +8,12 @@ import { postProcessClient } from './utils/postProcessClient';
 import { registerHandlebarTemplates } from './utils/registerHandlebarTemplates';
 import { writeClient } from './utils/writeClient';
 
-export enum HttpClient {
-    FETCH = 'fetch',
-    XHR = 'xhr',
-    NODE = 'node',
-}
+export { HttpClient } from './HttpClient';
 
 export type Options = {
     input: string | Record<string, any>;
     output: string;
-    httpClient?: HttpClient;
+    httpClient?: string | HttpClient;
     useOptions?: boolean;
     useUnionTypes?: boolean;
     exportCore?: boolean;
diff --git a/src/openApi/v2/parser/getComment.spec.ts b/src/openApi/v2/parser/getComment.spec.ts
@@ -1,10 +1,10 @@
-import * as os from 'os';
+import { EOL } from 'os';
 
 import { getComment } from './getComment';
 
 describe('getComment', () => {
     it('should parse comments', () => {
-        const multiline = 'Testing multiline comments.' + os.EOL + ' * This must go to the next line.' + os.EOL + ' * ' + os.EOL + ' * This will contain a break.';
+        const multiline = 'Testing multiline comments.' + EOL + ' * This must go to the next line.' + EOL + ' * ' + EOL + ' * This will contain a break.';
         expect(getComment('')).toEqual(null);
         expect(getComment('Hello')).toEqual('Hello');
         expect(getComment('Hello World!')).toEqual('Hello World!');
diff --git a/src/openApi/v2/parser/getComment.ts b/src/openApi/v2/parser/getComment.ts
@@ -1,4 +1,4 @@
-import * as os from 'os';
+import { EOL } from 'os';
 
 /**
  * Cleanup comment and prefix multiline comments with "*",
@@ -7,7 +7,7 @@ import * as os from 'os';
  */
 export function getComment(comment?: string): string | null {
     if (comment) {
-        return comment.replace(/\r?\n(.*)/g, (_, w) => `${os.EOL} * ${w.trim()}`);
+        return comment.replace(/\r?\n(.*)/g, (_, w) => `${EOL} * ${w.trim()}`);
     }
     return null;
 }
diff --git a/src/openApi/v3/parser/getComment.spec.ts b/src/openApi/v3/parser/getComment.spec.ts
@@ -1,10 +1,10 @@
-import * as os from 'os';
+import { EOL } from 'os';
 
 import { getComment } from './getComment';
 
 describe('getComment', () => {
     it('should parse comments', () => {
-        const multiline = 'Testing multiline comments.' + os.EOL + ' * This must go to the next line.' + os.EOL + ' * ' + os.EOL + ' * This will contain a break.';
+        const multiline = 'Testing multiline comments.' + EOL + ' * This must go to the next line.' + EOL + ' * ' + EOL + ' * This will contain a break.';
         expect(getComment('')).toEqual(null);
         expect(getComment('Hello')).toEqual('Hello');
         expect(getComment('Hello World!')).toEqual('Hello World!');
diff --git a/src/openApi/v3/parser/getComment.ts b/src/openApi/v3/parser/getComment.ts
@@ -1,4 +1,4 @@
-import * as os from 'os';
+import { EOL } from 'os';
 
 /**
  * Cleanup comment and prefix multiline comments with "*",
@@ -7,7 +7,7 @@ import * as os from 'os';
  */
 export function getComment(comment?: string): string | null {
     if (comment) {
-        return comment.replace(/\r?\n(.*)/g, (_, w) => `${os.EOL} * ${w.trim()}`);
+        return comment.replace(/\r?\n(.*)/g, (_, w) => `${EOL} * ${w.trim()}`);
     }
     return null;
 }
diff --git a/src/templates/core/node/sendRequest.hbs b/src/templates/core/node/sendRequest.hbs
@@ -4,8 +4,5 @@ async function sendRequest(options: ApiRequestOptions, url: string): Promise<Res
         headers: await getHeaders(options),
         body: getRequestBody(options),
     };
-    if (OpenAPI.WITH_CREDENTIALS) {
-        request.credentials = 'include';
-    }
     return await fetch(url, request);
 }
diff --git a/src/utils/format.ts b/src/utils/format.ts
@@ -1,8 +1,8 @@
-import * as os from 'os';
+import { EOL } from 'os';
 
 export function format(s: string): string {
     let indent: number = 0;
-    let lines = s.split(os.EOL);
+    let lines = s.split(EOL);
     lines = lines.map(line => {
         line = line.trim().replace(/^\*/g, ' *');
         let i = indent;
@@ -19,5 +19,5 @@ export function format(s: string): string {
         }
         return result;
     });
-    return lines.join(os.EOL);
+    return lines.join(EOL);
 }
diff --git a/src/utils/getOpenApiSpec.ts b/src/utils/getOpenApiSpec.ts
@@ -1,5 +1,5 @@
-import * as yaml from 'js-yaml';
-import * as path from 'path';
+import { safeLoad } from 'js-yaml';
+import { extname } from 'path';
 
 import { readSpec } from './readSpec';
 
@@ -10,13 +10,13 @@ import { readSpec } from './readSpec';
  * @param input
  */
 export async function getOpenApiSpec(input: string): Promise<any> {
-    const extension = path.extname(input).toLowerCase();
+    const extension = extname(input).toLowerCase();
     const content = await readSpec(input);
     switch (extension) {
         case '.yml':
         case '.yaml':
             try {
-                return yaml.safeLoad(content);
+                return safeLoad(content);
             } catch (e) {
                 throw new Error(`Could not parse OpenApi YAML: "${input}"`);
             }
diff --git a/src/utils/isSubdirectory.spec.ts b/src/utils/isSubdirectory.spec.ts
@@ -1,15 +1,15 @@
-import * as path from 'path';
+import { resolve } from 'path';
 
 import { isSubDirectory } from './isSubdirectory';
 
 describe('isSubDirectory', () => {
     it('should return correct result', () => {
-        expect(isSubDirectory(path.resolve('/'), path.resolve('/'))).toBeFalsy();
-        expect(isSubDirectory(path.resolve('.'), path.resolve('.'))).toBeFalsy();
-        expect(isSubDirectory(path.resolve('./project'), path.resolve('./project'))).toBeFalsy();
-        expect(isSubDirectory(path.resolve('./project'), path.resolve('../'))).toBeFalsy();
-        expect(isSubDirectory(path.resolve('./project'), path.resolve('../../'))).toBeFalsy();
-        expect(isSubDirectory(path.resolve('./'), path.resolve('./output'))).toBeTruthy();
-        expect(isSubDirectory(path.resolve('./'), path.resolve('../output'))).toBeTruthy();
+        expect(isSubDirectory(resolve('/'), resolve('/'))).toBeFalsy();
+        expect(isSubDirectory(resolve('.'), resolve('.'))).toBeFalsy();
+        expect(isSubDirectory(resolve('./project'), resolve('./project'))).toBeFalsy();
+        expect(isSubDirectory(resolve('./project'), resolve('../'))).toBeFalsy();
+        expect(isSubDirectory(resolve('./project'), resolve('../../'))).toBeFalsy();
+        expect(isSubDirectory(resolve('./'), resolve('./output'))).toBeTruthy();
+        expect(isSubDirectory(resolve('./'), resolve('../output'))).toBeTruthy();
     });
 });
diff --git a/src/utils/isSubdirectory.ts b/src/utils/isSubdirectory.ts
@@ -1,5 +1,5 @@
-import * as path from 'path';
+import { relative } from 'path';
 
 export function isSubDirectory(parent: string, child: string) {
-    return path.relative(child, parent).startsWith('..');
+    return relative(child, parent).startsWith('..');
 }
diff --git a/src/utils/readSpecFromDisk.ts b/src/utils/readSpecFromDisk.ts
@@ -1,4 +1,4 @@
-import * as path from 'path';
+import { resolve } from 'path';
 
 import { exists, readFile } from './fileSystem';
 
@@ -7,7 +7,7 @@ import { exists, readFile } from './fileSystem';
  * @param input
  */
 export async function readSpecFromDisk(input: string): Promise<string> {
-    const filePath = path.resolve(process.cwd(), input);
+    const filePath = resolve(process.cwd(), input);
     const fileExists = await exists(filePath);
     if (fileExists) {
         try {
diff --git a/src/utils/readSpecFromHttp.ts b/src/utils/readSpecFromHttp.ts
@@ -1,12 +1,12 @@
-import * as http from 'http';
+import { get } from 'http';
 
 /**
  * Download the spec file from a HTTP resource
  * @param url
  */
 export async function readSpecFromHttp(url: string): Promise<string> {
     return new Promise<string>((resolve, reject) => {
-        http.get(url, response => {
+        get(url, response => {
             let body = '';
             response.on('data', chunk => {
                 body += chunk;
diff --git a/src/utils/readSpecFromHttps.ts b/src/utils/readSpecFromHttps.ts
@@ -1,12 +1,12 @@
-import * as https from 'https';
+import { get } from 'https';
 
 /**
  * Download the spec file from a HTTPS resource
  * @param url
  */
 export async function readSpecFromHttps(url: string): Promise<string> {
     return new Promise<string>((resolve, reject) => {
-        https.get(url, response => {
+        get(url, response => {
             let body = '';
             response.on('data', chunk => {
                 body += chunk;
diff --git a/src/utils/writeClient.spec.ts b/src/utils/writeClient.spec.ts
@@ -1,5 +1,5 @@
 import type { Client } from '../client/interfaces/Client';
-import { HttpClient } from '../index';
+import { HttpClient } from '../HttpClient';
 import { mkdir, rmdir, writeFile } from './fileSystem';
 import { Templates } from './registerHandlebarTemplates';
 import { writeClient } from './writeClient';
diff --git a/src/utils/writeClient.ts b/src/utils/writeClient.ts
@@ -1,7 +1,7 @@
-import * as path from 'path';
+import { resolve } from 'path';
 
 import type { Client } from '../client/interfaces/Client';
-import { HttpClient } from '../index';
+import { HttpClient } from '../HttpClient';
 import { mkdir, rmdir } from './fileSystem';
 import { isSubDirectory } from './isSubdirectory';
 import { Templates } from './registerHandlebarTemplates';
@@ -12,7 +12,7 @@ import { writeClientSchemas } from './writeClientSchemas';
 import { writeClientServices } from './writeClientServices';
 
 /**
- * Write our OpenAPI client, using the given templates at the given output path.
+ * Write our OpenAPI client, using the given templates at the given output
  * @param client Client object with all the models, services, etc.
  * @param templates Templates wrapper with all loaded Handlebars templates
  * @param output The relative ___location of the output directory
@@ -28,19 +28,19 @@ export async function writeClient(
     client: Client,
     templates: Templates,
     output: string,
-    httpClient: HttpClient,
+    httpClient: string | HttpClient,
     useOptions: boolean,
     useUnionTypes: boolean,
     exportCore: boolean,
     exportServices: boolean,
     exportModels: boolean,
     exportSchemas: boolean
 ): Promise<void> {
-    const outputPath = path.resolve(process.cwd(), output);
-    const outputPathCore = path.resolve(outputPath, 'core');
-    const outputPathModels = path.resolve(outputPath, 'models');
-    const outputPathSchemas = path.resolve(outputPath, 'schemas');
-    const outputPathServices = path.resolve(outputPath, 'services');
+    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');
 
     if (!isSubDirectory(process.cwd(), output)) {
         throw new Error(`Output folder is not a subdirectory of the current working directory`);
diff --git a/src/utils/writeClientCore.spec.ts b/src/utils/writeClientCore.spec.ts
@@ -1,5 +1,5 @@
 import type { Client } from '../client/interfaces/Client';
-import { HttpClient } from '../index';
+import { HttpClient } from '../HttpClient';
 import { writeFile } from './fileSystem';
 import { Templates } from './registerHandlebarTemplates';
 import { writeClientCore } from './writeClientCore';
diff --git a/src/utils/writeClientCore.ts b/src/utils/writeClientCore.ts
@@ -1,8 +1,8 @@
-import * as path from 'path';
+import { resolve } from 'path';
 
 import type { Client } from '../client/interfaces/Client';
-import { HttpClient } from '../index';
-import { writeFile } from './fileSystem';
+import { HttpClient } from '../HttpClient';
+import { copyFile, exists, writeFile } from './fileSystem';
 import { Templates } from './registerHandlebarTemplates';
 
 /**
@@ -12,15 +12,31 @@ import { Templates } from './registerHandlebarTemplates';
  * @param outputPath Directory to write the generated files to
  * @param httpClient The selected httpClient (fetch, xhr or node)
  */
-export async function writeClientCore(client: Client, templates: Templates, outputPath: string, httpClient: HttpClient): Promise<void> {
+export async function writeClientCore(client: Client, templates: Templates, outputPath: string, httpClient: string | HttpClient): Promise<void> {
     const context = {
         httpClient,
         server: client.server,
         version: client.version,
     };
-    await writeFile(path.resolve(outputPath, 'OpenAPI.ts'), templates.core.settings(context));
-    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));
+
+    await writeFile(resolve(outputPath, 'OpenAPI.ts'), templates.core.settings(context));
+    await writeFile(resolve(outputPath, 'ApiError.ts'), templates.core.apiError({}));
+    await writeFile(resolve(outputPath, 'ApiRequestOptions.ts'), templates.core.apiRequestOptions({}));
+    await writeFile(resolve(outputPath, 'ApiResult.ts'), templates.core.apiResult({}));
+
+    switch (httpClient) {
+        case HttpClient.FETCH:
+        case HttpClient.XHR:
+        case HttpClient.NODE:
+            await writeFile(resolve(outputPath, 'request.ts'), templates.core.request(context));
+            break;
+        default:
+            const customRequestFile = resolve(process.cwd(), httpClient);
+            const customRequestFileExists = await exists(customRequestFile);
+            if (!customRequestFileExists) {
+                throw new Error(`Custom request file "${customRequestFile}" does not exists`);
+            }
+            await copyFile(customRequestFile, resolve(outputPath, 'request.ts'));
+            break;
+    }
 }
diff --git a/src/utils/writeClientIndex.ts b/src/utils/writeClientIndex.ts
@@ -1,4 +1,4 @@
-import * as path from 'path';
+import { resolve } from 'path';
 
 import type { Client } from '../client/interfaces/Client';
 import { writeFile } from './fileSystem';
@@ -30,7 +30,7 @@ export async function writeClientIndex(
     exportSchemas: boolean
 ): Promise<void> {
     await writeFile(
-        path.resolve(outputPath, 'index.ts'),
+        resolve(outputPath, 'index.ts'),
         templates.index({
             exportCore,
             exportServices,
diff --git a/src/utils/writeClientModels.spec.ts b/src/utils/writeClientModels.spec.ts
@@ -1,5 +1,5 @@
 import type { Model } from '../client/interfaces/Model';
-import { HttpClient } from '../index';
+import { HttpClient } from '../HttpClient';
 import { writeFile } from './fileSystem';
 import { Templates } from './registerHandlebarTemplates';
 import { writeClientModels } from './writeClientModels';
diff --git a/src/utils/writeClientModels.ts b/src/utils/writeClientModels.ts
@@ -1,7 +1,7 @@
-import * as path from 'path';
+import { resolve } from 'path';
 
 import type { Model } from '../client/interfaces/Model';
-import { HttpClient } from '../index';
+import { HttpClient } from '../HttpClient';
 import { writeFile } from './fileSystem';
 import { format } from './format';
 import { Templates } from './registerHandlebarTemplates';
@@ -14,9 +14,9 @@ import { Templates } from './registerHandlebarTemplates';
  * @param httpClient The selected httpClient (fetch, xhr or node)
  * @param useUnionTypes Use union types instead of enums
  */
-export async function writeClientModels(models: Model[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean): Promise<void> {
+export async function writeClientModels(models: Model[], templates: Templates, outputPath: string, httpClient: string | HttpClient, useUnionTypes: boolean): Promise<void> {
     for (const model of models) {
-        const file = path.resolve(outputPath, `${model.name}.ts`);
+        const file = resolve(outputPath, `${model.name}.ts`);
         const templateResult = templates.exports.model({
             ...model,
             httpClient,
diff --git a/src/utils/writeClientSchemas.spec.ts b/src/utils/writeClientSchemas.spec.ts
diff --git a/src/utils/writeClientSchemas.ts b/src/utils/writeClientSchemas.ts
diff --git a/src/utils/writeClientServices.spec.ts b/src/utils/writeClientServices.spec.ts
diff --git a/src/utils/writeClientServices.ts b/src/utils/writeClientServices.ts
diff --git a/test/custom/request.ts b/test/custom/request.ts
diff --git a/tsconfig.json b/tsconfig.json
diff --git a/types/index.d.ts b/types/index.d.ts
diff --git a/yarn.lock b/yarn.lock

Original file line number	Diff line number	Diff line change
`@@ -1,4 +1,4 @@`
`1`		`-import * as os from 'os';`
	`1`	`+import { EOL } from 'os';`
`2`	`2`
`3`	`3`	`/**`
`4`	`4`	`* Cleanup comment and prefix multiline comments with "*",`
`@@ -7,7 +7,7 @@ import * as os from 'os';`
`7`	`7`	`*/`
`8`	`8`	`export function getComment(comment?: string): string \| null {`
`9`	`9`	`if (comment) {`
`10`		- return comment.replace(/\r?\n(.)/g, (_, w) => `${os.EOL} ${w.trim()}`);
	`10`	+ return comment.replace(/\r?\n(.)/g, (_, w) => `${EOL} ${w.trim()}`);
`11`	`11`	`}`
`12`	`12`	`return null;`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -4,8 +4,5 @@ async function sendRequest(options: ApiRequestOptions, url: string): Promise<Res`
`4`	`4`	`headers: await getHeaders(options),`
`5`	`5`	`body: getRequestBody(options),`
`6`	`6`	`};`
`7`		`- if (OpenAPI.WITH_CREDENTIALS) {`
`8`		`- request.credentials = 'include';`
`9`		`- }`
`10`	`7`	`return await fetch(url, request);`
`11`	`8`	`}`