auth - Cómo hacer que un módulo angular ignore el interceptor http agregado en un módulo central

jwt interceptor angular

Question

Tengo un módulo central con un HttpInterceptor para el manejo de autorizaciones e incluyo este módulo en AppModule, de esta manera todos los demás módulos que usan HttpClient están usando este interceptor.

@NgModule({
  imports: [],
  declarations: [],
  providers: [
    {
      provide: HTTP_INTERCEPTORS,
      useClass: AuthInterceptor,
      multi: true,
    },
  ]
})
export class CoreModule { }

¿Cómo hacer que un módulo omita el interceptor predeterminado?

@NgModule({
  imports: [
    CommonModule
  ],
  declarations: components,
  providers: [CustomService],
  exports: components,
})
export class ModuleWithoutInterceptorModule { }

Answer 1

Puedes usar HttpBackend.

Ejemplo:

import { HttpClient, ..., HttpBackend } from ''@angular/common/http'';

@Injectable()
export class TestService {

  private httpClient: HttpClient;

  constructor( handler: HttpBackend) { 
     this.httpClient = new HttpClient(handler);
  }
....

De esta manera, AuthInterceptor no intercepta el servicio.

Answer 2

Según esta sugerencia en GitHub, hemos implementado un encabezado simple para identificar las solicitudes que no deberían ser interceptadas. En el interceptor:

export const InterceptorSkipHeader = ''X-Skip-Interceptor'';

@Injectable()
export class SkippableInterceptor implements HttpInterceptor {

  intercept(req: HttpRequest<any>, next: HttpHandler): Observable<HttpEvent<any>> {
    if (req.headers.has(InterceptorSkipHeader)) {
      const headers = req.headers.delete(InterceptorSkipHeader);
      return next.handle(req.clone({ headers }));
    }

    ...  // intercept
  }

}

Luego, cuando quiera omitir la intercepción para una solicitud en particular:

const headers = new HttpHeaders().set(InterceptorSkipHeader, '''');

this.httpClient
    .get<ResponseType>(someUrl, { headers })
    ...

Tenga en cuenta que con este método, el servicio , no el interceptor, está eligiendo cuándo se aplica la lógica del interceptor; esto significa que los servicios deben "saber" algo acerca de los interceptores en su aplicación. Dependiendo de su caso de uso, podría ser mejor hacer que los interceptores decidan cuándo aplicar la lógica.