@machhub-dev/node-red-nodes 1.0.5

package/node_modules/mqtt/src/lib/handlers/ack.ts

@@ -0,0 +1,159 @@
+// Other Socket Errors: EADDRINUSE, ECONNRESET, ENOTFOUND, ETIMEDOUT.
+
+import { PacketHandler, ErrorWithReasonCode } from '../shared'
+
+export const ReasonCodes = {
+	0: '',
+	1: 'Unacceptable protocol version',
+	2: 'Identifier rejected',
+	3: 'Server unavailable',
+	4: 'Bad username or password',
+	5: 'Not authorized',
+	16: 'No matching subscribers',
+	17: 'No subscription existed',
+	128: 'Unspecified error',
+	129: 'Malformed Packet',
+	130: 'Protocol Error',
+	131: 'Implementation specific error',
+	132: 'Unsupported Protocol Version',
+	133: 'Client Identifier not valid',
+	134: 'Bad User Name or Password',
+	135: 'Not authorized',
+	136: 'Server unavailable',
+	137: 'Server busy',
+	138: 'Banned',
+	139: 'Server shutting down',
+	140: 'Bad authentication method',
+	141: 'Keep Alive timeout',
+	142: 'Session taken over',
+	143: 'Topic Filter invalid',
+	144: 'Topic Name invalid',
+	145: 'Packet identifier in use',
+	146: 'Packet Identifier not found',
+	147: 'Receive Maximum exceeded',
+	148: 'Topic Alias invalid',
+	149: 'Packet too large',
+	150: 'Message rate too high',
+	151: 'Quota exceeded',
+	152: 'Administrative action',
+	153: 'Payload format invalid',
+	154: 'Retain not supported',
+	155: 'QoS not supported',
+	156: 'Use another server',
+	157: 'Server moved',
+	158: 'Shared Subscriptions not supported',
+	159: 'Connection rate exceeded',
+	160: 'Maximum connect time',
+	161: 'Subscription Identifiers not supported',
+	162: 'Wildcard Subscriptions not supported',
+}
+
+const handleAck: PacketHandler = (client, packet) => {
+	/* eslint no-fallthrough: "off" */
+	const { messageId } = packet
+	const type = packet.cmd
+	let response = null
+	const cb = client.outgoing[messageId] ? client.outgoing[messageId].cb : null
+	let err = null
+
+	// Checking `!cb` happens to work, but it's not technically "correct".
+	//
+	// Why? client code assumes client "no callback" is the same as client "we're not
+	// waiting for responses" (puback, pubrec, pubcomp, suback, or unsuback).
+	//
+	// It would be better to check `if (!client.outgoing[messageId])` here, but
+	// there's no reason to change it and risk (another) regression.
+	//
+	// The only reason client code works is becaues code in MqttClient.publish,
+	// MqttClinet.subscribe, and MqttClient.unsubscribe ensures client we will
+	// have a callback even if the user doesn't pass one in.)
+	if (!cb) {
+		client.log('_handleAck :: Server sent an ack in error. Ignoring.')
+		// Server sent an ack in error, ignore it.
+		return
+	}
+
+	// Process
+	client.log('_handleAck :: packet type', type)
+	switch (type) {
+		case 'pubcomp':
+		// same thing as puback for QoS 2
+		case 'puback': {
+			const pubackRC = packet.reasonCode
+			// Callback - we're done
+			if (pubackRC && pubackRC > 0 && pubackRC !== 16) {
+				err = new ErrorWithReasonCode(
+					`Publish error: ${ReasonCodes[pubackRC]}`,
+					pubackRC,
+				)
+				client['_removeOutgoingAndStoreMessage'](messageId, () => {
+					cb(err, packet)
+				})
+			} else {
+				client['_removeOutgoingAndStoreMessage'](messageId, cb)
+			}
+
+			break
+		}
+		case 'pubrec': {
+			response = {
+				cmd: 'pubrel',
+				qos: 2,
+				messageId,
+			}
+			const pubrecRC = packet.reasonCode
+
+			if (pubrecRC && pubrecRC > 0 && pubrecRC !== 16) {
+				err = new ErrorWithReasonCode(
+					`Publish error: ${ReasonCodes[pubrecRC]}`,
+					pubrecRC,
+				)
+				client['_removeOutgoingAndStoreMessage'](messageId, () => {
+					cb(err, packet)
+				})
+			} else {
+				client['_sendPacket'](response)
+			}
+			break
+		}
+		case 'suback': {
+			delete client.outgoing[messageId]
+			client.messageIdProvider.deallocate(messageId)
+			const granted = packet.granted as number[]
+			for (let grantedI = 0; grantedI < granted.length; grantedI++) {
+				const subackRC = granted[grantedI]
+				if ((subackRC & 0x80) !== 0) {
+					err = new Error(`Subscribe error: ${ReasonCodes[subackRC]}`)
+					err.code = subackRC
+
+					// suback with Failure status
+					const topics = client.messageIdToTopic[messageId]
+					if (topics) {
+						topics.forEach((topic) => {
+							delete client['_resubscribeTopics'][topic]
+						})
+					}
+				}
+			}
+			delete client.messageIdToTopic[messageId]
+			client['_invokeStoreProcessingQueue']()
+			cb(err, packet)
+			break
+		}
+		case 'unsuback': {
+			delete client.outgoing[messageId]
+			client.messageIdProvider.deallocate(messageId)
+			client['_invokeStoreProcessingQueue']()
+			cb(null, packet)
+			break
+		}
+		default:
+			client.emit('error', new Error('unrecognized packet type'))
+	}
+
+	if (client.disconnecting && Object.keys(client.outgoing).length === 0) {
+		client.emit('outgoingEmpty')
+	}
+}
+
+export default handleAck

