matterbridge-lg-thinq-plugin 0.1.0

package/src/services/thinq/mqtt/mqttConnectionEvents.test.ts

@@ -0,0 +1,276 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { asPartial, createMockLogger } from '../../../tests/helpers/testUtils.js';
+import {
+	MQTT_OFFLINE_RECONNECT_DELAY_MS,
+	MqttRuntimeDevice,
+	MqttRuntimeLogger,
+	wireMqttDeviceEvents,
+} from './mqttConnectionEvents.js';
+
+describe('mqttConnectionEvents', () => {
+	let mockDevice: MqttRuntimeDevice;
+	let mockLogger: MqttRuntimeLogger;
+	let deviceHandlers: Map<string, unknown[]>;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		vi.useFakeTimers();
+		deviceHandlers = new Map();
+		mockLogger = createMockLogger();
+		mockDevice = asPartial<MqttRuntimeDevice>({
+			on: vi.fn((event: string, handler: unknown) => {
+				if (!deviceHandlers.has(event)) {
+					deviceHandlers.set(event, []);
+				}
+				deviceHandlers.get(event)?.push(handler);
+			}),
+			subscribe: vi.fn(),
+			end: vi.fn(),
+		});
+	});
+
+	afterEach(() => {
+		vi.clearAllTimers();
+		vi.useRealTimers();
+		vi.clearAllMocks();
+	});
+
+	describe('wireMqttDeviceEvents', () => {
+		it('should subscribe to all topics on connect event', () => {
+			const subscriptions = [
+				'$aws/things/device1/shadow/update/accepted',
+				'$aws/things/device1/shadow/update/rejected',
+			];
+			const onMessage = vi.fn();
+			const reconnect = vi.fn();
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions,
+				onMessage,
+				reconnect,
+			});
+
+			const connectHandlers = deviceHandlers.get('connect') as (() => void)[];
+			expect(connectHandlers).toBeDefined();
+			connectHandlers[0]();
+
+			expect(mockDevice.subscribe).toHaveBeenCalledWith(subscriptions[0]);
+			expect(mockDevice.subscribe).toHaveBeenCalledWith(subscriptions[1]);
+			expect(mockDevice.subscribe).toHaveBeenCalledTimes(2);
+		});
+
+		it('should log info and debug on connect', () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn();
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const connectHandlers = deviceHandlers.get('connect') as (() => void)[];
+			connectHandlers[0]();
+
+			expect(mockLogger.info).toHaveBeenCalledWith('Successfully connected to the MQTT server.');
+			expect(mockLogger.debug).toHaveBeenCalledWith('mqtt connected:', 'mqtt.example.com');
+		});
+
+		it('should log error on error event', () => {
+			const error = new Error('Connection failed');
+			const onMessage = vi.fn();
+			const reconnect = vi.fn();
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const errorHandlers = deviceHandlers.get('error') as ((err: unknown) => void)[];
+			errorHandlers[0](error);
+
+			expect(mockLogger.error).toHaveBeenCalledWith('mqtt err:', error);
+		});
+
+		it('should parse valid JSON payload and call onMessage', () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn();
+			const payload = Buffer.from(JSON.stringify({ deviceId: 'device-1', data: { state: { reported: {} } } }));
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const messageHandlers = deviceHandlers.get('message') as ((topic: string, payload: Buffer) => void)[];
+			messageHandlers[0]('topic/test', payload);
+
+			expect(onMessage).toHaveBeenCalledWith({ deviceId: 'device-1', data: { state: { reported: {} } } });
+			expect(mockLogger.debug).toHaveBeenCalledWith('mqtt message received:', payload.toString());
+		});
+
+		it('should log error and debug when JSON parse fails', () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn();
+			const invalidJson = Buffer.from('not valid json');
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const messageHandlers = deviceHandlers.get('message') as ((topic: string, payload: Buffer) => void)[];
+			messageHandlers[0]('topic/test', invalidJson);
+
+			expect(mockLogger.error).toHaveBeenCalledWith('mqtt message parse error:', expect.any(Error));
+			expect(mockLogger.debug).toHaveBeenCalledWith('mqtt invalid message received:', 'not valid json');
+			expect(onMessage).not.toHaveBeenCalled();
+		});
+
+		it('should not call onMessage when JSON payload is invalid', () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn();
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const messageHandlers = deviceHandlers.get('message') as ((topic: string, payload: Buffer) => void)[];
+			messageHandlers[0]('topic/test', Buffer.from('{invalid json}'));
+
+			expect(onMessage).not.toHaveBeenCalled();
+		});
+
+		it('should end device connection, log, and schedule reconnect on offline', async () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn().mockResolvedValue(undefined);
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const offlineHandlers = deviceHandlers.get('offline') as (() => void)[];
+			offlineHandlers[0]();
+
+			expect(mockDevice.end).toHaveBeenCalled();
+			expect(mockLogger.info).toHaveBeenCalledWith('MQTT disconnected, retrying in 60 seconds!');
+
+			// Advance timer to trigger reconnect
+			await vi.advanceTimersByTimeAsync(MQTT_OFFLINE_RECONNECT_DELAY_MS);
+
+			expect(reconnect).toHaveBeenCalled();
+		});
+
+		it('should log error when reconnect fails', async () => {
+			const onMessage = vi.fn();
+			const reconnectError = new Error('Reconnect failed');
+			const reconnect = vi.fn().mockRejectedValue(reconnectError);
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+			});
+
+			const offlineHandlers = deviceHandlers.get('offline') as (() => void)[];
+			offlineHandlers[0]();
+
+			await vi.advanceTimersByTimeAsync(MQTT_OFFLINE_RECONNECT_DELAY_MS);
+
+			expect(mockLogger.error).toHaveBeenCalledWith('mqtt reconnect failed:', reconnectError);
+		});
+
+		it('should use custom scheduleReconnect when provided', async () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn().mockResolvedValue(undefined);
+			const customScheduleReconnect = vi.fn();
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+				scheduleReconnect: customScheduleReconnect,
+			});
+
+			const offlineHandlers = deviceHandlers.get('offline') as (() => void)[];
+			offlineHandlers[0]();
+
+			expect(customScheduleReconnect).toHaveBeenCalledWith(expect.any(Function), MQTT_OFFLINE_RECONNECT_DELAY_MS);
+		});
+
+		it('should call custom scheduleReconnect with the correct handler and delay', async () => {
+			const onMessage = vi.fn();
+			const reconnect = vi.fn().mockResolvedValue(undefined);
+			let capturedHandler: (() => Promise<void> | void) | undefined;
+			const customScheduleReconnect = vi.fn((handler) => {
+				capturedHandler = handler;
+			});
+
+			wireMqttDeviceEvents({
+				device: mockDevice,
+				logger: mockLogger,
+				mqttServer: 'mqtt.example.com',
+				subscriptions: [],
+				onMessage,
+				reconnect,
+				scheduleReconnect: customScheduleReconnect,
+			});
+
+			const offlineHandlers = deviceHandlers.get('offline') as (() => void)[];
+			offlineHandlers[0]();
+
+			expect(customScheduleReconnect).toHaveBeenCalledWith(expect.any(Function), MQTT_OFFLINE_RECONNECT_DELAY_MS);
+
+			// Manually call the captured handler
+			if (capturedHandler) {
+				const result = capturedHandler();
+				if (result instanceof Promise) {
+					await result;
+				}
+			}
+
+			expect(reconnect).toHaveBeenCalled();
+		});
+	});
+
+	describe('MQTT_OFFLINE_RECONNECT_DELAY_MS', () => {
+		it('should be 60000 milliseconds', () => {
+			expect(MQTT_OFFLINE_RECONNECT_DELAY_MS).toBe(60000);
+		});
+	});
+});

