Ricardo Mello. Engenheiro full-stack sênior, pirado em performance e AI

← artigos angular · frontend 4 min

Angular: Estendendo o HttpClient e criando Interceptors dinâmicos

Escrito em 2018. Algumas coisas aqui podem ter mudado.

Alpinista de jaqueta vermelha escalando uma encosta de gelo com uma picareta

Era uma sexta-feira, eu tinha acabado minha tarefa e parei pra consertar um tal “loader” que bloqueava a tela ao digitar nos campos de autocomplete. Esse loader era um interceptor exibido a cada Request.

Se tratando de uma arquitetura recém construída, seria simples resolver o problema: Remove o loader de lá e faz o componente controlar o coitado, já que cada componente sabe de suas necessidades. OOOOUUU, encapsula o HttpClient em uma classe sua e adicione as suas próprias mágicas dentro dela.

Porém, pela proporção “páginas que precisariam ser completamente refatoradas” versus “oculta o loader desse campinho aqui”, a solução mais rápida foi desabilitar o loader somente nos campos de autocomplete, pois todos nós temos um prazo. Nosso projeto também.

P.S.: Apesar do motivo, essa solução pode se aplicar a adicionar/remover caminhos de API, controlar o cache ou se o token de autenticação deve ser utilizado ou não.

Meme do Ned Stark (Game of Thrones): “Finish your project, deadline is coming”

A primeira alternativa

A primeira alternativa foi a mais simples porém a menos elaborada: adiciona um param “hideLoader” e usa ele pra dizer se o loader pode ser exibido ou não. Porém, procurando nas issues do Angular, já existia uma pra isso (#18155), e a galera não curtiu muito essa ideia por conta de enviar os dados pro servidor.

Pesquisando um pouco mais, cheguei à solução do ngx-rocket, que estendeu o HttpClient em uma nova classe e passou a responder no lugar dele adicionando seus próprios métodos. Não sei se o que me atraiu foi a criatividade, a complexidade, ou o fato de eu poder mapear todos os lugares que usam os métodos customizados sem muito esforço (vai que a feature é incluída no Angular 7 e eu tenho que refatorar tudo), mas é dessa solução que a gente vai falar aqui.

Estendendo o módulo

O Typescript tem um recurso bem interessante em que é possível estender um módulo. No nosso caso, vamos estender o módulo e exportar a interface HttpClient já com os métodos customizados. Para isso, vamos criar o arquivo http.service.ts com o seguinte conteúdo:

http.service.ts
declare module '@angular/common/http/src/client' {

  export interface HttpClient {
    hideLoader(hide?: boolean): HttpClient;
  }

}

Customizando Interceptors

Aqui, vamos encadear a chamada dos interceptors e permitir a customização deles:

http.service.ts
import { InjectionToken } from '@angular/core';
import { HttpClient, HttpEvent, HttpInterceptor, HttpHandler, HttpRequest } from '@angular/common/http';
import { Observable } from 'rxjs';

declare module '@angular/common/http/src/client' {

  export interface HttpClient {
    hideLoader(hide?: boolean): HttpClient;
  }

}

class HttpInterceptorHandler implements HttpHandler {

  constructor(private next: HttpHandler, private interceptor: HttpInterceptor) { }

  handle(request: HttpRequest<any>): Observable<HttpEvent<any>> {
    return this.interceptor.intercept(request, this.next);
  }

}

export const HTTP_DYNAMIC_INTERCEPTORS = new InjectionToken<HttpInterceptor>('HTTP_DYNAMIC_INTERCEPTORS');

O HttpClient, digo… o nosso Service

Ainda no nosso HttpService, vamos criar a classe que dá nome a ele. O método hideLoader é o responsável por desabilitar o interceptor de loader. Já o request, sobrescreve o método original para utilizar os interceptors definidos no nosso array.

http.service.ts
@Injectable()
export class HttpService extends HttpClient {

  constructor(private httpHandler: HttpHandler,
              private injector: Injector,
              @Optional() @Inject(HTTP_DYNAMIC_INTERCEPTORS) private interceptors: HttpInterceptor[] = []) {
    super(httpHandler);

    if (!this.interceptors) {
      // Configure default interceptors that can be disabled here
      this.interceptors = [
        this.injector.get(LoaderInterceptor),
      ];
    }
  }

  // Disable loader interceptor
  hideLoader(hide: boolean = true): HttpClient {
    return hide
      ? this.removeInterceptor(LoaderInterceptor)
      : this;
  }

  // Override the original method to wire interceptors when triggering the request.
  request(method?: any, url?: any, options?: any): any {
    const handler = this.interceptors.reduceRight(
      (next, interceptor) => new HttpInterceptorHandler(next, interceptor),
      this.httpHandler
    );
    return new HttpClient(handler).request(method, url, options);
  }

  private removeInterceptor(interceptorType: Function): HttpService {
    return new HttpService(
      this.httpHandler,
      this.injector,
      this.interceptors.filter(i => !(i instanceof interceptorType))
    );
  }

  private addInterceptor(interceptor: HttpInterceptor): HttpService {
    return new HttpService(
      this.httpHandler,
      this.injector,
      this.interceptors.concat([interceptor])
    );
  }

}

Registrando o Service

Vamos registrar o HttpService substituindo o HttpClient para que o mesmo seja injetado em todos os lugares que o HttpClient já é utilizado. No meu caso, eu registrei direto no app.module.ts:

app.module.ts
providers: [
  { provide: HttpClient, useClass: HttpService },
],

Utilizando

Por último, vamos utilizar o nosso método nos providers que chamam as URLs de autocomplete.

my-service.ts
public getAutoCompleteResult(term: string) {
  return this.httpClient
    .hideLoader()
    .get(`http://my-domain/api/autocomplete`);
}

Com isso, nós podemos utilizar métodos customizados no HttpClient e manter o resto da nossa aplicação funcionando, e também podemos rastrear onde eles foram utilizados caso ocorra alguma mudança na ferramenta.