package/node_modules/mqtt/src/lib/handlers/auth.ts

@@ -0,0 +1,44 @@
+import { IAuthPacket } from 'mqtt-packet'
+import { ErrorWithReasonCode, PacketHandler } from '../shared'
+import { ReasonCodes } from './ack'
+
+const handleAuth: PacketHandler = (
+	client,
+	packet: IAuthPacket & { returnCode: number },
+) => {
+	const { options } = client
+	const version = options.protocolVersion
+	const rc = version === 5 ? packet.reasonCode : packet.returnCode
+
+	if (version !== 5) {
+		const err = new ErrorWithReasonCode(
+			`Protocol error: Auth packets are only supported in MQTT 5. Your version:${version}`,
+			rc,
+		)
+		client.emit('error', err)
+		return
+	}
+
+	client.handleAuth(
+		packet,
+		(err: ErrorWithReasonCode, packet2: IAuthPacket) => {
+			if (err) {
+				client.emit('error', err)
+				return
+			}
+
+			if (rc === 24) {
+				client.reconnecting = false
+				client['_sendPacket'](packet2)
+			} else {
+				const error = new ErrorWithReasonCode(
+					`Connection refused: ${ReasonCodes[rc]}`,
+					rc,
+				)
+				client.emit('error', error)
+			}
+		},
+	)
+}
+
+export default handleAuth

package/node_modules/mqtt/src/lib/handlers/connack.ts

@@ -0,0 +1,55 @@
+import { ReasonCodes } from './ack'
+import TopicAliasSend from '../topic-alias-send'
+import { ErrorWithReasonCode, PacketHandler } from '../shared'
+import { IConnackPacket } from 'mqtt-packet'
+
+const handleConnack: PacketHandler = (client, packet: IConnackPacket) => {
+	client.log('_handleConnack')
+	const { options } = client
+	const version = options.protocolVersion
+	const rc = version === 5 ? packet.reasonCode : packet.returnCode
+
+	clearTimeout(client['connackTimer'])
+	delete client['topicAliasSend']
+
+	if (packet.properties) {
+		if (packet.properties.topicAliasMaximum) {
+			if (packet.properties.topicAliasMaximum > 0xffff) {
+				client.emit(
+					'error',
+					new Error('topicAliasMaximum from broker is out of range'),
+				)
+				return
+			}
+			if (packet.properties.topicAliasMaximum > 0) {
+				client['topicAliasSend'] = new TopicAliasSend(
+					packet.properties.topicAliasMaximum,
+				)
+			}
+		}
+		if (packet.properties.serverKeepAlive && options.keepalive) {
+			options.keepalive = packet.properties.serverKeepAlive
+		}
+
+		if (packet.properties.maximumPacketSize) {
+			if (!options.properties) {
+				options.properties = {}
+			}
+			options.properties.maximumPacketSize =
+				packet.properties.maximumPacketSize
+		}
+	}
+
+	if (rc === 0) {
+		client.reconnecting = false
+		client['_onConnect'](packet)
+	} else if (rc > 0) {
+		const err = new ErrorWithReasonCode(
+			`Connection refused: ${ReasonCodes[rc]}`,
+			rc,
+		)
+		client.emit('error', err)
+	}
+}
+
+export default handleConnack

