nest_microservice_wait_for_other_apps_to_be_online

import {createServer} from 'node:net'
import {IsNumber, IsOptional, IsString, Max, Min} from 'class-validator'
import {PortCheckDto} from '../dto/port-check.dto'

export class PortCheckDto {
    @IsString()
    @IsOptional()
    host?: string = 'localhost'

    /**
     * Smallest port number is `0`, although it is reserverd by IANA.
     *
     * Largest port number is an unsigned short (`65335`).
     */
    @IsNumber()
    @Min(0)
    @Max(65335)
    port: number
}

export class PortCheckErrorDto extends PortCheckDto {
    error: any
    status: 'failure' | 'open'
}

/**
 * Determines whether the specified port on a host is used
 *
 * @param    dto - DTO
 * @returns  `true` if port is used (on `EADDRINUSE` or `EACCES` errors), `false` if port is open, `null` on other errors.
 */
export async function isPortUsed(dto: PortCheckDto): Promise<boolean> {
    return new Promise((resolve, reject) => {
        const server = createServer()

        const onError = (e: {code: string}): void => {
            server.removeListener('listening', onListen)
            server.close()

            if (e.code == 'EADDRINUSE' || e.code == 'EACCES') {
                return resolve(true)
            } else {
                return reject({
                    ...dto,
                    error: e,
                    status: 'failure'
                })
            }
        }

        const onListen = (): void => {
            server.removeListener('error', onError)
            server.close()
            return reject({
                ...dto,
                status: 'open'
            })
        }

        server.once('error', onError)
        server.once('listening', onListen)
        server.once('error', onError)
        server.once('listening', onListen)

        server.listen(...Object.values(dto))
    })
}

/////////

// Example `main.ts`
import {NestFactory} from '@nestjs/core'
import {MicroserviceOptions, Transport} from '@nestjs/microservices'

import {CacheModule} from './cache/cache.module'

// Add additional array items with variables for other microservices on which current app depends
const portDepends = [
    {host: 'localhost', port: 1234}
]

// How long should we wait before checking if the dependecies are up
const waitTime = 1000

async function bootstrap(): Promise<void> {
    const interval = setInterval(async () => {
        try {
            await Promise.all(portDepends.map(port => isPortUsed(port)))
            clearInterval(interval)
            const app = await NestFactory.createMicroservice<MicroserviceOptions>(CacheModule, CACHE_TCP)
            app.useLogger(logger)
            await app.listen()
        } catch (e) {
            const err = e as PortCheckErrorDto
            console.warn(`Microservice on '${err?.host ? `${err.host}:` : ''}${err.port}' is offline.`)
        }
    }, waitTime)
}

bootstrap().catch(e => console.log(e))