@phystack/hub-client 4.5.19-dev → 4.5.21-dev

package/src/peripheral-twin.ts

@@ -0,0 +1,337 @@
+import { EventPayload, PhygridDataChannel, PhygridMediaStream, PhyHubClient } from ".";
+import { Instance, TwinMessageResult, TwinResponse, TwinTypeEnum } from "./types/twin.types";
+import { createTwinMessaging, TwinMessagingMethods } from "./twin-messaging";
+
+export class PeripheralTwinInstance {
+  public phyHubClient: PhyHubClient;
+  public twinId: string;
+  public edgeInstance: Instance | null = null;
+  public peripheralTwinResponse: TwinResponse | null = null;
+
+  private messaging: TwinMessagingMethods | null = null;
+
+  constructor(phyHubClient: PhyHubClient, twinId: string) {
+    this.phyHubClient = phyHubClient;
+    this.twinId = twinId;
+  }
+
+  // initialize the instance by performing sanity checks
+  async initialize() {
+    const edgeInstance = await this.phyHubClient.getInstance();
+    if (!edgeInstance) {
+      console.error('Edge instance not found');
+      throw new Error('Edge instance not found');
+    }
+    this.edgeInstance = edgeInstance;
+
+    const peripheralTwinResponse = await this.phyHubClient.getTwinById(this.twinId);
+    if (!peripheralTwinResponse) {
+      console.error(`Peripheral twin with id ${this.twinId} not found`);
+      throw new Error(`Peripheral twin with id ${this.twinId} not found`);
+    }
+
+    if (peripheralTwinResponse.type !== TwinTypeEnum.Peripheral) {
+      console.error(`Twin ${this.twinId} is not a peripheral twin`);
+      throw new Error(`Twin ${this.twinId} is not a peripheral twin`);
+    }
+
+    this.peripheralTwinResponse = peripheralTwinResponse;
+
+    // Create messaging methods using the shared factory
+    this.messaging = createTwinMessaging({
+      sendEvent: (targetTwinId, payload) => this.phyHubClient.sendEvent(targetTwinId, payload),
+      onTwinMessage: (twinId, callback) => this.phyHubClient.onTwinMessage(twinId, callback),
+      twinId: peripheralTwinResponse.id,
+      deviceId: edgeInstance.deviceId,
+      typePrefix: `peripheralInstance:${peripheralTwinResponse.id}`,
+    });
+
+    await this.phyHubClient.subscribeTwin(this.twinId);
+  }
+
+  private ensureInitialized(): void {
+    if (!this.messaging) {
+      throw new Error('[PeripheralTwinInstance] Not initialized. Call initialize() first.');
+    }
+  }
+
+  /**
+   * Send a message to this peripheral.
+   * - Without callback: Fire-and-forget (returns void)
+   * - With callback: Request-response pattern (returns Promise)
+   *
+   * Note: Peripheral emit is targeted (not broadcast), so callbacks are supported.
+   * Internally uses to(twinId).emit() for request-response pattern.
+   */
+  emit(eventType: string, payload: any): void;
+  emit(eventType: string, payload: any, callback: (response: TwinMessageResult) => void): Promise<TwinMessageResult>;
+  emit(
+    eventType: string,
+    payload: any,
+    callback?: (response: TwinMessageResult) => void
+  ): void | Promise<TwinMessageResult> {
+    this.ensureInitialized();
+    if (callback) {
+      // Use to().emit() for request-response since peripheral communication is targeted
+      return this.messaging!.to(this.twinId).emit(eventType, payload, callback);
+    } else {
+      this.messaging!.emit(eventType, payload);
+    }
+  }
+
+  /**
+   * Listen for events, with optional respond callback for request-response
+   */
+  on(
+    eventType: string,
+    callback: (message: any, respond?: (result: TwinMessageResult) => void) => void
+  ) {
+    this.ensureInitialized();
+    this.messaging!.on(eventType, callback);
+  }
+
+  to(targetTwinId: string) {
+    this.ensureInitialized();
+    return this.messaging!.to(targetTwinId);
+  }
+
+  async getDataChannel() {
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    return await this.phyHubClient.getDataChannel(this.peripheralTwinResponse.id);
+  };
+
+  async onDataChannel(callback: (dc: PhygridDataChannel) => void) {
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    await this.phyHubClient.onDataChannel(this.peripheralTwinResponse.id, callback);
+  };
+
+  async getMediaStream() {
+    if (!this.peripheralTwinResponse) {
+      console.error('Object is not initialized correctly');
+      return;
+    }
+
+    return await this.phyHubClient.getMediaStream(this.peripheralTwinResponse.id);
+  };
+
+  async onMediaStream(callback: (stream: PhygridMediaStream) => void): Promise<void> {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    await this.phyHubClient.onMediaStream(this.peripheralTwinResponse.id, callback);
+  };
+
+  async updateReported(properties: Record<string, any>) {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    const newReported = {
+      ...properties,
+    };
+
+    const result = await this.phyHubClient.updateReportedProperties(this.peripheralTwinResponse.id, newReported);
+
+    this.peripheralTwinResponse = Object.assign({}, this.peripheralTwinResponse, result);
+
+    return result;
+  };
+
+  onUpdateReported(callback: (reportedProperties: Record<string, any>) => void) {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    let previousProperties: Record<string, any> | undefined = undefined;
+
+    console.log(`[onUpdateReported] Registering handler for all reported properties`);
+
+    this.phyHubClient.onTwinUpdate(this.peripheralTwinResponse.id, (twin: TwinResponse) => {
+      console.log(`[onUpdateReported] Twin update received for ${this.peripheralTwinResponse!.id}`);
+
+      // Only process updates for this specific peripheral
+      if (twin.id !== this.peripheralTwinResponse!.id) {
+        console.log(`[onUpdateReported] Twin ID mismatch: ${twin.id} !== ${this.peripheralTwinResponse!.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`);
+      }
+    });
+  };
+
+  async updateDesired(properties: Record<string, any>): Promise<TwinResponse>{
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    const payload: EventPayload = {
+      twinId: this.peripheralTwinResponse.id,
+      data: properties,
+    };
+
+    const phyClientSocket = this.phyHubClient.getSocket();
+
+    return new Promise((resolve, reject) => {
+      this.phyHubClient.emit('updatePeripheralTwinDesired', payload, (response: any) => {
+        const { twin } = response;
+        resolve(twin || {});
+      });
+
+      phyClientSocket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  };
+
+  onUpdateDesired(callback: (desiredProperties: Record<string, any>) => void) {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    let previousProperties: Record<string, any> | undefined = undefined;
+
+    console.log(`[onUpdateDesired] Registering handler for all desired properties`);
+
+    this.phyHubClient.onTwinUpdate(this.peripheralTwinResponse.id, (twin: TwinResponse) => {
+      console.log(`[onUpdateDesired] Twin update received for ${this.peripheralTwinResponse!.id}`);
+
+      // Only process updates for this specific peripheral
+      if (twin.id !== this.peripheralTwinResponse!.id) {
+        console.log(`[onUpdateDesired] Twin ID mismatch: ${twin.id} !== ${this.peripheralTwinResponse!.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`);
+      }
+    });
+  };
+
+  async remove() : Promise<TwinResponse | void> {
+    if (!this.peripheralTwinResponse) {
+      throw new Error('Peripheral instance not initialized');
+    }
+
+    const payload: EventPayload = {
+      data: { twinId: this.peripheralTwinResponse.id },
+    };
+
+    const phyClientSocket = this.phyHubClient.getSocket();
+
+    return new Promise((resolve, reject) => {
+      this.phyHubClient.emit('deletePeripheralTwin', payload, (response: any) => {
+        const { twin } = response;
+        resolve(twin);
+      });
+
+      phyClientSocket?.on('error', (error: any) => {
+        reject(error);
+      });
+    });
+  };
+
+}
+

package/src/services/phyhub-connection.service.ts

@@ -2,6 +2,8 @@ import { Socket } from 'socket.io-client';
 import { get } from 'lodash';
 import { isBrowser } from '../helpers/browser.helper';
 import { getSocketIOWithProxy } from '@phystack/socket.io-proxy';
+import { PhyHubDirectConnection } from './phyhub-direct-connection.service';
+
 interface UrlConfig {
   url: string;
   timeout: number;
@@ -14,12 +16,26 @@ export class PhyHubConnection {
   private socketUrls: UrlConfig[] = [];
   private instanceId: string | undefined;
   private moduleName: string | undefined;
+  private directConnection: PhyHubDirectConnection | null = null;
 
   private constructor(
     params: { instanceId?: string; moduleName?: string; dataResidency?: string } = {}
   ) {
     this.instanceId = params.instanceId;
     this.moduleName = params.moduleName;
+
+    // Check for direct connection mode (for testing)
+    if (PhyHubDirectConnection.isEnabled()) {
+      this.directConnection = PhyHubDirectConnection.fromEnv();
+      if (this.directConnection) {
+        console.log('[PhyHubConnection] Direct connection mode enabled');
+        // Use device ID as instance ID if not provided
+        if (!this.instanceId) {
+          this.instanceId = this.directConnection.getInstanceId();
+        }
+      }
+    }
+
     this.setSocketUrls(params.dataResidency);
     this.fetchPhygridSocketInstance();
   }
@@ -137,6 +153,14 @@ export class PhyHubConnection {
   public async getPhyHubSocket(): Promise<Socket> {
     console.info(`getPhyHubSocket(): Getting phyhub socket`);
 
+    // Use direct connection if enabled (for testing)
+    if (this.directConnection) {
+      console.log('[PhyHubConnection] Using direct connection');
+      const socket = await this.directConnection.connect();
+      this.phygridSocketSingleton = socket;
+      return socket;
+    }
+
     // Always check top window first
     if (isBrowser) {
       const topWindow = this.getTopWindow();

package/src/services/phyhub-direct-connection.service.ts

@@ -0,0 +1,159 @@
+/**
+ * PhyHub Direct Connection Service
+ *
+ * Allows direct connection to PhyHub for testing purposes,
+ * bypassing the phyos layer that normally runs on devices.
+ *
+ * Usage:
+ *   - Set PHYHUB_DIRECT=true to enable direct connection
+ *   - Provide DEVICE_ID and ACCESS_KEY environment variables
+ *   - Optionally set PHYHUB_URL (defaults to EU region)
+ */
+
+import { Socket } from 'socket.io-client';
+import { getSocketIOWithProxy } from '@phystack/socket.io-proxy';
+
+export interface DirectConnectionConfig {
+  deviceId: string;
+  accessKey: string;
+  phyhubUrl?: string;
+  instanceId?: string; // Optional: override the twin ID to use
+}
+
+const DEFAULT_PHYHUB_URLS: Record<string, string> = {
+  eu: 'https://phyhub.eu.omborigrid.net',
+  us: 'https://phyhub.us.omborigrid.net',
+  uae: 'https://phyhub.uae.omborigrid.net',
+  au: 'https://phyhub.au.omborigrid.net',
+  in: 'https://phyhub.in.omborigrid.net',
+  qa: 'https://phyhub.qa.omborigrid.net',
+  dev: 'https://phyhub.dev.omborigrid.net',
+  local: 'http://localhost:3000',
+};
+
+export class PhyHubDirectConnection {
+  private socket: Socket | null = null;
+  private config: DirectConnectionConfig;
+
+  constructor(config: DirectConnectionConfig) {
+    this.config = {
+      ...config,
+      phyhubUrl: config.phyhubUrl || DEFAULT_PHYHUB_URLS.eu,
+    };
+  }
+
+  /**
+   * Create a direct connection from environment variables
+   * @throws Error if required environment variables are missing
+   */
+  static fromEnv(): PhyHubDirectConnection {
+    const deviceId = process.env.DEVICE_ID || process.env.PHYGRID_DEVICE_ID;
+    const accessKey = process.env.ACCESS_KEY || process.env.PHYGRID_DEVICE_KEY;
+
+    if (!deviceId) {
+      throw new Error('[PhyHubDirectConnection] DEVICE_ID or PHYGRID_DEVICE_ID env var required');
+    }
+    if (!accessKey) {
+      throw new Error('[PhyHubDirectConnection] ACCESS_KEY or PHYGRID_DEVICE_KEY env var required');
+    }
+
+    const region = process.env.PHYHUB_REGION?.toLowerCase();
+    const phyhubUrl = process.env.PHYHUB_URL || (region ? DEFAULT_PHYHUB_URLS[region] : undefined);
+
+    if (!phyhubUrl) {
+      throw new Error(`[PhyHubDirectConnection] PHYHUB_URL or valid PHYHUB_REGION required. Valid regions: ${Object.keys(DEFAULT_PHYHUB_URLS).join(', ')}`);
+    }
+
+    return new PhyHubDirectConnection({
+      deviceId,
+      accessKey,
+      phyhubUrl,
+      instanceId: process.env.TWIN_ID || process.env.INSTANCE_ID,
+    });
+  }
+
+  /**
+   * Check if direct connection mode is enabled
+   */
+  static isEnabled(): boolean {
+    return process.env.PHYHUB_DIRECT === 'true' || process.env.PHYHUB_DIRECT === '1';
+  }
+
+  /**
+   * Get the device ID (also used as the primary twin ID)
+   */
+  getDeviceId(): string {
+    return this.config.deviceId;
+  }
+
+  /**
+   * Get the instance/twin ID to use
+   */
+  getInstanceId(): string {
+    return this.config.instanceId || this.config.deviceId;
+  }
+
+  /**
+   * Connect directly to PhyHub
+   */
+  async connect(): Promise<Socket> {
+    if (this.socket?.connected) {
+      return this.socket;
+    }
+
+    const { deviceId, accessKey, phyhubUrl } = this.config;
+
+    console.log(`[PhyHubDirectConnection] Connecting to ${phyhubUrl}`);
+    console.log(`[PhyHubDirectConnection] Device ID: ${deviceId}`);
+
+    this.socket = await getSocketIOWithProxy(phyhubUrl!, {
+      auth: {
+        deviceId,
+        accessKey,
+      },
+      reconnection: true,
+      reconnectionAttempts: 5,
+      reconnectionDelay: 1000,
+      timeout: 10000,
+    });
+
+    await new Promise<void>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error('Connection timeout'));
+      }, 15000);
+
+      this.socket!.on('connect', () => {
+        clearTimeout(timeout);
+        console.log(`[PhyHubDirectConnection] Connected successfully`);
+        resolve();
+      });
+
+      this.socket!.on('connect_error', (error) => {
+        clearTimeout(timeout);
+        console.error(`[PhyHubDirectConnection] Connection error:`, error.message);
+        reject(error);
+      });
+    });
+
+    return this.socket;
+  }
+
+  /**
+   * Disconnect from PhyHub
+   */
+  disconnect(): void {
+    if (this.socket) {
+      this.socket.disconnect();
+      this.socket = null;
+    }
+  }
+
+  /**
+   * Get the socket instance
+   */
+  getSocket(): Socket | null {
+    return this.socket;
+  }
+}
+
+export default PhyHubDirectConnection;