PE-2229 - rename OpenApi properties, remove config from http client, add config to request

Author: lub0v-parsable

package.json

@@ -1,6 +1,6 @@
 {
     "name": "@parsable/openapi-typescript-codegen",
-    "version": "0.0.2-alpha-4",
+    "version": "0.0.2-alpha-5",
     "description": "Library that generates Typescript clients based on the OpenAPI specification.",
     "author": "Ferdi Koomen",
     "homepage": "https://github.com/ferdikoomen/openapi-typescript-codegen",

src/templates/core/ApiResult.hbs

@@ -1,9 +1,9 @@
 {{>header}}
 
-export type ApiResult = {
+export type ApiResult<T = any> = {
     readonly url: string;
     readonly ok: boolean;
     readonly status: number;
     readonly statusText: string;
-    readonly body: any;
+    readonly body: T;
 }

src/templates/core/BaseHttpRequest.hbs

@@ -4,14 +4,10 @@ import type { ApiRequestOptions } from './ApiRequestOptions';
 import type { ApiResult } from './ApiResult';
 import type { OpenAPIConfig } from './OpenAPI';
 
-export class BaseHttpRequest {
-    readonly openApiConfig: OpenAPIConfig;
-
-    constructor(openApiConfig: OpenAPIConfig) {
-        this.openApiConfig = openApiConfig;
-    }
-
-    async request(options: ApiRequestOptions): Promise<ApiResult> {
-        throw new Error('Not Implemented');
-    }
+export interface BaseHttpRequest {
+    request(
+        options: ApiRequestOptions,
+        config: OpenAPIConfig,
+        mergeConfig?: OpenAPIConfig
+    ): Promise<ApiResult>;
 }

src/templates/core/OpenAPI.hbs

@@ -6,22 +6,22 @@ type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
 type Headers = Record<string, string>;
 
 export type OpenAPIConfig = {
-    BASE?: string;
-    VERSION?: string;
-    WITH_CREDENTIALS?: boolean;
-    TOKEN?: string | Resolver<string>;
-    USERNAME?: string | Resolver<string>;
-    PASSWORD?: string | Resolver<string>;
-    HEADERS?: Headers | Resolver<Headers>;
+    baseUrl?: string;
+    version?: string;
+    withCredentials?: boolean;
+    token?: string | Resolver<string>;
+    username?: string | Resolver<string>;
+    password?: string | Resolver<string>;
+    headers?: Headers | Resolver<Headers>;
 }
 {{#unless @root.exportClient}}
 export const OpenAPI: OpenAPIConfig = {
-    BASE: '{{{server}}}',
-    VERSION: '{{{version}}}',
-    WITH_CREDENTIALS: false,
-    TOKEN: undefined,
-    USERNAME: undefined,
-    PASSWORD: undefined,
-    HEADERS: undefined,
+    baseUrl: '{{{server}}}',
+    version: '{{{version}}}',
+    withCredentials: false,
+    token: undefined,
+    username: undefined,
+    password: undefined,
+    headers: undefined,
 };
 {{/unless}}

src/templates/core/fetch/getHeaders.hbs

@@ -1,8 +1,8 @@
 async function getHeaders(options: ApiRequestOptions, config: OpenAPIConfig): Promise<Headers> {
-    const token = await resolve(options, config.TOKEN);
-    const username = await resolve(options, config.USERNAME);
-    const password = await resolve(options, config.PASSWORD);
-    const defaultHeaders = await resolve(options, config.HEADERS);
+    const token = await resolve(options, config.token);
+    const username = await resolve(options, config.username);
+    const password = await resolve(options, config.password);
+    const defaultHeaders = await resolve(options, config.headers);
 
     const headers = new Headers({
         Accept: 'application/json',

src/templates/core/fetch/request.hbs

@@ -5,7 +5,7 @@ import type { ApiRequestOptions } from './ApiRequestOptions';
 import type { ApiResult } from './ApiResult';
 import type { OpenAPIConfig } from './OpenAPI';
 {{#if @root.exportClient}}
-import { BaseHttpRequest } from './BaseHttpRequest';
+import type { BaseHttpRequest } from './BaseHttpRequest';
 {{else}}
 import { OpenAPI } from './OpenAPI';
 {{/if}}
@@ -16,6 +16,9 @@ import { OpenAPI } from './OpenAPI';
 {{>functions/isString}}
 
 
+{{>functions/deepAssign}}
+
+
 {{>functions/isStringWithValue}}
 
 
@@ -53,20 +56,19 @@ import { OpenAPI } from './OpenAPI';
 
 
 {{#if @root.exportClient}}
-export class FetchHttpRequest extends BaseHttpRequest {
-    constructor(openApiConfig: OpenAPIConfig) {
-        super(openApiConfig);
-    }
-
+export class FetchHttpRequest implements BaseHttpRequest {
     /**
     * Request using fetch client
     * @param options The request options from the the service
+    * @param config The OpenAPI configuration
+    * @param [mergeConfig] Additional optional OpenAPI configuration that will be merged with the first one
     * @returns ApiResult
     * @throws ApiError
     */
-    async request(options: ApiRequestOptions): Promise<ApiResult> {
-        const url = getUrl(options, this.openApiConfig);
-        const response = await sendRequest(options, this.openApiConfig, url);
+    async request(options: ApiRequestOptions, config: OpenAPIConfig, mergeConfig?: OpenAPIConfig): Promise<ApiResult> {
+        const conf = mergeConfig ? deepAssign(config, mergeConfig) : config;
+        const url = getUrl(options, conf);
+        const response = await sendRequest(options, conf, url);
         const responseBody = await getResponseBody(response);
         const responseHeader = getResponseHeader(response, options.responseHeader);
 

src/templates/core/fetch/sendRequest.hbs

@@ -4,7 +4,7 @@ async function sendRequest(options: ApiRequestOptions, config: OpenAPIConfig, ur
         headers: await getHeaders(options, config),
         body: getRequestBody(options),
     };
-    if (config.WITH_CREDENTIALS) {
+    if (config.withCredentials) {
         request.credentials = 'include';
     }
     return await fetch(url, request);

src/templates/core/functions/deepAssign.hbs

@@ -0,0 +1,19 @@
+export function deepAssign(
+    target: Record<string, unknown>,
+    source: Record<string, unknown>,
+): Record<string, unknown> {
+    const keys = Object.keys(source);
+    for (const k of keys) {
+        const sourceValue: unknown = source[k];
+        const targetValue: unknown = target[k];
+        if (Object(sourceValue) === sourceValue && Object(targetValue) === targetValue) {
+            target[k] = deepAssign(
+                targetValue as Record<string, unknown>,
+                sourceValue as Record<string, unknown>,
+            );
+        } else {
+            target[k] = source[k];
+        }
+    }
+    return target;
+}

src/templates/core/functions/getUrl.hbs

@@ -1,6 +1,6 @@
 function getUrl(options: ApiRequestOptions, config: OpenAPIConfig): string {
     const path = options.path.replace(/[:]/g, '_');
-    const url = `${config.BASE}${path}`;
+    const url = `${config.baseUrl}${path}`;
 
     if (options.query) {
         return `${url}${getQueryString(options.query)}`;

src/templates/core/index.hbs

@@ -4,7 +4,7 @@ export { ApiError } from './ApiError';
 export type { ApiRequestOptions } from './ApiRequestOptions';
 export type { ApiResult } from './ApiResult';
 {{#if @root.exportClient}}
-export { BaseHttpRequest } from './BaseHttpRequest';
+export type { BaseHttpRequest } from './BaseHttpRequest';
 export { {{{httpRequestName}}} } from './{{{httpRequestName}}}';
 export type { OpenAPIConfig } from './OpenAPI';
 {{else}}