Micro connection while validation jwt in middleware

[Bubuioc]

Hello i get a micro connection while validating jwt in my middleware.
Middleware itself:

export const WsAuthMiddleware = (
  socket: Socket,
  next: (err?: any) => void,
): void => {
  passport.authenticate(
    'jwt',
    { session: false },
    (err: unknown, user: IJwtSignPayload) => {
      if (err) {
        const errorResponse =
          err instanceof HttpException
            ? err.getResponse()
            : new InternalServerErrorException().getResponse();

        return next(errorResponse);
      }

      socket.handshake['user'] = user;

      next();
    },
  )(socket.request, {}, next);
};

It's using in adapter

export class SocketIOAdapter extends IoAdapter {
  private readonly configService: ConfigService;
  private readonly redisService: RedisService;
  private adapterConstructor: ReturnType<typeof createAdapter>;

  constructor(private readonly app: INestApplicationContext) {
    super(app);
    this.configService = this.app.get(ConfigService);
    this.redisService = this.app.get(RedisService);
    this._createClient();
  }

  private _createClient(): void {
    const streamName = this.configService.get<string>('redisConfig.streamName');
    const redisClient = this.redisService.getClient;
    this.adapterConstructor = createAdapter(redisClient, { streamName });
  }

  createIOServer(port: number, options?: ServerOptions): Server {
    const server: Server = super.createIOServer(port, {
      ...options,
      cors: {
        origin: (_req: any, callback: (arg0: null, arg1: boolean) => void) => {
          callback(null, true);
        },
        credentials: true,
      },
      transports: ['polling', 'websocket'],
      allowUpgrades: true,
      pingTimeout: 2000,
      pingInterval: 7000,
    });
    server.adapter(this.adapterConstructor);

    server.use(WsAuthMiddleware);

    return server;
  }
}

Is there a way to skip this?

[Shivam-Kathait]

instead of header send token in query and then extract like this socket.handshake.query.token