@reactoo/watchtogether-sdk-js 2.8.48 → 2.8.52

package/src/modules/wt-iot-worker5.worker.js

@@ -1,210 +1,226 @@
-import { mqtt5, iot } from 'aws-iot-device-sdk-v2';
-console.log('Worker: Starting up');
+import { mqtt5, iot, auth } from 'aws-iot-device-sdk-v2';
+
+class StaticCredentialsProvider extends auth.CredentialsProvider {
+	constructor({ accessKeyId, secretAccessKey, sessionToken, region }) {
+		super();
+		this.creds = { accessKeyId, secretAccessKey, sessionToken, region };
+	}
+	getCredentials() {
+		return {
+			aws_access_id: this.creds.accessKeyId ?? "",
+			aws_secret_key: this.creds.secretAccessKey ?? "",
+			aws_sts_token: this.creds.sessionToken,
+			aws_region: this.creds.region
+		};
+	}
+}
+
+console.log('Worker: Starting up with MQTT5');
 
 let client = null;
-let currentConnectionId = 1;
+let isConnectedVal = false
+let listenersAttached = false;
+let terminateOnDisconnect = false;
+
+const normalizeError = (err) => {
+	if (!err) return 'Unknown error';
+	if (typeof err === 'string') return err;
+	if (err.message) return err.message;
+	try { return JSON.stringify(err); } catch { return String(err); }
+};
+
+const cleanupClient = () => {
+	try { client?.removeAllListeners?.(); } catch {}
+	try { client?.close?.(); } catch {}
+	client = null;
+	listenersAttached = false;
+	isConnectedVal = false;
+	if(terminateOnDisconnect) {
+		self.close();
+	}
+};
 
 self.onmessage = function(event) {
-    const { type, params, topic, message, stamp } = event.data;
-    console.log(`Worker: Received message of type: ${type}`);
-
-    switch (type) {
-        case 'connect':
-            connect(params, stamp);
-            break;
-        case 'disconnect':
-            disconnect(stamp);
-            break;
-        case 'is_connected':
-            isConnected();
-            break;
-        case 'clear_topics':
-            // No action needed in the worker
-            break;
-        case 'subscribe':
-            subscribe(topic, stamp);
-            break;
-        case 'unsubscribe':
-            unsubscribe(topic, stamp);
-            break;
-        case 'send':
-            send(topic, message);
-            break;
-    }
+	const { type, params, topic, message, stamp } = event.data;
+	console.log(`Worker: Received message of type: ${type}`);
+
+	switch (type) {
+		case 'connect':
+			connect(params);
+			break;
+		case 'disconnect':
+			disconnect();
+			break;
+		case 'isConnected':
+			isConnected(stamp);
+			break;
+		case 'clearTopics':
+			// No action needed in the worker
+			break;
+		case 'subscribe':
+			subscribe(topic, stamp);
+			break;
+		case 'unsubscribe':
+			unsubscribe(topic, stamp);
+			break;
+		case 'send':
+			send(topic, message);
+			break;
+	}
 };
 
