Como lançar o erro do operador de mapa RxJS (angular)

Quero lançar um erro do operador de mapa do meu observável com base em uma condição. Por exemplo, se os dados API corretos não forem recebidos. Por favor, veja o seguinte código:

private userAuthenticate( email: string, password: string ) {
    return this.httpPost(`${this.baseApiUrl}/auth?format=json&provider=login`, {userName: email, password: password})
        .map( res => { 
            if ( res.bearerToken ) {
                return this.saveJwt(res.bearerToken); 
            } else {
                // THIS DOESN'T THROW ERROR --------------------
                return Observable.throw('Valid token not returned');
            }
        })
        .catch( err => Observable.throw(this.logError(err) )
        .finally( () => console.log("Authentication done.") );
}

Basicamente, como você pode ver no código, se a resposta (objeto res) não tiver 'bearerToken', quero exibir um erro. Para que na minha assinatura vá para o segundo parâmetro (handleError) mencionado abaixo.

.subscribe(success, handleError)

Alguma sugestão?

Basta jogar o erro dentro do map()operador. Todos os retornos de chamada em RxJS são agrupados com blocos try-catch para que sejam capturados e enviados como uma errornotificação.

Isso significa que você não retorna nada e apenas lança o erro:

map(res => { 
  if (res.bearerToken) {
    return this.saveJwt(res.bearerToken); 
  } else {
    throw new Error('Valid token not returned');
  }
})

o throwError() (antigo Observable.throw()em RxJS 5) é um Observable que apenas envia uma errornotificação, mas map()não se importa com o que você retorna. Mesmo se você retornar um Observável map()dele, será passado como uma nextnotificação.

Por último, você provavelmente não precisa usar .catchError()(antigo catch()em RxJS 5). Se você precisar realizar algum efeito colateral quando ocorrer um erro, é melhor usar tap(null, err => console.log(err))(antigo do()em RxJS 5), por exemplo.

Janeiro de 2019: Atualizado para RxJS 6

Se você sentir que throw new Error()parece não observável, você pode usar throwError(...)com em switchMapvez de map(a diferença sendo switchMapretorna um novo observável):

// this is the import needed for throwError()
import { throwError } from 'rxjs';


// RxJS 6+ syntax
this.httpPost.pipe(switchMap(res => { 
   if (res.bearerToken) {
      return of(this.saveJwt(res.bearerToken)); 
   } 
   else {
      return throwError('Valid token not returned');  // this is 
   }
});

ou mais concisamente:

this.httpPost.pipe(switchMap(res => (res.bearerToken) ? 
                                    of(this.saveJwt(res.bearerToken)) : 
                                    throwError('Valid token not returned')
));

O comportamento será o mesmo, é apenas uma sintaxe diferente.

Você está literalmente dizendo 'mudar' do http observável no tubo para um observável diferente, que está apenas 'envolvendo' o valor de saída ou um novo 'erro' observável.

Não se esqueça de colocar ofou você receberá algumas mensagens de erro confusas.

Além disso, a beleza de 'switchMap' é que você pode retornar uma nova 'cadeia' de comandos se quiser - para qualquer lógica que precise ser feita saveJwt.

Mesmo que essa pergunta já tenha sido respondida, eu gostaria de compartilhar minha própria abordagem (embora seja apenas ligeiramente diferente da anterior).

Eu decidiria o que é retornado separado do mapeamento e vice-versa. Não tenho certeza de qual operadora é melhor para isso, então vou usar tap.

this.httpPost.pipe(
  tap(res => { 
    if (!res.bearerToken) {
      throw new Error('Valid token not returned');
    }
  }),
  map(res => this.saveJwt(res.bearerToken)),
);