Option to dependency inject the request function

[jesperkristensen]

I would like to have an option to dependency inject the request function in each operation, such that the services don't have a dependency on the core modules, and so that --exportCore false will produce typescript code that compiles.

For example:

type __request = (options: ApiRequestOptions) => Promise<ApiResult>

export class MyService {
    public static async myOperation(
        request: __request,
        myParam: string,
        requestBody: MyRequestModel,
    ): Promise<MyResponseModel> {
        const result = await request({
            method: 'POST',
            path: `/my-api/${myParam}`,
            body: requestBody,
        });
        return result.body;
    }
}

Use case 1:

I consume multiple OpenAPIs from multiple different microservices. I need to make modifications to the core request module to make it support React Native. I need to make modifications to the core OpenAPI module to fetch the correct token. I want to maintain one copy of these modifications across the apis generated for all the microservices, instead of duplicating the modifications per microservice.

Use case 2:

I modified the core request module to add a timeout. I want to use different timeouts in different operation calls. If the request function was given as a parameter to the operation, I could pass a modified request function that included the timeout.

Example:

const r = await MyService.myOperation(makeRequest({timeout: 10}), "string", {object: true})

May be related to #428 and #400

Thanks for a great library.

[iansan5653]

I would love to see this as well. Currently we are using a Proxy to wrap each service and intercept every API method call in order to add logging and loading state tracking. It would be much cleaner if we could build a central request service that we inject into every API service that handles the requesting, logging, and tracking. It would also be a lot easier to test as we could just inject a fake service for testing.

I don't think this would be too cumbersome to use. Just make each service a regular class that takes some interface or method as a property and that way you don't have to inject with every method call. A very basic example:

interface RequestOptions {
  method: "get" | "post";
  body: object;
  /* ... */
}

type Requestor = (url: string, options: RequestOptions) => Promise<any>;

export class ExampleService(requestor: Requestor) {
  
}

I actually think that if you built it this way, it would make development of this project a lot easier. You could eventually remove all the different options for request libraries and just have the injected variant. If someone wants to use the fetch API, they can just make a Requestor that calls fetch. Same goes for any other request tool.

[iansan5653]

@ferdikoomen I might be able to work on a PR for this if you approve of the idea.

[iansan5653]

I just saw PR #489 which solves the problem here, but I think it can be done in a better way. Injection through the class field would be a lot cleaner as the global variable config would be avoided. PR #434 is somewhat related as well as it would be easy to intercept requests if you are making your own requestor.

[ferdikoomen]

@jesperkristensen @iansan5653 there is currently one option and that is to use the --request parameter to supply a custom request file when generating:

openapi --input spec.json --output generated --request request.ts",

Example of such a file:

import { stringify } from 'qs';
import { ApiRequestOptions } from './ApiRequestOptions';
import { ApiResult } from './ApiResult';

export async function request(options: ApiRequestOptions): Promise
{
const path = options.path.replace(/[:]/g, '_');
const query = stringify(options.query);
const url = ${host}${base}${path}?${query};

const body = options.body && JSON.stringify(options.body);

const headers = {
    ...options.headers,
    'Accept': 'application/json',
    'Content-Type': 'application/json; charset=utf-8',
};

// Add your custom request logic here....
const response = await fetch({
    url,
    headers,
    body,
});

const isSuccess = response.statusCode >= 200 && response.statusCode < 300;
const responseBody = response.body && JSON.parse(response.body);

return {
    url,
    ok: isSuccess,
    status: response.statusCode,
    statusText: '',
    body: responseBody,
};

}

Other options are indeed possible, if time permits I'll add them. But that is pending a larger rewrite. 

[iansan5653]

I didn't know that was possible, thanks. To clarify, does the request file just need to export a single method request which has type (options: ApiRequestOptions) => Promise<any>?

[ferdikoomen]

@iansan5653 Yes indeed, simple example: https://github.com/ferdikoomen/openapi-typescript-codegen/blob/master/test/custom/request.ts

[jesperkristensen]

Unfortunately it looks like the --request parameter can only be specified when generating the API client, but not when calling the API, so it does not really solve my problem.