header in datasource-rest about datasource-rest HOT 5 CLOSED

didReceiveResponse<TResult = any>(response: any, request: Request): Promise<any> {   
    const parent = super.didReceiveResponse.bind(this);

    return new Promise(async (resolve) => {
      const body = await parent<TResult>(response, request);

      return resolve({
        body,
        req: request,
      })
    });
  }

const { req, body } = await this.get<MyType>('/uri'); // Error
// I changed to

const { req, body } = await this.get('/uri');

return body as MyType;

// Interface with response, like axios
interface ResponseInterface<T = any>  {
  data: T;
  status: number;
  headers: any;
  request?: any;
}

class BaseAPIDataSource extends RESTDataSource {
  didReceiveResponse(response: any, request: Request): Promise<any> {
    // I'm getting some metrics here to prometheus
    return this.formatResponse(response, request);
  }

  async formatResponse(response: any, request: Request): Promise<ResponseInterface> {
    if (response.status >= 500) {
      await super.didReceiveResponse(response, request);
    }
    const data = await this.parseBody(response);
    return {
      data,
      status: response.status,
      headers: response.headers,
      request,
    };
  }

  // Now I'm overloading the parent methods only changing the type response
  
  protected async get<TResult = any, R = ResponseInterface<TResult>>(
    path: string,
    params?: URLSearchParamsInit,
    init?: RequestInit,
  ): Promise<R> {
    return super.get(path, params, init);
  }

  protected async put<TResult = any, R = ResponseInterface<TResult>>(
    path: string,
    body?: Body,
    init?: RequestInit,
  ): Promise<R> {
    return super.put(path, body, init);
  }

  protected async post<TResult = any, R = ResponseInterface<TResult>>(
    path: string,
    body?: Body,
    init?: RequestInit,
  ): Promise<R> {
    return super.post(path, body, init);
  }

  protected async patch<TResult = any, R = ResponseInterface<TResult>>(
    path: string,
    body?: Body,
    init?: RequestInit,
  ): Promise<R> {
    return super.patch(path, body, init);
  }

  protected async delete<TResult = any, R = ResponseInterface<TResult>>(
    path: string,
    params?: URLSearchParamsInit,
    init?: RequestInit,
  ): Promise<R> {
    return super.delete(path, params, init);
  }
}

  const { data, headers, status } = await this.get<MyCustomType>('/my/path', { page: 1 });

  console.log(data, headers, status);