@nestjs/microservices/client/client-mqtt.js

Nest - modern, fast, powerful node.js web framework (@microservices)

import { createRequire } from 'module';
import { EmptyError, fromEvent, lastValueFrom, merge } from 'rxjs';
import { first, map, share, tap } from 'rxjs/operators';
import { ECONNREFUSED, ENOTFOUND, MQTT_DEFAULT_URL } from '../constants.js';
import { MqttRecord, } from '../record-builders/mqtt.record-builder.js';
import { MqttRecordSerializer } from '../serializers/mqtt-record.serializer.js';
import { ClientProxy } from './client-proxy.js';
import { Logger } from '@nestjs/common';
import { loadPackageSync, isObject } from '@nestjs/common/internal';
let mqttPackage = {};
/**
 * @publicApi
 */
export class ClientMqtt extends ClientProxy {
    options;
    logger = new Logger(ClientProxy.name);
    subscriptionsCount = new Map();
    url;
    /* eslint-disable @typescript-eslint/no-redundant-type-constituents */
    mqttClient = null;
    connectionPromise = null;
    isInitialConnection = false;
    isReconnecting = false;
    pendingEventListeners = [];
    constructor(options) {
        super();
        this.options = options;
        this.url = this.getOptionsProp(this.options, 'url') ?? MQTT_DEFAULT_URL;
        mqttPackage = loadPackageSync('mqtt', ClientMqtt.name, () => createRequire(import.meta.url)('mqtt'));
        this.initializeSerializer(options);
        this.initializeDeserializer(options);
    }
    getRequestPattern(pattern) {
        return pattern;
    }
    getResponsePattern(pattern) {
        return `${pattern}/reply`;
    }
    async close() {
        if (this.mqttClient) {
            await this.mqttClient.endAsync();
        }
        this.mqttClient = null;
        this.connectionPromise = null;
        this.pendingEventListeners = [];
    }
    async connect() {
        if (this.mqttClient) {
            return this.connectionPromise;
        }
        this.mqttClient = this.createClient();
        this.registerErrorListener(this.mqttClient);
        this.registerOfflineListener(this.mqttClient);
        this.registerReconnectListener(this.mqttClient);
        this.registerConnectListener(this.mqttClient);
        this.registerDisconnectListener(this.mqttClient);
        this.registerCloseListener(this.mqttClient);
        this.pendingEventListeners.forEach(({ event, callback }) => this.mqttClient.on(event, callback));
        this.pendingEventListeners = [];
        const connect$ = this.connect$(this.mqttClient);
        this.connectionPromise = lastValueFrom(this.mergeCloseEvent(this.mqttClient, connect$).pipe(share())).catch(err => {
            if (err instanceof EmptyError) {
                return;
            }
            throw err;
        });
        return this.connectionPromise;
    }
    mergeCloseEvent(instance, source$) {
        const close$ = fromEvent(instance, "close" /* MqttEventsMap.CLOSE */).pipe(tap({
            next: () => {
                this._status$.next("closed" /* MqttStatus.CLOSED */);
            },
        }), map((err) => {
            throw err;
        }));
        return merge(source$, close$).pipe(first());
    }
    createClient() {
        return mqttPackage.connect(this.url, this.options);
    }
    registerErrorListener(client) {
        client.on("error" /* MqttEventsMap.ERROR */, (err) => {
            if (err.code === ECONNREFUSED || err.code === ENOTFOUND) {
                return;
            }
            this.logger.error(err);
        });
    }
    registerOfflineListener(client) {
        client.on("offline" /* MqttEventsMap.OFFLINE */, () => {
            this.connectionPromise = Promise.reject('Error: Connection lost. Trying to reconnect...');
            // Prevent unhandled rejections
            this.connectionPromise.catch(() => { });
            this.logger.error('MQTT broker went offline.');
        });
    }
    registerReconnectListener(client) {
        client.on("reconnect" /* MqttEventsMap.RECONNECT */, () => {
            this.isReconnecting = true;
            this._status$.next("reconnecting" /* MqttStatus.RECONNECTING */);
            this.logger.log('MQTT connection lost. Trying to reconnect...');
        });
    }
    registerDisconnectListener(client) {
        client.on("disconnect" /* MqttEventsMap.DISCONNECT */, () => {
            this._status$.next("disconnected" /* MqttStatus.DISCONNECTED */);
        });
    }
    registerCloseListener(client) {
        client.on("close" /* MqttEventsMap.CLOSE */, () => {
            this._status$.next("closed" /* MqttStatus.CLOSED */);
        });
    }
    registerConnectListener(client) {
        client.on("connect" /* MqttEventsMap.CONNECT */, () => {
            this.isReconnecting = false;
            this._status$.next("connected" /* MqttStatus.CONNECTED */);
            this.logger.log('Connected to MQTT broker');
            this.connectionPromise = Promise.resolve();
            if (!this.isInitialConnection) {
                this.isInitialConnection = true;
                client.on('message', this.createResponseCallback());
            }
        });
    }
    on(event, callback) {
        if (this.mqttClient) {
            this.mqttClient.on(event, callback);
        }
        else {
            this.pendingEventListeners.push({ event, callback });
        }
    }
    unwrap() {
        if (!this.mqttClient) {
            throw new Error('Not initialized. Please call the "connect" method first.');
        }
        return this.mqttClient;
    }
    createResponseCallback() {
        return async (channel, buffer) => {
            let packet;
            try {
                packet = JSON.parse(buffer.toString());
            }
            catch (err) {
                this.logger.debug('MQTT response packet is not in json format, bypassing...');
                packet = buffer.toString();
            }
            const { err, response, isDisposed, id } = await this.deserializer.deserialize(packet);
            const callback = this.routingMap.get(id);
            if (!callback) {
                return undefined;
            }
            if (isDisposed || err) {
                return callback({
                    err,
                    response,
                    isDisposed: true,
                });
            }
            callback({
                err,
                response,
            });
        };
    }
    publish(partialPacket, callback) {
        try {
            const packet = this.assignPacketId(partialPacket);
            const pattern = this.normalizePattern(partialPacket.pattern);
            const responseChannel = this.getResponsePattern(pattern);
            let subscriptionsCount = this.subscriptionsCount.get(responseChannel) || 0;
            const publishPacket = () => {
                subscriptionsCount = this.subscriptionsCount.get(responseChannel) || 0;
                this.subscriptionsCount.set(responseChannel, subscriptionsCount + 1);
                this.routingMap.set(packet.id, callback);
                const options = isObject(packet?.data) && packet.data instanceof MqttRecord
                    ? packet.data.options
                    : undefined;
                delete packet?.data?.options;
                const serializedPacket = this.serializer.serialize(packet);
                this.mqttClient.publish(this.getRequestPattern(pattern), serializedPacket, this.mergePacketOptions(options));
            };
            if (subscriptionsCount <= 0) {
                this.mqttClient.subscribe(responseChannel, (err) => !err && publishPacket());
            }
            else {
                publishPacket();
            }
            return () => {
                this.unsubscribeFromChannel(responseChannel);
                this.routingMap.delete(packet.id);
            };
        }
        catch (err) {
            callback({ err });
            return () => { };
        }
    }
    dispatchEvent(packet) {
        const pattern = this.normalizePattern(packet.pattern);
        const options = isObject(packet?.data) && packet.data instanceof MqttRecord
            ? packet.data.options
            : undefined;
        delete packet?.data?.options;
        const serializedPacket = this.serializer.serialize(packet);
        return new Promise((resolve, reject) => this.mqttClient.publish(pattern, serializedPacket, this.mergePacketOptions(options), (err) => (err ? reject(err) : resolve())));
    }
    unsubscribeFromChannel(channel) {
        const subscriptionCount = this.subscriptionsCount.get(channel);
        this.subscriptionsCount.set(channel, subscriptionCount - 1);
        if (subscriptionCount - 1 <= 0) {
            this.mqttClient.unsubscribe(channel);
        }
    }
    initializeSerializer(options) {
        this.serializer = options?.serializer ?? new MqttRecordSerializer();
    }
    mergePacketOptions(requestOptions) {
        if (!requestOptions && !this.options?.userProperties) {
            return undefined;
        }
        // Cant just spread objects as MQTT won't deliver
        // any message with empty object as "userProperties" field
        // @url https://github.com/nestjs/nest/issues/14079
        let options = {};
        if (requestOptions) {
            options = { ...requestOptions };
        }
        if (this.options?.userProperties) {
            options.properties = {
                ...options.properties,
                userProperties: {
                    ...this.options?.userProperties,
                    ...options.properties?.userProperties,
                },
            };
        }
        return options;
    }
}