package/node_modules/mqtt/src/lib/handlers/index.ts

@@ -0,0 +1,74 @@
+import handlePublish from './publish'
+import handleAuth from './auth'
+import handleConnack from './connack'
+import handleAck from './ack'
+import handlePubrel from './pubrel'
+import { PacketHandler } from '../shared'
+
+const handle: PacketHandler = (client, packet, done) => {
+	const { options } = client
+
+	if (
+		options.protocolVersion === 5 &&
+		options.properties &&
+		options.properties.maximumPacketSize &&
+		options.properties.maximumPacketSize < packet.length
+	) {
+		client.emit('error', new Error(`exceeding packets size ${packet.cmd}`))
+		client.end({
+			reasonCode: 149,
+			properties: { reasonString: 'Maximum packet size was exceeded' },
+		})
+		return client
+	}
+
+	client.log('_handlePacket :: emitting packetreceive')
+	client.emit('packetreceive', packet)
+
+	switch (packet.cmd) {
+		case 'publish':
+			// DO NOT SHIFT PING HERE, this would lead to https://github.com/mqttjs/MQTT.js/issues/1861
+			handlePublish(client, packet, done)
+			break
+		case 'puback':
+		case 'pubrec':
+		case 'pubcomp':
+		case 'suback':
+		case 'unsuback':
+			client.reschedulePing()
+			handleAck(client, packet)
+			done()
+			break
+		case 'pubrel':
+			client.reschedulePing()
+			handlePubrel(client, packet, done)
+			break
+		case 'connack':
+			// no need to reschedule ping here as keepalive manager is created after successll connect
+			// (when onConnect is called at the end of handleConnack)
+			handleConnack(client, packet)
+			done()
+			break
+		case 'auth':
+			client.reschedulePing()
+			handleAuth(client, packet)
+			done()
+			break
+		case 'pingresp':
+			client.log('_handlePacket :: received pingresp')
+			client.reschedulePing(true)
+			done()
+			break
+		case 'disconnect':
+			client.emit('disconnect', packet)
+			done()
+			break
+		default:
+			// TODO: unknown packet received. Should we emit an error?
+			client.log('_handlePacket :: unknown command')
+			done()
+			break
+	}
+}
+
+export default handle

package/node_modules/mqtt/src/lib/handlers/publish.ts