-function connect(params, stamp) {
-    console.log('Worker: Attempting to connect');
-    const { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken } = params;
-
-    const configBuilder = iot.AwsIotMqtt5ClientConfigBuilder.new_with_websockets();
-
-    configBuilder.with_clean_session(true);
-    configBuilder.with_client_id(apiMqttClientId);
-    configBuilder.with_endpoint(apiMqttUrl);
-    configBuilder.with_credentials(region, accessKeyId, secretAccessKey, sessionToken);
-    configBuilder.with_ping_timeout_ms(3000);
-    configBuilder.with_connect_properties({
-        keepAliveIntervalSeconds: 30,
-        sessionExpiryIntervalSeconds: 300
-    });
-
-    const config = configBuilder.build();
-
-    // MQTT5 uses a single client instance
-    client = new mqtt5.Mqtt5Client(config);
-    currentConnectionId++;
-
-    setupConnectionListeners(currentConnectionId);
-
-    client.start()
-        .then(() => {
-            console.log('Worker: Connection successful');
-            self.postMessage({ type: 'connect_result', data: {success: true, connectionId: currentConnectionId, stamp} });
-        })
-        .catch((error) => {
-            console.error('Worker: Connection failed', error);
-            self.postMessage({ type: 'connect_result', data: {success: false, error: error.message, stamp} });
-        });
+function connect(params) {
+	if (client) return; // guard duplicate connects
+
+	console.log('Worker: Attempting to connect with MQTT5');
+	const { apiMqttUrl, apiMqttClientId, region, accessKeyId, secretAccessKey, sessionToken } = params;
+
+	const credentialsProvider = new StaticCredentialsProvider({
+		accessKeyId,
+		secretAccessKey,
+		sessionToken,
+		region
+	});
+
+	const configBuilder = iot.AwsIotMqtt5ClientConfigBuilder.newWebsocketMqttBuilderWithSigv4Auth(
+		apiMqttUrl,
+		{ region, credentialsProvider }
+	);
+
+	configBuilder.withConnectProperties({
+		clientId: apiMqttClientId,
+		keepAliveIntervalSeconds: 30,
+		sessionExpiryIntervalSeconds: 3600
+	});
+
+	const config = configBuilder.build();
+	client = new mqtt5.Mqtt5Client(config);
+	attachConnectionListeners();
+	client.start();
 }
 
-function disconnect(stamp) {
-    if (client) {
-        const connectionId = currentConnectionId;
-        client.stop()
-            .then(() => {
-                if(connectionId !== currentConnectionId) {
-                    console.log('Worker: Connection Id mismatch, ignoring disconnect result', connectionId, currentConnectionId);
-                    return;
-                }
-                self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
-            })
-            .catch((error) => {
-                if(connectionId !== currentConnectionId) {
-                    console.log('Worker: Connection Id mismatch, ignoring disconnect result', connectionId, currentConnectionId);
-                    return;
-                }
-                self.postMessage({ type: 'disconnect_result', data: { success: false, error: error.message, stamp} });
-            });
-        client = null;
-    } else {
-        self.postMessage({ type: 'disconnect_result', data: {success: true, stamp} });
-    }
+function disconnect(terminate = true) {
+	terminateOnDisconnect = terminate;
+	if (client) {
+		client.stop();
+	}
 }
 
-function isConnected() {
-    const connected = client && client.getIsConnected();
-    self.postMessage({ type: 'is_connected_result', data:{connected} });
+function isConnected(stamp) {
+	self.postMessage({ type: 'is_connected_result', data:{connected: isConnectedVal, stamp} });
 }
 
 function subscribe(topic, stamp) {
-    if (client && client.getIsConnected()) {
-        const subscription = {
-            qos: mqtt5.QoS.AtLeastOnce,
-            topicFilter: topic
-        };
-
-        client.subscribe(subscription)
-            .then(() => {
-                self.postMessage({ type: 'subscribe_result', data: {success: true, stamp} });
-            })
-            .catch((error) => {
-                self.postMessage({ type: 'subscribe_result', data: {success: false, error: error.message, stamp} });
-            });
-    } else {
-        self.postMessage({ type: 'subscribe_result', data: {success: false, error: 'Not connected', stamp} });
-    }
+	if (client && isConnectedVal) {
+		const subscribePacket = {
+			subscriptions: [{
+				topicFilter: topic,
+				qos: mqtt5.QoS.AtLeastOnce
+			}]
+		};
+		client.subscribe(subscribePacket)
+			.then(() => {
+				self.postMessage({ type: 'subscribe_result', data: {success: true, stamp} });
+			})
+			.catch((error) => {
+				self.postMessage({ type: 'subscribe_result', data: {success: false, error: normalizeError(error), stamp} });
+			});
+	} else {
+		self.postMessage({ type: 'subscribe_result', data: {success: false, error: 'Not connected', stamp} });
+	}
 }
 
 function unsubscribe(topic, stamp) {
-    if (client && client.getIsConnected()) {
-        client.unsubscribe({ topicFilter: topic })
-            .then(() => {
-                self.postMessage({ type: 'unsubscribe_result', data: {success: true, stamp} });
-            })
-            .catch((error) => {
-                self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: error.message, stamp} });
-            });
-    } else {
-        self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: 'Not connected', stamp} });
-    }
+	if (client && isConnectedVal) {
+		const unsubscribePacket = {
+			topicFilters: [topic]
+		};
+		client.unsubscribe(unsubscribePacket)
+			.then(() => {
+				self.postMessage({ type: 'unsubscribe_result', data: {success: true, stamp} });
+			})
+			.catch((error) => {
+				self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: normalizeError(error), stamp} });
+			});
+	} else {
+		self.postMessage({ type: 'unsubscribe_result', data: {success: false, error: 'Not connected', stamp} });
+	}
 }
 
 function send(topic, message) {
-    if (client && client.getIsConnected()) {
-        const publish = {
-            qos: mqtt5.QoS.AtLeastOnce,
-            topicName: topic,
-            payload: message,
-            retain: false
-        };
-        client.publish(publish);
-    } else {
-        console.error('Cannot send message: Not connected');
-    }
+	if (client && isConnectedVal) {
+		const publishPacket = {
+			topicName: topic,
+			payload: message,
+			qos: mqtt5.QoS.AtLeastOnce
+		};
+		client.publish(publishPacket).catch((e) => {
+			console.error('Publish failed:', normalizeError(e));
+		});
+	} else {
+		console.error('Cannot send message: Not connected');
+	}
 }
 
