Tipo do parâmetro no GlobalErrorHandler: handleError(error :any) | Angular parte 4: lapidando o projeto

Blz pessoal, estou tentando tipificar alguns erros com as respostas http com o GlobalErrorHandler, mas estou enfrentando uma situação curiosa.

Sei que quando declaro no module:

 providers:[{
    provide:ErrorHandler,
    useClass:GlobalErrorHandler
  }]

Eu falo pro angular usar o meu error handler no lugar do padrão para interceptar os erros da aplicação. Por isso o método handleError tem um parâmetro do tipo any.

Mas imprimindo esse objeto do parâmetro de handleError na console eu percebi que para os erros de http ele possui as propriedades name e message.

Na propriedade name está preenchido a string Error, e na message a string com o erro de fato: error.message ---> Uncaught (in promise): HttpErrorResponse: {"headers":{"normalizedNames":{},"lazyUpdate":null},"status":409,"statusText":"Conflict","url"....

Então eu acabo fazendo uma conversão com essa string:

handleError(error:Error): void {
console.log('-----error----->',error)
        let httpErrorResponse = JSON.parse(
            error.message.replace('Uncaught (in promise): HttpErrorResponse:','')
            ) as HttpErrorResponse;
}

É possível obter esse objeto de maneira "mais sofisticada" para eu poder transformar em HttpErrorResponse? pq acabei fazendo uma solução bem ruim removendo a string na mão.

Já tentei tbm verificar o tipo do objeto mas n tive sucesso tbm:

if (error instanceof ErrorEvent) {
            console.log('error instanceof ErrorEvent')
}
if(error instanceof Promise){
            console.log(' Promise Promise ------>>>>>',error)
}
if(error instanceof HttpErrorResponse){
            console.log('------>>>>>',error)
}
if(error instanceof HttpResponse){
            console.log('HttpResponse ------>>>>>',error)
}

Obs: Já tentei explicitar isso no handleError(error:HttpErrorResponse) na esperança de rolar uma chamada tipada ao método mas sem sucesso.

Alguma ideia?

Fala aí Danilo, tudo bem? Consegue postar o código completo?

Normalmente, podemos usar a classe HttpErrorResponse da qual temos funções bem legais:

public intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    if (isLogged()) {
        const token = getToken()
        const reqWithHeader = req.clone({
            setHeaders: {
                Authorization: token
            }
        })
        return next.handle(reqWithHeader).pipe(
            tap(null, (event: HttpEvent<any>) => {
                if (event instanceof HttpErrorResponse) {
                    if (event.status === httpCodes.CODE_401) {
                        this.eventService.emit(events.LOGOUT)
                        this.router.navigate([routes.login])
                    }
                }
            })
        )
    }
    return next.handle(req)
}

Basicamente é um código para setar o token quando estiver logado e verificar se o mesmo está válida durante as próximas chamadas.

Caso esteja inválido e der erro 401 vai mandar para o login novamente.

Espero ter ajudado.