HttpClient variation with flexible output format parsing

HttpClient.ts

import * as http from 'http';
import * as https from 'https';
import got, { Got, ExtendOptions, Headers, CancelableRequest, Response } from 'got';
import CacheableLookup from 'cacheable-lookup';

import { decodeData, TypeOf, TSchema } from '../decoder';

export const DefaultHttpClientOptions = {
  keepAlive: true,
  maxSockets: 10,
  // rough guess: 10 open sockets for each agent is enough, keeping more
  // than a ten can become dangerous when http client amount increase
};

export const gotDefaultOptions = {
  urlPrefix: '',
  dnsCache: new CacheableLookup({
    maxTtl: 60 * 30, // 30 minutes
  }),
  context: { someContext: 'here' },
  handlers: [
    (options: any, next: Function) => {
      Error.captureStackTrace(options.context);
      return next(options);
    },
  ],
  hooks: {
    beforeError: [
      (error: any) => {
        error.source = error.options.context.stack.split('\n');
        return error;
      },
    ],
  },
  agent: {
    http: new http.Agent(DefaultHttpClientOptions),
    https: new https.Agent(DefaultHttpClientOptions),
  },
};

type GetOptions = {
  headers?: Headers;
};

type PostOptions = {
  headers?: Headers;
  body?: string | Buffer | undefined;
  json?: object;
};

/**
 * Class-wrapper for HttpClient (now it's got) responses and checking it`s schema
 * In case you need to implement new data serialization format, add methods for it`s processing here
 */
class HttpResponseWrapper {
  private _gotResponse: CancelableRequest<Response<string>>;

  constructor(gotResponse: CancelableRequest<Response<string>>) {
    this._gotResponse = gotResponse;
  }

  async json<S extends TSchema>(schema?: S): Promise<TypeOf<S>> {
    const data = await this._gotResponse.json();
    if (!schema) {
      return data;
    }

    return decodeData<S>(schema, data, 'httpClient');
  }
}

export class HttpClient {
  got: Got;

  constructor(options: Got | ExtendOptions) {
    this.got = got.extend({
      ...gotDefaultOptions,
      ...options,
    });
  }

  get(path: string, options?: GetOptions): HttpResponseWrapper {
    return new HttpResponseWrapper(this.got.get(path, options));
  }

  post(path: string, options?: PostOptions): HttpResponseWrapper {
    return new HttpResponseWrapper(this.got.post(path, options));
  }
}