- Woking on httpntlm

Author: ferdikoomen

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, httpntlm]', '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)

package.json

@@ -90,6 +90,7 @@
         "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",

src/index.ts

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

src/templates/core/OpenAPI.hbs

@@ -10,6 +10,7 @@ type Config = {
     TOKEN?: string | Resolver<string>;
     USERNAME?: string | Resolver<string>;
     PASSWORD?: string | Resolver<string>;
+    DOMAIN?: string | Resolver<string>;
     HEADERS?: Headers | Resolver<Headers>;
 }
 
@@ -20,5 +21,6 @@ export const OpenAPI: Config = {
     TOKEN: undefined,
     USERNAME: undefined,
     PASSWORD: undefined,
+    DOMAIN: undefined,
     HEADERS: undefined,
 };

src/templates/core/httpntlm/getHeaders.hbs

@@ -0,0 +1,31 @@
+async function getHeaders(options: ApiRequestOptions): Promise<Headers> {
+    const headers = new Headers({
+        Accept: 'application/json',
+        ...OpenAPI.HEADERS,
+        ...options.headers,
+    });
+
+    const token = await resolve(OpenAPI.TOKEN);
+    const username = await resolve(OpenAPI.USERNAME);
+    const password = await resolve(OpenAPI.PASSWORD);
+
+    if (isStringWithValue(token)) {
+        headers.append('Authorization', `Bearer ${token}`);
+    }
+
+    if (isStringWithValue(username) && isStringWithValue(password)) {
+        const credentials = Buffer.from(`${username}:${password}`).toString('base64');
+        headers.append('Authorization', `Basic ${credentials}`);
+    }
+
+    if (options.body) {
+        if (isBinary(options.body)) {
+            headers.append('Content-Type', 'application/octet-stream');
+        } else if (isString(options.body)) {
+            headers.append('Content-Type', 'text/plain');
+        } else {
+            headers.append('Content-Type', 'application/json');
+        }
+    }
+    return headers;
+}

src/templates/core/httpntlm/getRequestBody.hbs

@@ -0,0 +1,13 @@
+function getRequestBody(options: ApiRequestOptions): BodyInit | undefined {
+    if (options.formData) {
+        return getFormData(options.formData);
+    }
+    if (options.body) {
+        if (isString(options.body) || isBinary(options.body)) {
+            return options.body;
+        } else {
+            return JSON.stringify(options.body);
+        }
+    }
+    return undefined;
+}

src/templates/core/httpntlm/getResponseBody.hbs

@@ -0,0 +1,16 @@
+async function getResponseBody(response: Response): Promise<any> {
+    try {
+        const contentType = response.headers.get('Content-Type');
+        if (contentType) {
+            const isJSON = contentType.toLowerCase().startsWith('application/json');
+            if (isJSON) {
+                return await response.json();
+            } else {
+                return await response.text();
+            }
+        }
+    } catch (error) {
+        console.error(error);
+    }
+    return null;
+}

src/templates/core/httpntlm/getResponseHeader.hbs

@@ -0,0 +1,9 @@
+function getResponseHeader(response: Response, responseHeader?: string): string | null {
+    if (responseHeader) {
+        const content = response.headers.get(responseHeader);
+        if (isString(content)) {
+            return content;
+        }
+    }
+    return null;
+}

src/templates/core/httpntlm/request.hbs

@@ -0,0 +1,76 @@
+{{>header}}
+
+import FormData from 'form-data';
+import fetch, { BodyInit, Headers, RequestInit, Response } from 'node-fetch';
+import { types } from 'util';
+
+import { ApiError } from './ApiError';
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { OpenAPI } from './OpenAPI';
+
+{{>functions/isDefined}}
+
+
+{{>functions/isString}}
+
+
+{{>functions/isStringWithValue}}
+
+
+{{>functions/isBinary}}
+
+
+{{>functions/getQueryString}}
+
+
+{{>functions/getUrl}}
+
+
+{{>functions/getFormData}}
+
+
+{{>functions/resolve}}
+
+
+{{>httpntlm/getHeaders}}
+
+
+{{>httpntlm/getRequestBody}}
+
+
+{{>httpntlm/sendRequest}}
+
+
+{{>httpntlm/getResponseHeader}}
+
+
+{{>httpntlm/getResponseBody}}
+
+
+{{>functions/catchErrors}}
+
+
+/**
+* Request using node-fetch client
+* @param options The request options from the the service
+* @result ApiResult
+* @throws ApiError
+*/
+export async function request(options: ApiRequestOptions): Promise<ApiResult> {
+    const url = getUrl(options);
+    const response = await sendRequest(options, url);
+    const responseBody = await getResponseBody(response);
+    const responseHeader = getResponseHeader(response, options.responseHeader);
+
+    const result: ApiResult = {
+        url,
+        ok: response.ok,
+        status: response.status,
+        statusText: response.statusText,
+        body: responseHeader || responseBody,
+    };
+
+    catchErrors(options, result);
+    return result;
+}

src/templates/core/httpntlm/sendRequest.hbs

@@ -0,0 +1,8 @@
+async function sendRequest(options: ApiRequestOptions, url: string): Promise<Response> {
+    const request: RequestInit = {
+        method: options.method,
+        headers: await getHeaders(options),
+        body: getRequestBody(options),
+    };
+    return await fetch(url, request);
+}