@@ -0,0 +1,183 @@
+import { IPublishPacket } from 'mqtt-packet'
+import { PacketHandler } from '../shared'
+
+const validReasonCodes = [0, 16, 128, 131, 135, 144, 145, 151, 153]
+
+/*
+  those late 2 case should be rewrite to comply with coding style:
+
+  case 1:
+  case 0:
+    // do not wait sending a puback
+    // no callback passed
+    if (1 === qos) {
+      this._sendPacket({
+        cmd: 'puback',
+        messageId: messageId
+      });
+    }
+    // emit the message event for both qos 1 and 0
+    this.emit('message', topic, message, packet);
+    this.handleMessage(packet, done);
+    break;
+  default:
+    // do nothing but every switch mus have a default
+    // log or throw an error about unknown qos
+    break;
+
+  for now i just suppressed the warnings
+  */
+const handlePublish: PacketHandler = (client, packet: IPublishPacket, done) => {
+	client.log('handlePublish: packet %o', packet)
+	done = typeof done !== 'undefined' ? done : client.noop
+	let topic = packet.topic.toString()
+	const message = packet.payload
+	const { qos } = packet
+	const { messageId } = packet
+	const { options } = client
+	if (client.options.protocolVersion === 5) {
+		let alias: number
+		if (packet.properties) {
+			alias = packet.properties.topicAlias
+		}
+		if (typeof alias !== 'undefined') {
+			if (topic.length === 0) {
+				if (alias > 0 && alias <= 0xffff) {
+					const gotTopic =
+						client['topicAliasRecv'].getTopicByAlias(alias)
+					if (gotTopic) {
+						topic = gotTopic
+						client.log(
+							'handlePublish :: topic complemented by alias. topic: %s - alias: %d',
+							topic,
+							alias,
+						)
+					} else {
+						client.log(
+							'handlePublish :: unregistered topic alias. alias: %d',
+							alias,
+						)
+						client.emit(
+							'error',
+							new Error('Received unregistered Topic Alias'),
+						)
+						return
+					}
+				} else {
+					client.log(
+						'handlePublish :: topic alias out of range. alias: %d',
+						alias,
+					)
+					client.emit(
+						'error',
+						new Error('Received Topic Alias is out of range'),
+					)
+					return
+				}
+			} else if (client['topicAliasRecv'].put(topic, alias)) {
+				client.log(
+					'handlePublish :: registered topic: %s - alias: %d',
+					topic,
+					alias,
+				)
+			} else {
+				client.log(
+					'handlePublish :: topic alias out of range. alias: %d',
+					alias,
+				)
+				client.emit(
+					'error',
+					new Error('Received Topic Alias is out of range'),
+				)
+				return
+			}
+		}
+	}
+	client.log('handlePublish: qos %d', qos)
+	switch (qos) {
+		case 2: {
+			options.customHandleAcks(
+				topic,
+				message as Buffer,
+				packet,
+				(error, code) => {
+					if (typeof error === 'number') {
+						code = error
+						error = null
+					}
+					if (error) {
+						return client.emit('error', error as Error)
+					}
+					if (validReasonCodes.indexOf(code) === -1) {
+						return client.emit(
+							'error',
+							new Error('Wrong reason code for pubrec'),
+						)
+					}
+					if (code) {
+						client['_sendPacket'](
+							{ cmd: 'pubrec', messageId, reasonCode: code },
+							done,
+						)
+					} else {
+						client.incomingStore.put(packet, () => {
+							client['_sendPacket'](
+								{ cmd: 'pubrec', messageId },
+								done,
+							)
+						})
+					}
+				},
+			)
+			break
+		}
+		case 1: {
+			// emit the message event
+			options.customHandleAcks(
+				topic,
+				message as Buffer,
+				packet,
+				(error, code) => {
+					if (typeof error === 'number') {
+						code = error
+						error = null
+					}
+					if (error) {
+						return client.emit('error', error as Error)
+					}
+					if (validReasonCodes.indexOf(code) === -1) {
+						return client.emit(
+							'error',
+							new Error('Wrong reason code for puback'),
+						)
+					}
+					if (!code) {
+						client.emit('message', topic, message as Buffer, packet)
+					}
+					client.handleMessage(packet, (err) => {
+						if (err) {
+							return done && done(err)
+						}
+						client['_sendPacket'](
+							{ cmd: 'puback', messageId, reasonCode: code },
+							done,
+						)
+					})
+				},
+			)
+			break
+		}
+		case 0:
+			// emit the message event
+			client.emit('message', topic, message as Buffer, packet)
+			client.handleMessage(packet, done)
+			break
+		default:
+			// do nothing
+			client.log('handlePublish: unknown QoS. Doing nothing.')
+			// log or throw an error about unknown qos
+			break
+	}
+}
+
+export default handlePublish

package/node_modules/mqtt/src/lib/handlers/pubrel.ts

@@ -0,0 +1,27 @@
+import { IPubcompPacket, IPublishPacket, IPubrelPacket } from 'mqtt-packet'
+import { PacketHandler } from '../shared'
+
+const handlePubrel: PacketHandler = (client, packet: IPubrelPacket, done) => {
+	client.log('handling pubrel packet')
+	const callback = typeof done !== 'undefined' ? done : client.noop
+	const { messageId } = packet
+
+	const comp: IPubcompPacket = { cmd: 'pubcomp', messageId }
+
+	client.incomingStore.get(packet, (err, pub: IPublishPacket) => {
+		if (!err) {
+			client.emit('message', pub.topic, pub.payload as Buffer, pub)
+			client.handleMessage(pub, (err2) => {
+				if (err2) {
+					return callback(err2)
+				}
+				client.incomingStore.del(pub, client.noop)
+				client['_sendPacket'](comp, callback)
+			})
+		} else {
+			client['_sendPacket'](comp, callback)
+		}
+	})
+}
+
+export default handlePubrel

package/node_modules/mqtt/src/lib/is-browser.ts

