@phystack/hub-client 4.4.51 → 4.4.53

package/src/index.ts

@@ -7,9 +7,11 @@ import {
   EdgeTwinResponse,
   EdgeTwinDesiredPropertiesResponse,
   PeripheralTwinResponse,
-  TwinTypeEnum,
   Instance,
   PeripheralInstance,
+  IPeripheralTwinInstance,
+  TwinMessageResult,
+  TwinMessageResultStatus,
 } from './types/twin.types';
 import {
   PhygridDataChannel,
@@ -27,8 +29,11 @@ import {
   createWebRTCMediaStreamConnection,
   WebRTCMediaStreamResult,
 } from './services/webrtc/mediastream';
+import { TwinRegistry } from './twin-registry';
 // import { createWebRTCMediaStreamConnection, WebRTCMediaStreamResult } from './helpers/webrtc-mediastream';
 
+export * from './types';
+
 // Define WebRTC types that might not be available in all environments
 declare global {
   // In browsers, these are standard WebRTC interfaces
@@ -91,7 +96,7 @@ declare global {
   }
 })().catch(err => console.error('Error in WebRTC globals initialization:', err));
 
-interface EventPayload<T = any> {
+export interface EventPayload<T = any> {
   twinId?: string;
   sourceTwinId?: string;
   sourceDeviceId?: string;
@@ -115,8 +120,8 @@ export class PhyHubClient {
   private subscribedTwins: Set<string> = new Set();
   private twinMessageListeners: { [key: string]: Set<(message: any) => void> } = {};
   private instances: Map<string, Instance> = new Map();
-  private peripheralInstances: Map<string, PeripheralInstance> = new Map();
   private twinUpdateListeners: { [key: string]: Set<(twin: TwinResponse) => void> } = {};
+  private twinInstancesRegistry: TwinRegistry | null = null;
 
   private readonly EVENTS = {
     PING: 'ping',
@@ -262,30 +267,36 @@ export class PhyHubClient {
       this.socketConnected = false;
     });
 
-    this.socket.on(this.EVENTS.TWIN_MESSAGE, (payload: EventPayload) => {
+    this.socket.on(this.EVENTS.TWIN_MESSAGE, (payload: EventPayload, callback: (response: TwinMessageResult | null) => void) => {
       // console.log('Received TWIN_MESSAGE payload:', {
       //   JSON: JSON.stringify(payload, null, 2),
       // });
 
+      let result: TwinMessageResult | null = null;
       if (payload.twinId && payload.data) {
         // console.log('Received TWIN_MESSAGE event:', {
         //   hasListeners: !!this.twinMessageListeners[payload.twinId],
         //   listenerCount: this.twinMessageListeners[payload.twinId]?.size
         // });
         const listeners = this.twinMessageListeners[payload.twinId];
-        if (listeners) {
+        if (listeners?.size) {
           // console.log(`Executing ${listeners.size} listeners for twin ${payload.twinId}`);
-          listeners.forEach(callback => {
-            // console.log('Executing listener for twin:', callback);
+          listeners.forEach(listener => {
+            // console.log('Executing listener for twin:', listener);
             try {
-              callback(payload);
+              listener(payload);
+              result = { status: TwinMessageResultStatus.Success, message: 'Action completed' };
             } catch (error) {
               console.error(`Error in twin message listener for ${payload.twinId}:`, error);
+              result = { status: TwinMessageResultStatus.Error, message: (error as Error)?.message || 'An error occurred' };
             }
           });
         } else {
-          // console.log(`No listeners found for twin ${payload.twinId}`, JSON.stringify(payload, null, 2));
+          // even though there are no errors, still send acknowledgement to the socket server
+          result = { status: TwinMessageResultStatus.Warning, message: `No listeners found for twin ${payload.twinId} on this socket` };
         }
+
+        callback(result);
       } else {
         // console.log('Invalid twin message payload:', payload);
       }
@@ -336,6 +347,10 @@ export class PhyHubClient {
     if (!PhyHubClient.instance) {
       PhyHubClient.instance = new PhyHubClient(params);
       await PhyHubClient.instance.initializeConnection();
+
+      // create twin registry to store instances
+      PhyHubClient.instance.twinInstancesRegistry = new TwinRegistry(PhyHubClient.instance);
+
       console.info(`connect(): Connection to phyhub initialized`);
     }
     return PhyHubClient.instance;
@@ -707,303 +722,15 @@ export class PhyHubClient {
   }
 
   // TODO properties should automatically be updated when the edge twin is updated
-  public async getPeripheralInstance(peripheralTwinId: string): Promise<PeripheralInstance> {
-    if (this.peripheralInstances.has(peripheralTwinId)) {
-      return this.peripheralInstances.get(peripheralTwinId)!;
+  /**
+   * provides instance of PeripheralTwinInstance class
+  */
+  public async getPeripheralInstance(peripheralTwinId: string): Promise<IPeripheralTwinInstance | null> {
+    if (!this.twinInstancesRegistry) {
+      throw new Error('PhyHubClient instance is not initialized yet');
     }
-    // console.log(`Getting peripheral instance for twin ID: ${peripheralTwinId}`);
-    let peripheralInstance: PeripheralInstance | undefined;
-    const edgeInstance = await this.getInstance();
-    if (!edgeInstance) {
-      console.error('Edge instance not found');
-      throw new Error('Edge instance not found');
-    }
-
-    // console.log('getting peripheral twin', peripheralTwinId);
-
-    const peripheralTwin = await this.getTwinById(peripheralTwinId);
-    // console.log('peripheralTwinp', peripheralTwin);
-    if (!peripheralTwin) {
-      console.error(`Peripheral twin with id ${peripheralTwinId} not found`);
-      throw new Error(`Peripheral twin with id ${peripheralTwinId} not found`);
-    }
-
-    if (peripheralTwin.type !== TwinTypeEnum.Peripheral) {
-      throw new Error(`Twin ${peripheralTwinId} is not a peripheral twin`);
-    }
-
-    // Auto-subscribe if peripheral belongs to a different device
-    // if (peripheralTwin.deviceId !== edgeInstance.deviceId) {
-    // console.log('Auto-subscribing to peripheral twin', peripheralTwinId);
-    // const response =
-    await this.subscribeTwin(peripheralTwinId);
-    // console.log('subscribeTwin response', response);
-    // }
-
-    const instanceTypePrefix = 'peripheralInstance';
-
-    const peripheralTwinEmit = (type: string, payload: any) => {
-      // console.log(`Peripheral ${peripheralTwinId} emitting event:`, {
-      //   type,
-      //   payload
-      // });
-
-      const messagePayload = {
-        type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
-        sourceTwinId: peripheralTwin.id,
-        sourceDeviceId: edgeInstance.deviceId,
-        data: payload,
-      };
-
-      // console.log('Sending twin message:', JSON.stringify(messagePayload, null, 2));
-      this.sendTwinMessage(peripheralTwin.id, messagePayload);
-    };
-
-    const peripheralTwinOn = (type: string, callback: (message: any) => void) => {
-      console.log(`Setting up listener for peripheral ${peripheralTwinId} event: ${type}`);
-
-      const onMessage = (payload: any) => {
-        // console.log(`Received message for peripheral ${peripheralTwinId}:`, payload);
-        const messageType = payload.data?.type || payload.type;
-        if (messageType === `${instanceTypePrefix}:${peripheralTwin.id}:${type}`) {
-          // console.log('Processing matching message type');
-          callback(payload.data?.data || payload.data);
-        } else {
-          // console.log('Ignoring non-matching message type:', messageType);
-        }
-      };
-
-      this.onTwinMessage(peripheralTwin.id, onMessage);
-    };
-
-    const peripheralTwinTo = (targetTwinId: string) => ({
-      emit: (type: string, payload: any) => {
-        const messagePayload = {
-          type: `${instanceTypePrefix}:${peripheralTwin.id}:${type}`,
-          sourceTwinId: edgeInstance.id,
-          sourceDeviceId: edgeInstance.deviceId,
-          data: payload,
-        };
-        this.sendTwinMessage(targetTwinId, messagePayload);
-      },
-    });
-
-    const getDataChannel = async () => {
-      return await this.getDataChannel(peripheralTwin.id);
-    };
-
-    const onDataChannel = async (callback: (dc: PhygridDataChannel) => void) => {
-      return await this.onDataChannel(peripheralTwin.id, callback);
-    };
-
-    const getMediaStream = async () => {
-      if (!peripheralInstance) {
-        throw new Error('Peripheral instance not initialized');
-      }
-      return await this.getMediaStream(peripheralInstance.id);
-    };
-
-    const onMediaStream = async (callback: (stream: PhygridMediaStream) => void): Promise<void> => {
-      if (!peripheralInstance) {
-        throw new Error('Peripheral instance not initialized');
-      }
-      await this.onMediaStream(peripheralInstance.id, callback);
-      // Return void to match the expected return type
-    };
-
-    const updateReported = async (properties: Record<string, any>) => {
-      const newReported = {
-        ...properties,
-      };
-      const result = await this.updateReportedProperties(peripheralTwin.id, newReported);
-      // console.log('hub-client updateReported result', result);
-      Object.assign(peripheralInstance!, result);
-      return result;
-    };
-
-    const onUpdateReported = (callback: (reportedProperties: Record<string, any>) => void) => {
-      let previousProperties: Record<string, any> | undefined = undefined;
-
-      console.log(`[onUpdateReported] Registering handler for all reported properties`);
-
-      this.onTwinUpdate(peripheralTwin.id, (twin: TwinResponse) => {
-        console.log(`[onUpdateReported] Twin update received for ${peripheralTwin.id}`);
-
-        // Only process updates for this specific peripheral
-        if (twin.id !== peripheralTwin.id) {
-          console.log(`[onUpdateReported] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
-          return;
-        }
-
-        const reported = twin.properties.reported as Record<string, any>;
-
-        // Check if reported properties exist
-        if (reported) {
-          // If this is the first update, always trigger
-          if (previousProperties === undefined) {
-            console.log(`[onUpdateReported] First update - calling callback`);
-            previousProperties = JSON.parse(JSON.stringify(reported)); // Deep copy
-            callback(reported);
-            return;
-          }
 
-          const currentPropertiesStr = JSON.stringify(reported);
-          const previousPropertiesStr = JSON.stringify(previousProperties);
-
-          // Debug by printing parts of the strings - last 100 chars to avoid excessive logs
-          console.log(
-            `[onUpdateReported] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`
-          );
-          console.log(
-            `[onUpdateReported] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`
-          );
-
-          // Additional check - compare string lengths first
-          if (currentPropertiesStr.length !== previousPropertiesStr.length) {
-            console.log(
-              `[onUpdateReported] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`
-            );
-          }
-
-          const hasChanged = currentPropertiesStr !== previousPropertiesStr;
-
-          console.log(
-            `[onUpdateReported] Properties comparison:`,
-            hasChanged ? 'CHANGED' : 'UNCHANGED'
-          );
-
-          if (hasChanged) {
-            previousProperties = JSON.parse(currentPropertiesStr); // Deep copy
-            console.log(`[onUpdateReported] Calling callback with updated reported properties`);
-            callback(reported);
-          } else {
-            // Force a callback call at least every 5 updates to ensure clients get updates
-            // This is a safety mechanism
-            console.log(`[onUpdateReported] No change detected in properties`);
-          }
-        } else {
-          console.log(`[onUpdateReported] No reported properties found`);
-        }
-      });
-    };
-
-    const onUpdateDesired = (callback: (desiredProperties: Record<string, any>) => void) => {
-      let previousProperties: Record<string, any> | undefined = undefined;
-
-      console.log(`[onUpdateDesired] Registering handler for all desired properties`);
-
-      this.onTwinUpdate(peripheralTwin.id, (twin: TwinResponse) => {
-        console.log(`[onUpdateDesired] Twin update received for ${peripheralTwin.id}`);
-
-        // Only process updates for this specific peripheral
-        if (twin.id !== peripheralTwin.id) {
-          console.log(`[onUpdateDesired] Twin ID mismatch: ${twin.id} !== ${peripheralTwin.id}`);
-          return;
-        }
-
-        const desired = twin.properties.desired as Record<string, any>;
-
-        // Check if desired properties exist
-        if (desired) {
-          // If this is the first update, always trigger
-          if (previousProperties === undefined) {
-            console.log(`[onUpdateDesired] First update - calling callback`);
-            previousProperties = JSON.parse(JSON.stringify(desired)); // Deep copy
-            callback(desired);
-            return;
-          }
-
-          const currentPropertiesStr = JSON.stringify(desired);
-          const previousPropertiesStr = JSON.stringify(previousProperties);
-
-          // Debug by printing parts of the strings - last 100 chars to avoid excessive logs
-          console.log(
-            `[onUpdateDesired] Current (end): ...${currentPropertiesStr.substring(currentPropertiesStr.length - 100)}`
-          );
-          console.log(
-            `[onUpdateDesired] Previous (end): ...${previousPropertiesStr.substring(previousPropertiesStr.length - 100)}`
-          );
-
-          // Additional check - compare string lengths first
-          if (currentPropertiesStr.length !== previousPropertiesStr.length) {
-            console.log(
-              `[onUpdateDesired] String length changed: ${currentPropertiesStr.length} vs ${previousPropertiesStr.length}`
-            );
-          }
-
-          const hasChanged = currentPropertiesStr !== previousPropertiesStr;
-
-          console.log(
-            `[onUpdateDesired] Properties comparison:`,
-            hasChanged ? 'CHANGED' : 'UNCHANGED'
-          );
-
-          if (hasChanged) {
-            previousProperties = JSON.parse(currentPropertiesStr); // Deep copy
-            console.log(`[onUpdateDesired] Calling callback with updated desired properties`);
-            callback(desired);
-          } else {
-            // Force a callback call at least every 5 updates to ensure clients get updates
-            // This is a safety mechanism
-            console.log(`[onUpdateDesired] No change detected in properties`);
-          }
-        } else {
-          console.log(`[onUpdateDesired] No desired properties found`);
-        }
-      });
-    };
-
-    const remove = async (): Promise<TwinResponse | void> => {
-      const payload: EventPayload = {
-        data: { twinId: peripheralTwin.id },
-      };
-
-      return new Promise((resolve, reject) => {
-        this.emit('deletePeripheralTwin', payload, (response: any) => {
-          const { twin } = response;
-          resolve(twin);
-        });
-
-        this.socket?.on('error', (error: any) => {
-          reject(error);
-        });
-      });
-    };
-
-    const updateDesired = async (properties: Record<string, any>): Promise<TwinResponse> => {
-      const payload: EventPayload = {
-        twinId: peripheralTwin.id,
-        data: properties,
-      };
-
-      return new Promise((resolve, reject) => {
-        this.emit('updatePeripheralTwinDesired', payload, (response: any) => {
-          const { twin } = response;
-          resolve(twin || {});
-        });
-
-        this.socket?.on('error', (error: any) => {
-          reject(error);
-        });
-      });
-    };
-
-    peripheralInstance = {
-      ...peripheralTwin,
-      emit: peripheralTwinEmit,
-      on: peripheralTwinOn,
-      to: peripheralTwinTo,
-      updateReported,
-      updateDesired,
-      onUpdateReported,
-      onUpdateDesired,
-      remove,
-      getDataChannel,
-      onDataChannel,
-      getMediaStream,
-      onMediaStream,
-    };
-    this.peripheralInstances.set(peripheralTwinId, peripheralInstance);
+    const peripheralInstance = await this.twinInstancesRegistry.getPeripheralInstance(peripheralTwinId);
     return peripheralInstance;
   }
 
@@ -1191,7 +918,7 @@ export class PhyHubClient {
     targetTwinId: string,
     data: any,
     callback?: (response: any) => void
-  ) {
+  ) : Promise<TwinMessageResult | undefined> {
     // console.log('sendTwinMessage called with:', {
     //   targetTwinId,
     //   data,
@@ -1229,9 +956,30 @@ export class PhyHubClient {
     } else {
       // console.log('sendTwinMessage emitting with promise');
       return new Promise((resolve, reject) => {
+
+        const twinMessageTimeout = 10 * 1000;
+        const twinMessageTimeoutId = setTimeout(() => {
+          if (this.socket) {
+            this.socket?.off(payload.data.type);
+          }
+
+          reject({ status: TwinMessageResultStatus.Error, message: `twinMessage failed to complete in specified time (${twinMessageTimeout} ms)`});
+        }, twinMessageTimeout);
+
+        if (this.socket) {
+          this.socket.on(payload.data.type, (response: TwinMessageResult) => {
+            if (response && response.status !== TwinMessageResultStatus.Warning) {
+              // clear timeout on receiving twinMessage result when response status is not warning
+              clearTimeout(twinMessageTimeoutId);
+
+              this.socket?.off(payload.data.type);
+              resolve(response);
+            }
+          });
+        }
+
         this.emit(this.EVENTS.TWIN_MESSAGE, payload, (response: any) => {
-          // console.log('sendTwinMessage promise received response:', response);
-          resolve(response);
+          console.log('sendTwinMessage promise received response:', response);
         });
 
         this.socket?.on('error', (error: any) => {
@@ -1390,7 +1138,7 @@ export class PhyHubClient {
   //   });
   // }
 
-  private async updateReportedProperties(
+  public async updateReportedProperties(
     twinId: string,
     reportedProperties: Record<string, any>
   ): Promise<TwinResponse> {