javascript - Cómo interceptar llamadas HTTP salientes y establecer el token JWT en un microservicio de Nestjs

Estoy desarrollando un microservicio Nestjs y necesito analizar el JWT entrante en la solicitud para las solicitudes HTTP salientes, pero parece que no hay una manera más limpia de hacerlo, o ¿me estoy perdiendo de algo? Esto es lo que he hecho hasta ahora

Nota: Usando el cliente http axios de nestjs

usuario.controlador.ts

@Controller('/users')
export class UserController {
   constructor(private userService: userService,
      private vehicleService: VehicleService){}

   @Post()
   create(@Req() req: Request, @Body() userData: userData) {
    // I can get the JWT token from here
    // fetch some data from different micro-service
     const d = this.vehicleService.getVehicleById(userData.vehicleId, req.headers['authorization'])
    // save user
   }
}

vehicle.service.ts

@Injectable() export class VehicleService { basePath=http://ms-vehicles/api/v1/vehicles;

  constructor(private httpService: HttpService) {}

  getVehicleById(vehicleId: string, token: string) {
    return this.httpSerice.get(this.basePath + '/' + vehicleId,
     {headers: {Authorization: token});
  }
}

Podemos interceptar las llamadas HTTP salientes usando un interceptor de axios, pero ¿cómo puedo establecer el token correcto desde allí, sin pasar el token a través del controlador y el servicio como un parámetro?

Encontré la siguiente solución en Stack Overflow y no estoy seguro de que esta sea la manera correcta de hacerlo.

interceptor

@Injectable()
export class HttpServiceInterceptor implements NestInterceptor {
  constructor(private httpService: HttpService) {}
  intercept(context: ExecutionContext, next: CallHandler): Observable<any> {
  
    // ** if you use normal HTTP module **
    const ctx = context.switchToHttp();
    const token = ctx.getRequest().headers['authorization'];

    // ** if you use GraphQL module **
    const ctx = GqlExecutionContext.create(context);
    const token = ctx.getContext().token;

    if (ctx.token) {
      this.httpService.axiosRef.defaults.headers.common['authorization'] =
        token;
    }
    return next.handle().pipe();
  }
}

Registrar el interceptor en el módulo principal como uno global

@Module({
  providers: [
    {
      provide: APP_INTERCEPTOR,
      useClass: HttpServiceInterceptor,
    },
  ],
})
export class AppModule {}

si uso la solución anterior, ¿podemos garantizar que el token de otra persona no se utilizará en otras solicitudes, porque estos encabezados comunes están disponibles en cualquier lugar donde usemos httpService? o ¿estoy equivocado?