package/src/services/thinq/mqtt/mqttConnectionEvents.ts

@@ -0,0 +1,76 @@
+export const MQTT_OFFLINE_RECONNECT_DELAY_MS = 60000;
+
+export interface MqttRuntimeDevice {
+	on(event: 'error', handler: (err: unknown) => void): unknown;
+	on(event: 'connect' | 'offline', handler: () => void): unknown;
+	on(event: 'message', handler: (topic: string, payload: Buffer) => void): unknown;
+	subscribe(subscription: string): unknown;
+	end(): unknown;
+}
+
+export interface MqttRuntimeLogger {
+	debug(...args: unknown[]): void;
+	error(...args: unknown[]): void;
+	info(...args: unknown[]): void;
+}
+
+export type MqttReconnectScheduler = (handler: () => void | Promise<void>, delayMs: number) => unknown;
+
+/** Wires connect/message/error/offline handlers onto an MQTT device, ports `mqttConnection.ts` verbatim. */
+export function wireMqttDeviceEvents(options: {
+	device: MqttRuntimeDevice;
+	logger: MqttRuntimeLogger;
+	mqttServer: string;
+	subscriptions: string[];
+	onMessage: (data: unknown) => void;
+	reconnect: () => Promise<void>;
+	scheduleReconnect?: MqttReconnectScheduler;
+}): void {
+	const {
+		device,
+		logger,
+		mqttServer,
+		subscriptions,
+		onMessage,
+		reconnect,
+		scheduleReconnect = (handler, delayMs) => setTimeout(handler, delayMs),
+	} = options;
+
+	device.on('error', (err) => {
+		logger.error('mqtt err:', err);
+	});
+
+	device.on('connect', () => {
+		logger.info('Successfully connected to the MQTT server.');
+		logger.debug('mqtt connected:', mqttServer);
+		for (const subscription of subscriptions) {
+			device.subscribe(subscription);
+		}
+	});
+
+	device.on('message', (_topic, payload) => {
+		const payloadText = payload.toString();
+		let parsedPayload: unknown;
+		try {
+			parsedPayload = JSON.parse(payloadText);
+		} catch (err) {
+			logger.error('mqtt message parse error:', err);
+			logger.debug('mqtt invalid message received:', payloadText);
+			return;
+		}
+
+		onMessage(parsedPayload);
+		logger.debug('mqtt message received:', payloadText);
+	});
+
+	device.on('offline', () => {
+		device.end();
+
+		logger.info('MQTT disconnected, retrying in 60 seconds!');
+		scheduleReconnect(() => {
+			reconnect().catch((err: unknown) => {
+				logger.error('mqtt reconnect failed:', err);
+			});
+		}, MQTT_OFFLINE_RECONNECT_DELAY_MS);
+	});
+}

