chore: add nextjs_fetch client

Author: Justin Calleja

README.md

@@ -38,7 +38,7 @@ $ openapi --help
     -V, --version             output the version number
     -i, --input <value>       OpenAPI specification, can be a path, url or string content (required)
     -o, --output <value>      Output directory (required)
-    -c, --client <value>      HTTP client to generate [fetch, xhr, node, axios, angular] (default: "fetch")
+    -c, --client <value>      HTTP client to generate [nextjs_fetch, fetch, xhr, node, axios, angular] (default: "fetch")
     --name <value>            Custom client class name
     --useOptions              Use options instead of arguments
     --useUnionTypes           Use union types instead of enums

bin/index.js

@@ -12,7 +12,7 @@ const params = 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, axios, angular]', 'fetch')
+    .option('-c, --client <value>', 'HTTP client to generate [nextjs_fetch, fetch, xhr, node, axios, angular]', 'fetch')
     .option('--name <value>', 'Custom client class name')
     .option('--useOptions', 'Use options instead of arguments')
     .option('--useUnionTypes', 'Use union types instead of enums')

src/HttpClient.ts

@@ -1,6 +1,7 @@
 export enum HttpClient {
     FETCH = 'fetch',
     XHR = 'xhr',
+    NEXTJS_FETCH = 'nextjs_fetch',
     NODE = 'node',
     AXIOS = 'axios',
     ANGULAR = 'angular',

src/index.ts

@@ -36,7 +36,7 @@ export type Options = {
  * service layer, etc.
  * @param input The relative ___location of the OpenAPI spec
  * @param output The relative ___location of the output directory
- * @param httpClient The selected httpClient (fetch, xhr, node or axios)
+ * @param httpClient The selected httpClient (nextjs_fetch, fetch, xhr, node or axios)
  * @param clientName Custom client class name
  * @param useOptions Use options or arguments functions
  * @param useUnionTypes Use union types instead of enums

src/templates/core/ApiRequestOptions.hbs

@@ -1,5 +1,23 @@
 {{>header}}
 
+
+{{#equals @root.httpClient 'nextjs_fetch'}}
+export type ApiRequestOptions = {
+	readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+	readonly url: string;
+	readonly path?: Record<string, any>;
+	readonly cookies?: Record<string, any>;
+	readonly headers?: Record<string, any>;
+	readonly query?: Record<string, any>;
+	readonly formData?: Record<string, any>;
+	readonly body?: any;
+	readonly mediaType?: string;
+	readonly responseHeader?: string;
+	readonly errors?: Record<number, string>;
+	readonly cache?: RequestInit['cache']
+    readonly next?: { revalidate: number }
+};
+{{else}}
 export type ApiRequestOptions = {
 	readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
 	readonly url: string;
@@ -13,3 +31,4 @@ export type ApiRequestOptions = {
 	readonly responseHeader?: string;
 	readonly errors?: Record<number, string>;
 };
+{{/equals}}

src/templates/core/nextjs_fetch/getHeaders.hbs

@@ -0,0 +1,40 @@
+export const getHeaders = async (config: OpenAPIConfig, options: ApiRequestOptions): Promise<Headers> => {
+	const token = await resolve(options, config.TOKEN);
+	const username = await resolve(options, config.USERNAME);
+	const password = await resolve(options, config.PASSWORD);
+	const additionalHeaders = await resolve(options, config.HEADERS);
+
+	const headers = Object.entries({
+		Accept: 'application/json',
+		...additionalHeaders,
+		...options.headers,
+	})
+		.filter(([_, value]) => isDefined(value))
+		.reduce((headers, [key, value]) => ({
+			...headers,
+			[key]: String(value),
+		}), {} as Record<string, string>);
+
+	if (isStringWithValue(token)) {
+		headers['Authorization'] = `Bearer ${token}`;
+	}
+
+	if (isStringWithValue(username) && isStringWithValue(password)) {
+		const credentials = base64(`${username}:${password}`);
+		headers['Authorization'] = `Basic ${credentials}`;
+	}
+
+	if (options.body) {
+		if (options.mediaType) {
+			headers['Content-Type'] = options.mediaType;
+		} else if (isBlob(options.body)) {
+			headers['Content-Type'] = options.body.type || 'application/octet-stream';
+		} else if (isString(options.body)) {
+			headers['Content-Type'] = 'text/plain';
+		} else if (!isFormData(options.body)) {
+			headers['Content-Type'] = 'application/json';
+		}
+	}
+
+	return new Headers(headers);
+};

src/templates/core/nextjs_fetch/getRequestBody.hbs

@@ -0,0 +1,12 @@
+export const getRequestBody = (options: ApiRequestOptions): any => {
+	if (options.body !== undefined) {
+		if (options.mediaType?.includes('/json')) {
+			return JSON.stringify(options.body)
+		} else if (isString(options.body) || isBlob(options.body) || isFormData(options.body)) {
+			return options.body;
+		} else {
+			return JSON.stringify(options.body);
+		}
+	}
+	return undefined;
+};

src/templates/core/nextjs_fetch/getResponseBody.hbs

@@ -0,0 +1,19 @@
+export const getResponseBody = async (response: Response): Promise<any> => {
+	if (response.status !== 204) {
+		try {
+			const contentType = response.headers.get('Content-Type');
+			if (contentType) {
+				const jsonTypes = ['application/json', 'application/problem+json']
+				const isJSON = jsonTypes.some(type => contentType.toLowerCase().startsWith(type));
+				if (isJSON) {
+					return await response.json();
+				} else {
+					return await response.text();
+				}
+			}
+		} catch (error) {
+			console.error(error);
+		}
+	}
+	return undefined;
+};

src/templates/core/nextjs_fetch/getResponseHeader.hbs

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

src/templates/core/nextjs_fetch/request.hbs

@@ -0,0 +1,94 @@
+{{>header}}
+
+import { ApiError } from './ApiError';
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { CancelablePromise } from './CancelablePromise';
+import type { OnCancel } from './CancelablePromise';
+import type { OpenAPIConfig } from './OpenAPI';
+
+{{>functions/isDefined}}
+
+
+{{>functions/isString}}
+
+
+{{>functions/isStringWithValue}}
+
+
+{{>functions/isBlob}}
+
+
+{{>functions/isFormData}}
+
+
+{{>functions/base64}}
+
+
+{{>functions/getQueryString}}
+
+
+{{>functions/getUrl}}
+
+
+{{>functions/getFormData}}
+
+
+{{>functions/resolve}}
+
+
+{{>fetch/getHeaders}}
+
+
+{{>fetch/getRequestBody}}
+
+
+{{>fetch/sendRequest}}
+
+
+{{>fetch/getResponseHeader}}
+
+
+{{>fetch/getResponseBody}}
+
+
+{{>functions/catchErrorCodes}}
+
+
+/**
+ * Request method
+ * @param config The OpenAPI configuration object
+ * @param options The request options from the service
+ * @returns CancelablePromise<T>
+ * @throws ApiError
+ */
+export const request = <T>(config: OpenAPIConfig, options: ApiRequestOptions): CancelablePromise<T> => {
+	return new CancelablePromise(async (resolve, reject, onCancel) => {
+		try {
+			const url = getUrl(config, options);
+			const formData = getFormData(options);
+			const body = getRequestBody(options);
+			const headers = await getHeaders(config, options);
+
+			if (!onCancel.isCancelled) {
+				const response = await sendRequest(config, options, url, body, formData, headers, onCancel);
+				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,
+				};
+
+				catchErrorCodes(options, result);
+
+				resolve(result.body);
+			}
+		} catch (error) {
+			reject(error);
+		}
+	});
+};