How to use the @nestjs/websockets.WebSocketGateway function in @nestjs/websockets

import {
  SubscribeMessage,
  WebSocketGateway,
  WebSocketServer
} from '@nestjs/websockets'
import { Socket, Server } from 'socket.io'
// Service
import { TextService } from '../services'

@WebSocketGateway()
export class TextGateway {
  constructor(private textService: TextService) {}
  @WebSocketServer()
  io: Server

  @SubscribeMessage('text')
  async handleText(client: Socket, data: { data: { id: string } }) {
    try {
      const response = await this.textService.getText(data.data.id)
      client.emit('text/' + data.data.id, response)
    } catch (error) {
      console.error(error)
    }
  }

  @SubscribeMessage('texts')

import { Logger } from '@nestjs/common';
import {
  WebSocketGateway,
  WebSocketServer,
  OnGatewayConnection,
  OnGatewayDisconnect,
} from '@nestjs/websockets';

@WebSocketGateway(4001, { transport: ['websocket'] })
export class AppGateway implements OnGatewayConnection, OnGatewayDisconnect {
  @WebSocketServer()
  wss;

  private logger = new Logger('AppGateway');

  handleConnection(client) {
    this.logger.log('New client connected');
    client.emit('connection', 'Successfully connected to server');
  }

  handleDisconnect(client) {
    this.logger.log('Client disconnected');
  }
}

import { Get, Controller } from '@nestjs/common';
import { WebSocketGateway, SubscribeMessage, WebSocketServer } from '@nestjs/websockets';
import { HunliDiscussService, HunliFuyueService } from './hunli_discuss.service';

@WebSocketGateway({ port: 1314 })
export class AppGeteway {
  @WebSocketServer() server;

  constructor(private hunli: HunliDiscussService, private fuyue: HunliFuyueService) {

  }

  @SubscribeMessage('hunli.discuss')
  async handelHunliDiscuss(sender, data) {
    const list = await this.hunli.findAll();
    sender.emit('hunli.discuss', list);
  }

  @SubscribeMessage('hunli.discuss.add')
  async handelHunliDiscussAdd(sender, data) {
    const item = await this.hunli.addOne(data);

import {
	OnGatewayConnection,
	OnGatewayDisconnect,
	OnGatewayInit,
	SubscribeMessage,
	WebSocketGateway,
	WebSocketServer
} from '@nestjs/websockets';
import { LoggerService } from '@nestjs/common';
import { v4 } from 'uuid';
import { AppLogger } from './app.logger';

@WebSocketGateway()
export class AppGateway implements OnGatewayInit, OnGatewayConnection, OnGatewayDisconnect {

	@WebSocketServer() server;

	private logger: LoggerService;

	constructor() {
		this.logger  = new AppLogger(AppGateway.name);
	}


	@SubscribeMessage('message')
	handleMessage(sender, data) {
		this.logger.log(`New socket message: ${data}`);
	}

import { AuthenticationGatewayMiddleware } from '../../shared/middlewares/authentication.gateway.middleware';
import { CommentService } from '../../modules/comment/comment.service';
import { SubscribeMessage, WebSocketGateway, WebSocketServer, WsException, WsResponse } from '@nestjs/websockets';

@WebSocketGateway({
    middlewares: [AuthenticationGatewayMiddleware]
})
export class CommentGateway {
    @WebSocketServer() server;

    constructor(private readonly commentService: CommentService) { }

    @SubscribeMessage('indexComment')
    async index(client, data): Promise> {
        if (!data.entryId) throw new WsException('Missing entry id.');

        const comments = await this.commentService.findAll({
            where: {entryId: data.entryId}
        });

        return { event: 'indexComment', data: comments };

import { SubscribeMessage, WebSocketGateway } from '@nestjs/websockets';

@WebSocketGateway()
export class ServerGateway {
  @SubscribeMessage('push')
  onPush(client, data) {
    return {
      event: 'pop',
      data,
    };
  }
}

import {
  MessageBody,
  SubscribeMessage,
  WebSocketGateway,
} from '@nestjs/websockets';

@WebSocketGateway(8080)
export class ApplicationGateway {
  @SubscribeMessage('push')
  onPush(@MessageBody() data) {
    return {
      event: 'pop',
      data,
    };
  }
}

import {
  SubscribeMessage,
  WebSocketGateway,
  WebSocketServer
} from '@nestjs/websockets'
import { Socket, Server } from 'socket.io'
import { UserService, AuthService } from '../services'
import { Inject } from '@nestjs/common'
import { withTryCatch, withResponse, withAuthentication } from '../common'
import { IMessage } from '../../../interfaces'

@WebSocketGateway()
export class UserGateway {
  constructor(
    @Inject('UserService')
    private readonly userService: UserService,
    @Inject('AuthService')
    private readonly authService: AuthService
  ) {}

  @WebSocketServer()
  io: Server

  @SubscribeMessage('user')
  @withResponse('user')
  @withTryCatch
  @withAuthentication
  async handlerUser(client: Socket, message: IMessage<{}>) {

import { Bar, Symbol } from '@dripjs/types';
import { UseFilters, UseGuards } from '@nestjs/common';
import { OnGatewayDisconnect, SubscribeMessage, WebSocketGateway, WsResponse } from '@nestjs/websockets';
import { Observable } from 'rxjs';
import { map } from 'rxjs/operators';

import { IntelServiceExceptionFilter } from '../exceptions';
import { AuthGuard } from '../guards';
import { GetBarsInput, IntelRealtimeResponse, RealtimeInput } from '../types';
import { IntelService } from './intel.service';

@WebSocketGateway()
@UseGuards(AuthGuard)
@UseFilters(IntelServiceExceptionFilter)
export class IntelGateway implements OnGatewayDisconnect {
  constructor(private readonly interService: IntelService) {}

  handleDisconnect(_: any): void {
    this.interService.close();
  }

  @SubscribeMessage('symbols')
  async symbols(_: any, exchange: string): Promise {
    return this.interService.getSymbols(exchange);
  }

  @SubscribeMessage('bars')
  async bars(_: any, input: GetBarsInput): Promise {

import { UseFilters, UseGuards } from '@nestjs/common';
import { SubscribeMessage, WebSocketGateway, WsResponse } from '@nestjs/websockets';
import { Observable, from } from 'rxjs';
import { map } from 'rxjs/operators';

import { IntelGetSymbolsResponse } from '../common';
import { IntelServiceExceptionFilter } from '../exceptions';
import { AuthGuard } from '../guards';
import { IntelService } from './intel.service';

@WebSocketGateway()
@UseGuards(AuthGuard)
@UseFilters(IntelServiceExceptionFilter)
export class IntelGateway {
  constructor(private readonly interService: IntelService) {}

  @SubscribeMessage('events')
  findAll(client: any, data: any): Observable> {
    return from([1, 2, 3]).pipe(map((item) => ({ event: 'events', data: item })));
  }

  @SubscribeMessage('identity')
  async identity(client: any, data: number): Promise {
    return 123;
  }

  @SubscribeMessage('symbols')