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);
+}
+});
+};