package/src/services/thinq/mqtt/mqttKeyRepository.test.ts

@@ -0,0 +1,164 @@
+import type NodePersist from 'node-persist';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { asPartial, createMockLogger } from '../../../tests/helpers/testUtils.js';
+import { MqttKeyRepository } from './mqttKeyRepository.js';
+
+describe('MqttKeyRepository', () => {
+	let mockPersist: NodePersist.LocalStorage;
+	let mockLogger: ReturnType<typeof createMockLogger>;
+	let repository: MqttKeyRepository;
+
+	beforeEach(() => {
+		vi.clearAllMocks();
+		mockPersist = asPartial<NodePersist.LocalStorage>({
+			getItem: vi.fn(),
+			setItem: vi.fn(),
+		});
+		mockLogger = createMockLogger();
+		repository = new MqttKeyRepository(mockPersist, mockLogger);
+	});
+
+	afterEach(() => {
+		vi.clearAllMocks();
+	});
+
+	describe('getOrCreateKeyPair', () => {
+		it('should return cached key pair when it exists', async () => {
+			const cachedKeyPair = {
+				privateKey: 'cached-private-key',
+				publicKey: 'cached-public-key',
+			};
+
+			vi.mocked(mockPersist.getItem).mockResolvedValue(cachedKeyPair);
+
+			const result = await repository.getOrCreateKeyPair();
+
+			expect(result).toEqual(cachedKeyPair);
+			expect(mockPersist.getItem).toHaveBeenCalledWith('thinq:mqtt:keyPair');
+			expect(mockPersist.setItem).not.toHaveBeenCalled();
+			expect(mockLogger.debug).toHaveBeenCalledWith('Loaded cached MQTT key pair');
+		});
+
+		it('should generate and cache new key pair when cache is empty', async () => {
+			vi.mocked(mockPersist.getItem).mockResolvedValue(undefined);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			(vi.mocked(mockPersist.setItem) as any).mockImplementation(() => Promise.resolve());
+
+			const result = await repository.getOrCreateKeyPair();
+
+			expect(result).toBeDefined();
+			expect(result.privateKey).toBeDefined();
+			expect(result.publicKey).toBeDefined();
+			expect(mockPersist.getItem).toHaveBeenCalledWith('thinq:mqtt:keyPair');
+			expect(mockPersist.setItem).toHaveBeenCalledWith('thinq:mqtt:keyPair', result);
+			expect(mockLogger.debug).toHaveBeenCalledWith('Generating 2048-bit MQTT key pair...');
+		});
+
+		it('should persist the generated key pair', async () => {
+			vi.mocked(mockPersist.getItem).mockResolvedValue(undefined);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			(vi.mocked(mockPersist.setItem) as any).mockImplementation(() => Promise.resolve());
+
+			await repository.getOrCreateKeyPair();
+
+			expect(mockPersist.setItem).toHaveBeenCalledWith(
+				'thinq:mqtt:keyPair',
+				expect.objectContaining({
+					privateKey: expect.stringContaining('PRIVATE KEY'),
+					publicKey: expect.stringContaining('PUBLIC KEY'),
+				}),
+			);
+		});
+
+		it('should return the same instance on repeated calls', async () => {
+			const cachedKeyPair = {
+				privateKey: 'cached-private-key',
+				publicKey: 'cached-public-key',
+			};
+
+			vi.mocked(mockPersist.getItem).mockResolvedValue(cachedKeyPair);
+
+			const result1 = await repository.getOrCreateKeyPair();
+			const result2 = await repository.getOrCreateKeyPair();
+
+			expect(result1).toBe(result2);
+			// getItem should be called once per call
+			expect(mockPersist.getItem).toHaveBeenCalledTimes(2);
+		});
+
+		it('should generate keys with RSA format', async () => {
+			vi.mocked(mockPersist.getItem).mockResolvedValue(undefined);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			(vi.mocked(mockPersist.setItem) as any).mockImplementation(() => Promise.resolve());
+
+			const result = await repository.getOrCreateKeyPair();
+
+			expect(result.privateKey).toContain('BEGIN RSA PRIVATE KEY');
+			expect(result.publicKey).toContain('BEGIN PUBLIC KEY');
+		});
+	});
+
+	describe('getOrCreateCsr', () => {
+		it('should return cached CSR when it exists', async () => {
+			const cachedCsr = 'cached-csr-data';
+			const keyPair = { privateKey: 'key', publicKey: 'pubkey' };
+
+			vi.mocked(mockPersist.getItem).mockResolvedValue(cachedCsr);
+
+			const result = await repository.getOrCreateCsr(keyPair);
+
+			expect(result).toBe(cachedCsr);
+			expect(mockPersist.getItem).toHaveBeenCalledWith('thinq:mqtt:csr');
+			expect(mockPersist.setItem).not.toHaveBeenCalled();
+			expect(mockLogger.debug).toHaveBeenCalledWith('Loaded cached MQTT CSR');
+		});
+
+		it('should generate and cache new CSR when cache is empty', async () => {
+			vi.mocked(mockPersist.getItem).mockResolvedValue(undefined);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			(vi.mocked(mockPersist.setItem) as any).mockImplementation(() => Promise.resolve());
+
+			// Use the actual generateMqttKeyPair to create valid keys
+			const { generateMqttKeyPair } = await import('./mqttCertificate.js');
+			const keyPair = generateMqttKeyPair();
+
+			const result = await repository.getOrCreateCsr(keyPair);
+
+			expect(result).toBeDefined();
+			expect(result).toContain('BEGIN CERTIFICATE REQUEST');
+			expect(mockPersist.getItem).toHaveBeenCalledWith('thinq:mqtt:csr');
+			expect(mockPersist.setItem).toHaveBeenCalledWith('thinq:mqtt:csr', result);
+			expect(mockLogger.debug).toHaveBeenCalledWith('Creating MQTT certification request (CSR)...');
+		});
+
+		it('should return the same CSR on repeated calls with cache', async () => {
+			const cachedCsr = 'cached-csr';
+			const keyPair = { privateKey: 'key', publicKey: 'pubkey' };
+
+			vi.mocked(mockPersist.getItem).mockResolvedValue(cachedCsr);
+
+			const result1 = await repository.getOrCreateCsr(keyPair);
+			const result2 = await repository.getOrCreateCsr(keyPair);
+
+			expect(result1).toBe(result2);
+			expect(result1).toBe(cachedCsr);
+		});
+
+		it('should store CSR under correct storage key', async () => {
+			vi.mocked(mockPersist.getItem).mockResolvedValue(undefined);
+			// eslint-disable-next-line @typescript-eslint/no-explicit-any
+			(vi.mocked(mockPersist.setItem) as any).mockImplementation(() => Promise.resolve());
+
+			const { generateMqttKeyPair } = await import('./mqttCertificate.js');
+			const keyPair = generateMqttKeyPair();
+
+			await repository.getOrCreateCsr(keyPair);
+
+			expect(mockPersist.setItem).toHaveBeenCalledWith(
+				'thinq:mqtt:csr',
+				expect.stringContaining('BEGIN CERTIFICATE REQUEST'),
+			);
+		});
+	});
+});

