[Feature request] Allow to use a custom http client

[alesmit]

Problem

The framework currently uses got as builtin http client. It would be nice if it was possible to pass an instance of whatever client the consumer prefers such as axios or node-fetch.

Possible solution

The way I see this happening is that, on server creation, the consumer must pass an instance of a class which inherits an abstract Client exported by the framework. Something like:

import fetch from 'node-fetch';
import { ExpressFactory, Http };

class CustomHttpClient extends Http.Client {
  public override async request(parameters): Promise<Http.Response> {
    if (parameters.method === Http.Method.GET) {
      return fetch(url);
    }

    // other methods ...
  }
}

ExpressFactory.createServer({
  ...options, // bootstrap parameters
  httpClient: new CustomHttpClient(),
});

Please note that the examples here outline a PoC and are not thoroughly contrived, but it would be appropriate to have extra capabilities like access to request and response headers, parsing of the response, etc.

Adapters

Additionally, the framework could expose some ready-to-use adapters for the most popular http clients. For example, say I would like to use "got", I should be able to use it right away without coming up with my own implementation of the Client.

import got from 'got';
import { ExpressFactory, Http };

ExpressFactory.createServer({
  ...options, // bootstrap parameters
  httpClient: Http.adapters.got(got),
});

The adapter would be a function that takes got as input, and returns an instance of a class which extends Http.Client whose implementation is limited to mapping of got functions to the request method.

Cache

A discussion can follow to decide whether or not the framework should put its own cache into the http client or give the ability to pass a custom data store. As a consumer of the framework, I would be fine with both options as long as the framework gives me a way to read and write cached data.

[ukaoskid]

I agree with the idea of having the dev teams decide the HTTP client lib and implementation that better fits the need.
However, my thought is to leverage the already existing pattern of the custom providers. What we should do, actually, is provide a common interface to implement, which will look like that:

@Injectable()
export class CustomHttpClient implements HttpClientInterface {
}

@Module({
  modules: [RandomModule],
  controllers: [TestController],
  providers: [
    { provider: HTTP_CLIENT, useClass: CustomHttpClient }
  ]
})
export class TestRootModule { }

Or directly from the injectable class:

@Injectable({ interface: HTTP_CLIENT })
export class CustomHttpClient implements HttpClientInterface {
}

The usage, like already happens for the CacheManager, can continue to happen through the abstract HttpService, which will have injected either the custom provider or the default choice of the framework.

@Injectable()
export class TestService {
  constructor(private readonly httpService: HttpService) {
  }
}

[alesmit]

Closing due to functionality already available via custom providers