-function setupConnectionListeners(connectionId) {
-    client.on('connectionSuccess', (eventData) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring connectionSuccess event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({
-            type: 'connection_success',
-            data: {
-                sessionPresent: eventData.sessionPresent,
-                negotiatedSettings: eventData.negotiatedSettings
-            },
-            connectionId: connectionId
-        });
-    });
-
-    client.on('connectionFailure', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring connectionFailure event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'connection_failure', data: error, connectionId: connectionId });
-    });
-
-    client.on('disconnection', (eventData) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring disconnect event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({
-            type: 'disconnect',
-            data: { reason: eventData.errorCode },
-            connectionId: connectionId
-        });
-    });
-
-    client.on('messageReceived', (eventData) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring message event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({
-            type: 'message',
-            data: {
-                topic: eventData.message.topicName,
-                payload: eventData.message.payload,
-                qos: eventData.message.qos,
-                retain: eventData.message.retain,
-                properties: eventData.message.properties
-            },
-            connectionId: connectionId
-        });
-    });
-
-    client.on('error', (error) => {
-        if(connectionId !== currentConnectionId) {
-            console.log('Worker: Connection Id mismatch, ignoring error event', connectionId, currentConnectionId);
-            return;
-        }
-        self.postMessage({ type: 'error', data: error });
-    });
+function attachConnectionListeners() {
+
+	if(listenersAttached || !client) {
+		return;
+	}
+
+	// not sure if all errors are unrecoverable, but we will treat them as such for now
+
+	client.on('error', (error) => {
+		isConnectedVal = false;
+		self.postMessage({ type: 'error', data: error });
+	});
+
+	client.on('messageReceived', (eventData) => {
+		const { message } = eventData;
+		self.postMessage({
+			type: 'message',
+			data: {
+				topic: message.topicName,
+				payload: message.payload
+			}
+		});
+	});
+
+	client.on('attemptingConnect', () => {
+		self.postMessage({ type: 'attemptingConnect'});
+	})
+
+	client.on('connectionSuccess', () => {
+		isConnectedVal = true;
+		self.postMessage({ type: 'connectionSuccess'});
+	});
+
+	client.on('connectionFailure', (eventData) => {
+		isConnectedVal = false;
+		self.postMessage({
+			type: 'connectionFailure',
+			data: {
+				error: normalizeError(eventData?.error),
+				connack: eventData?.connack
+			}});
+	});
+
+	client.on('disconnection', (eventData) => {
+		isConnectedVal = false;
+		self.postMessage({
+			type: 'disconnection',
+			data: { error: normalizeError(eventData?.error), disconnect: eventData?.disconnect }
+		});
+	});
+
+	client.on('stopped', () => {
+		// free native resources and reset state
+		cleanupClient();
+		self.postMessage({ type: 'stopped'});
+	});
+
+	listenersAttached = true;
 }
 
-console.log('Worker: Setup complete');
+
+console.log('Worker: Setup complete with MQTT5');