- Added request property

Author: ferdikoomen

bin/index.js

@@ -12,13 +12,14 @@ 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] or path to custom request file', 'fetch')
+    .option('-c, --client <value>', 'HTTP client to generate [fetch, xhr, node]', '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)
     .option('--exportServices <value>', 'Write services to disk', true)
     .option('--exportModels <value>', 'Write models to disk', true)
     .option('--exportSchemas <value>', 'Write schemas to disk', false)
+    .option('--request <value>', 'Path to custom request file')
     .parse(process.argv);
 
 const OpenAPI = require(path.resolve(__dirname, '../dist/index.js'));
@@ -34,6 +35,7 @@ if (OpenAPI) {
         exportServices: JSON.parse(program.exportServices) === true,
         exportModels: JSON.parse(program.exportModels) === true,
         exportSchemas: JSON.parse(program.exportSchemas) === true,
+        request: program.request,
     })
         .then(() => {
             process.exit(0);

package.json

@@ -1,6 +1,6 @@
 {
     "name": "openapi-typescript-codegen",
-    "version": "0.7.0",
+    "version": "0.7.1",
     "description": "Library that generates Typescript clients based on the OpenAPI specification.",
     "author": "Ferdi Koomen",
     "homepage": "https://github.com/ferdikoomen/openapi-typescript-codegen",
@@ -91,7 +91,6 @@
         "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

@@ -13,13 +13,14 @@ export { HttpClient } from './HttpClient';
 export type Options = {
     input: string | Record<string, any>;
     output: string;
-    httpClient?: string | HttpClient;
+    httpClient?: HttpClient;
     useOptions?: boolean;
     useUnionTypes?: boolean;
     exportCore?: boolean;
     exportServices?: boolean;
     exportModels?: boolean;
     exportSchemas?: boolean;
+    request?: string;
     write?: boolean;
 };
 
@@ -36,6 +37,7 @@ export type Options = {
  * @param exportServices: Generate services
  * @param exportModels: Generate models
  * @param exportSchemas: Generate schemas
+ * @param request: Path to custom request file
  * @param write Write the files to disk (true or false)
  */
 export async function generate({
@@ -48,6 +50,7 @@ export async function generate({
     exportServices = true,
     exportModels = true,
     exportSchemas = false,
+    request,
     write = true,
 }: Options): Promise<void> {
     const openApi = isString(input) ? await getOpenApiSpec(input) : input;
@@ -59,15 +62,15 @@ export async function generate({
             const client = parseV2(openApi);
             const clientFinal = postProcessClient(client);
             if (!write) break;
-            await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+            await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request);
             break;
         }
 
         case OpenApiVersion.V3: {
             const client = parseV3(openApi);
             const clientFinal = postProcessClient(client);
             if (!write) break;
-            await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas);
+            await writeClient(clientFinal, templates, output, httpClient, useOptions, useUnionTypes, exportCore, exportServices, exportModels, exportSchemas, request);
             break;
         }
     }

src/utils/writeClient.ts

@@ -23,18 +23,20 @@ import { writeClientServices } from './writeClientServices';
  * @param exportServices: Generate services
  * @param exportModels: Generate models
  * @param exportSchemas: Generate schemas
+ * @param request: Path to custom request file
  */
 export async function writeClient(
     client: Client,
     templates: Templates,
     output: string,
-    httpClient: string | HttpClient,
+    httpClient: HttpClient,
     useOptions: boolean,
     useUnionTypes: boolean,
     exportCore: boolean,
     exportServices: boolean,
     exportModels: boolean,
-    exportSchemas: boolean
+    exportSchemas: boolean,
+    request?: string
 ): Promise<void> {
     const outputPath = resolve(process.cwd(), output);
     const outputPathCore = resolve(outputPath, 'core');
@@ -49,7 +51,7 @@ export async function writeClient(
     if (exportCore) {
         await rmdir(outputPathCore);
         await mkdir(outputPathCore);
-        await writeClientCore(client, templates, outputPathCore, httpClient);
+        await writeClientCore(client, templates, outputPathCore, httpClient, request);
     }
 
     if (exportServices) {

src/utils/writeClientCore.ts

@@ -11,8 +11,9 @@ import { Templates } from './registerHandlebarTemplates';
  * @param templates The loaded handlebar templates
  * @param outputPath Directory to write the generated files to
  * @param httpClient The selected httpClient (fetch, xhr or node)
+ * @param request: Path to custom request file
  */
-export async function writeClientCore(client: Client, templates: Templates, outputPath: string, httpClient: string | HttpClient): Promise<void> {
+export async function writeClientCore(client: Client, templates: Templates, outputPath: string, httpClient: HttpClient, request?: string): Promise<void> {
     const context = {
         httpClient,
         server: client.server,
@@ -23,20 +24,14 @@ export async function writeClientCore(client: Client, templates: Templates, outp
     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({}));
+    await writeFile(resolve(outputPath, 'request.ts'), templates.core.request(context));
 
-    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;
+    if (request) {
+        const requestFile = resolve(process.cwd(), request);
+        const requestFileExists = await exists(requestFile);
+        if (!requestFileExists) {
+            throw new Error(`Custom request file "${requestFile}" does not exists`);
+        }
+        await copyFile(requestFile, resolve(outputPath, 'request.ts'));
     }
 }

src/utils/writeClientModels.ts

@@ -14,7 +14,7 @@ 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: string | HttpClient, useUnionTypes: boolean): Promise<void> {
+export async function writeClientModels(models: Model[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean): Promise<void> {
     for (const model of models) {
         const file = resolve(outputPath, `${model.name}.ts`);
         const templateResult = templates.exports.model({

src/utils/writeClientSchemas.ts

@@ -14,7 +14,7 @@ import { Templates } from './registerHandlebarTemplates';
  * @param httpClient The selected httpClient (fetch, xhr or node)
  * @param useUnionTypes Use union types instead of enums
  */
-export async function writeClientSchemas(models: Model[], templates: Templates, outputPath: string, httpClient: string | HttpClient, useUnionTypes: boolean): Promise<void> {
+export async function writeClientSchemas(models: Model[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean): Promise<void> {
     for (const model of models) {
         const file = resolve(outputPath, `$${model.name}.ts`);
         const templateResult = templates.exports.schema({

src/utils/writeClientServices.ts

@@ -17,7 +17,7 @@ const VERSION_TEMPLATE_STRING = 'OpenAPI.VERSION';
  * @param useUnionTypes Use union types instead of enums
  * @param useOptions Use options or arguments functions
  */
-export async function writeClientServices(services: Service[], templates: Templates, outputPath: string, httpClient: string | HttpClient, useUnionTypes: boolean, useOptions: boolean): Promise<void> {
+export async function writeClientServices(services: Service[], templates: Templates, outputPath: string, httpClient: HttpClient, useUnionTypes: boolean, useOptions: boolean): Promise<void> {
     for (const service of services) {
         const file = resolve(outputPath, `${service.name}.ts`);
         const useVersion = service.operations.some(operation => operation.path.includes(VERSION_TEMPLATE_STRING));

test/custom/request.ts

@@ -1,60 +1,23 @@
-// @ts-ignore
-import httpntlm from 'httpntlm';
-import { promisify } from 'util';
-import { stringify } from 'qs';
+/* istanbul ignore file */
+/* tslint:disable */
+/* eslint-disable */
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+import { OpenAPI } from './OpenAPI';
 
-type TRequestOptions = {
-    readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
-    readonly path: string;
-    readonly cookies?: Record<string, any>;
-    readonly headers?: Record<string, any>;
-    readonly query?: Record<string, any>;
-    readonly formData?: Record<string, any>;
-    readonly body?: any;
-    readonly responseHeader?: string;
-    readonly errors?: Record<number, string>;
-}
-
-type TResult = {
-    readonly url: string;
-    readonly ok: boolean;
-    readonly status: number;
-    readonly statusText: string;
-    readonly body: any;
-}
-
-export async function request(options: TRequestOptions): Promise<TResult> {
+export async function request(options: ApiRequestOptions): Promise<ApiResult> {
 
-    const path = options.path.replace(/[:]/g, '_');
-    const query = stringify(options.query);
-    const host = 'http://localhost:8080';
-    const url = `${host}${path}${query}`;
+    const url = `${OpenAPI.BASE}${options.path}`;
 
-    const body = options.body && JSON.stringify(options.body);
-    const headers = {
-        ...options.headers,
-        'Accept': 'application/json',
-        'Content-Type': 'application/json; charset=utf-8',
-        'Accept-Encoding': 'identity',
-    }
-
-    const method = options.method.toLowerCase();
-    const fetch = promisify(httpntlm[method]);
-
-    const response = await fetch({
-        url,
-        ___domain: '___domain',
-        username: 'username',
-        password: 'password',
-        headers,
-        body,
-    });
+    // Do your request...
 
     return {
         url,
-        ok: response.ok,
-        status: response.statusCode,
-        statusText: response.statusText,
-        body: JSON.parse(response.body),
+        ok: true,
+        status: 200,
+        statusText: 'dummy',
+        body: {
+            ...options
+        },
     };
 }

test/index.js

@@ -13,6 +13,7 @@ async function generateV2() {
         exportSchemas: true,
         exportModels: true,
         exportServices: true,
+        request: './test/custom/request.ts',
     });
 }
 
@@ -27,6 +28,7 @@ async function generateV3() {
         exportSchemas: true,
         exportModels: true,
         exportServices: true,
+        request: './test/custom/request.ts',
     });
 }