@phystack/hub-client 4.4.53 → 4.4.55

package/src/peripheral-twin.ts

@@ -1,5 +1,6 @@
 import { EventPayload, PhygridDataChannel, PhygridMediaStream, PhyHubClient } from ".";
-import { Instance, TwinResponse, TwinTypeEnum } from "./types/twin.types";
+import { Instance, TwinMessageResult, TwinResponse, TwinTypeEnum } from "./types/twin.types";
+import { createTwinMessaging, TwinMessagingMethods } from "./twin-messaging";
 
 export class PeripheralTwinInstance {
   public phyHubClient: PhyHubClient;
@@ -7,7 +8,7 @@ export class PeripheralTwinInstance {
   public edgeInstance: Instance | null = null;
   public peripheralTwinResponse: TwinResponse | null = null;
 
-  private instanceTypePrefix = 'peripheralInstance';
+  private messaging: TwinMessagingMethods | null = null;
 
   constructor(phyHubClient: PhyHubClient, twinId: string) {
     this.phyHubClient = phyHubClient;
@@ -36,82 +37,58 @@ export class PeripheralTwinInstance {
 
     this.peripheralTwinResponse = peripheralTwinResponse;
 
-    await this.phyHubClient.subscribeTwin(this.twinId);
-  }
+    // 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}`,
+    });
 
-  // alias to sendEvent()
-  async emit(eventType: string, payload: any) {
-    return await this.sendEvent(eventType, payload);
+    await this.phyHubClient.subscribeTwin(this.twinId);
   }
 
-  async sendEvent(eventType: string, payload: any) {
-    return await this.peripheralTwinEmit(eventType, payload);
+  private ensureInitialized(): void {
+    if (!this.messaging) {
+      throw new Error('[PeripheralTwinInstance] Not initialized. Call initialize() first.');
+    }
   }
 
-  private async peripheralTwinEmit(eventType: string, payload: any) {
-    if (!this.edgeInstance || !this.peripheralTwinResponse) {
-     throw new Error('Object is not initialized correctly');
+  /**
+   * Send a message to the twin.
+   * - Without callback: Fire-and-forget (returns void)
+   * - With callback: Request-response pattern (returns Promise)
+   */
+  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) {
+      return this.messaging!.emit(eventType, payload, callback);
+    } else {
+      this.messaging!.emit(eventType, payload);
     }
-
-    const messagePayload = {
-      type: `${this.instanceTypePrefix}:${this.peripheralTwinResponse.id}:${eventType}`,
-      sourceTwinId: this.peripheralTwinResponse.id,
-      sourceDeviceId: this.edgeInstance.deviceId,
-      data: payload,
-    };
-
-    const result = await this.phyHubClient.sendTwinMessage(this.peripheralTwinResponse.id, messagePayload);
-    return result;
-  };
-
-  // alias to onEvent()
-  on(eventType: string, callback: (message: any) => void) {
-    return this.onEvent(eventType, callback);
   }
 
-  onEvent(eventType: string, callback: (message: any) => void) {
-    return this.peripheralTwinOn(eventType, callback);
+  /**
+   * 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);
   }
 
-  private peripheralTwinOn(eventType: string, callback: (message: any) => void) {
-    console.log(`Setting up listener for peripheral ${this.twinId} event: ${eventType}`);
-
-    if (!this.peripheralTwinResponse) {
-      console.error('Object is not initialized correctly');
-      return;
-    }
-
-    const onMessage = (payload: any) => {
-      // console.log(`Received message for peripheral ${peripheralTwinId}:`, payload);
-      const messageType = payload.data?.type || payload.type;
-      if (messageType === `${this.instanceTypePrefix}:${this.peripheralTwinResponse!.id}:${eventType}`) {
-        // console.log('Processing matching message type');
-        callback(payload.data?.data || payload.data);
-      } else {
-        // console.log('Ignoring non-matching message type:', messageType);
-      }
-    };
-
-    this.phyHubClient.onTwinMessage(this.peripheralTwinResponse.id, onMessage);
-  };
-
   to(targetTwinId: string) {
-    return {
-      emit: async (eventType: string, payload: any) => {
-        if (!this.edgeInstance || !this.peripheralTwinResponse) {
-          throw new Error('Object is not initialized correctly');
-        }
-
-        const messagePayload = {
-          type: `${this.instanceTypePrefix}:${this.peripheralTwinResponse.id}:${eventType}`,
-          sourceTwinId: this.edgeInstance.id,
-          sourceDeviceId: this.edgeInstance.deviceId,
-          data: payload,
-        };
-
-        return await this.phyHubClient.sendTwinMessage(targetTwinId, messagePayload);
-      }
-    }
+    this.ensureInitialized();
+    return this.messaging!.to(targetTwinId);
   }
 
   async getDataChannel() {

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;