package/src/services/thinq/mqtt/mqttKeyRepository.ts

@@ -0,0 +1,43 @@
+import { AnsiLogger } from 'matterbridge/logger';
+import type NodePersist from 'node-persist';
+
+import { createMqttCsr, generateMqttKeyPair, MqttKeyPair } from './mqttCertificate.js';
+
+const KEY_PAIR_STORAGE_KEY = 'thinq:mqtt:keyPair';
+const CSR_STORAGE_KEY = 'thinq:mqtt:csr';
+
+/** Persisted RSA keypair/CSR repository for MQTT client certificate enrollment, mirrors `UserDataRepository`. */
+export class MqttKeyRepository {
+	constructor(
+		private readonly persist: NodePersist.LocalStorage,
+		private readonly logger: AnsiLogger,
+	) {}
+
+	/** Loads the cached MQTT key pair, generating and caching one on first call. */
+	public async getOrCreateKeyPair(): Promise<MqttKeyPair> {
+		const cached = (await this.persist.getItem(KEY_PAIR_STORAGE_KEY)) as MqttKeyPair | undefined;
+		if (cached) {
+			this.logger.debug('Loaded cached MQTT key pair');
+			return cached;
+		}
+
+		this.logger.debug('Generating 2048-bit MQTT key pair...');
+		const keys = generateMqttKeyPair();
+		await this.persist.setItem(KEY_PAIR_STORAGE_KEY, keys);
+		return keys;
+	}
+
+	/** Loads the cached MQTT CSR, generating and caching one on first call. */
+	public async getOrCreateCsr(keys: MqttKeyPair): Promise<string> {
+		const cached = (await this.persist.getItem(CSR_STORAGE_KEY)) as string | undefined;
+		if (cached) {
+			this.logger.debug('Loaded cached MQTT CSR');
+			return cached;
+		}
+
+		this.logger.debug('Creating MQTT certification request (CSR)...');
+		const csr = createMqttCsr(keys);
+		await this.persist.setItem(CSR_STORAGE_KEY, csr);
+		return csr;
+	}
+}