@@ -0,0 +1,46 @@
+const isStandardBrowserEnv = () => {
+	// window is only defined when it is a browser
+	if (typeof window !== 'undefined') {
+		// Is the process an electron application
+		// check if we are in electron `renderer`
+		const electronRenderCheck =
+			typeof navigator !== 'undefined' &&
+			navigator.userAgent?.toLowerCase().indexOf(' electron/') > -1
+		if (electronRenderCheck && process?.versions) {
+			const electronMainCheck = Object.prototype.hasOwnProperty.call(
+				process.versions,
+				'electron',
+			)
+			// Both electron checks are only true if the following webPreferences are set in the main electron BrowserWindow()
+			//   webPreferences: {
+			//     sandbox: false,
+			//     nodeIntegration: true
+			//     contextIsolation: false
+			// }
+			return !electronMainCheck
+		}
+		return typeof window.document !== 'undefined'
+	}
+	// return false if nothing is detected
+	return false
+}
+
+const isWebWorkerEnv = () =>
+	Boolean(
+		// eslint-disable-next-line no-restricted-globals
+		typeof self === 'object' &&
+			// eslint-disable-next-line no-restricted-globals
+			self?.constructor?.name?.includes('WorkerGlobalScope'),
+	)
+
+const isReactNativeEnv = () =>
+	typeof navigator !== 'undefined' && navigator.product === 'ReactNative'
+
+const isBrowser =
+	isStandardBrowserEnv() || isWebWorkerEnv() || isReactNativeEnv()
+
+export const isWebWorker = isWebWorkerEnv()
+
+export const isReactNativeBrowser = isReactNativeEnv()
+
+export default isBrowser

package/node_modules/mqtt/src/lib/shared.ts

@@ -0,0 +1,87 @@
+import type { Packet } from 'mqtt-packet'
+import type { Duplex } from 'stream'
+import type MqttClient from './client'
+import type { IClientOptions } from './client'
+
+export type DoneCallback = (error?: Error) => void
+
+export type GenericCallback<T> = (error?: Error, result?: T) => void
+
+export type VoidCallback = () => void
+
+export type IStream = Duplex & {
+	/** only set on browsers, it's a [WebSocket](https://developer.mozilla.org/en-US/docs/Web/API/WebSocket)  */
+	socket?: any
+}
+
+export type StreamBuilder = (
+	client: MqttClient,
+	opts?: IClientOptions,
+) => IStream
+
+export type Callback = () => void
+
+export type PacketHandler = (
+	client: MqttClient,
+	packet: Packet,
+	done?: DoneCallback,
+) => void
+
+export type TimerVariant = 'auto' | 'worker' | 'native'
+
+export class ErrorWithReasonCode extends Error {
+	public code: number
+
+	public constructor(message: string, code: number) {
+		super(message)
+		this.code = code
+
+		// We need to set the prototype explicitly
+		Object.setPrototypeOf(this, ErrorWithReasonCode.prototype)
+		Object.getPrototypeOf(this).name = 'ErrorWithReasonCode'
+	}
+}
+
+// eslint-disable-next-line @typescript-eslint/ban-types
+export type Constructor<T = {}> = new (...args: any[]) => T
+
+export function applyMixin(
+	target: Constructor,
+	mixin: Constructor,
+	includeConstructor = false,
+): void {
+	// Figure out the inheritance chain of the mixin
+	const inheritanceChain: Constructor[] = [mixin]
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		const current = inheritanceChain[0]
+		const base = Object.getPrototypeOf(current)
+		if (base?.prototype) {
+			inheritanceChain.unshift(base)
+		} else {
+			break
+		}
+	}
+	for (const ctor of inheritanceChain) {
+		for (const prop of Object.getOwnPropertyNames(ctor.prototype)) {
+			// Do not override the constructor
+			if (includeConstructor || prop !== 'constructor') {
+				Object.defineProperty(
+					target.prototype,
+					prop,
+					Object.getOwnPropertyDescriptor(ctor.prototype, prop) ??
+						Object.create(null),
+				)
+			}
+		}
+	}
+}
+export const nextTick =
+	typeof process?.nextTick === 'function'
+		? process.nextTick
+		: (callback: () => void) => {
+				setTimeout(callback, 0)
+		  }
+
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+export const MQTTJS_VERSION = require('../../package.json').version