Custom Transporters in NestJS

//src/custom.transporter.ts

import {
    ClientProxy,
    ReadPacket,
    WritePacket,
    CustomTransportStrategy,
} from '@nestjs/microservices';
import { Logger } from '@nestjs/common';

export class CustomTransporter
    extends ClientProxy
    implements CustomTransportStrategy {
    private readonly logger = new Logger(CustomTransporter.name);

    constructor(private readonly options: any) {
        super();
    }

    async connect(): Promise<void> {
        this.logger.log('Custom Transporter connected...');
        // Implement your connection logic here
    }

    async close(): Promise<void> {
        this.logger.log('Custom Transporter closed...');
        // Implement your close logic here
    }

    listen(callback: () => void): void {
        this.logger.log('Custom Transporter is listening...');
        // Implement your custom transport logic here
        callback();
    }

    protected dispatchEvent(packet: ReadPacket<any>): Promise<any> {
        this.logger.log(`Dispatch event: ${JSON.stringify(packet)}`);
        // Implement your dispatch event logic here
        return Promise.resolve();
    }

    protected publish(
        packet: ReadPacket<any>,
        callback: (packet: WritePacket<any>) => void,
    ): () => void {
        this.logger.log(`Publish event: ${JSON.stringify(packet)}`);
        // Simulate an immediate response for testing purposes
        callback({ response: 'response' });
        return () => { };
    }
}

//main.ts

import { NestFactory } from '@nestjs/core';
import { AppModule } from './app.module';
import { CustomTransporter } from './custom.transporter';
import { MicroserviceOptions } from '@nestjs/microservices';

async function bootstrap() {
    const app = await NestFactory.create(AppModule);

    app.connectMicroservice<MicroserviceOptions>({
        strategy: new CustomTransporter({
            /* Custom options */
        }),
    });

    await app.startAllMicroservices();
    await app.listen(3000);
}
bootstrap();

//app.module.ts

import { Module } from '@nestjs/common';
import { AppController } from './app.controller';
import { AppService } from './app.service';
import { AppGateway } from './app.gateway';

@Module({
    imports: [],
    controllers: [AppController],
    providers: [AppService, AppGateway],
})
export class AppModule { }

//app.controller.ts

import { Controller, Get } from '@nestjs/common';
import {
    ClientProxy,
    ClientProxyFactory,
    CustomClientOptions,
} from '@nestjs/microservices';
import { CustomTransporter } from './custom.transporter';

@Controller()
export class AppController {
    private client: ClientProxy;

    constructor() {
        const customClientOptions: CustomClientOptions = {
            customClass: CustomTransporter,
            options: {
                /* Custom options */
            },
        };
        this.client = ClientProxyFactory.create(customClientOptions);
    }

    @Get()
    async sendMessage() {
        const pattern = { cmd: 'custom_message' };
        const data = { text: 'Hello from custom transporter' };
        const response = await this.client.send(pattern, data).toPromise();
        return response;
    }

    @Get('custom-message')
    async getCustomMessage() {
        const pattern = { cmd: 'custom_message' };
        const data = { text: 'Hello from custom transporter' };
        const response = await this.client.send(pattern, data).toPromise();
        return response;
    }
}

//app.gateway.ts

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

@WebSocketGateway()
export class AppGateway {
    @SubscribeMessage('message')
    handleMessage(@MessageBody() message: string): string {
        return message;
    }
}

//app.service.ts

import { Injectable } from '@nestjs/common';

@Injectable()
export class AppService {
    getHello(): string {
        return 'Hello World!';
    }
}