@forgecart/sdk 1.0.0 → 1.2.1

package/src/admin-namespace.ts

@@ -4,7 +4,7 @@
  * This file was automatically generated and should not be manually edited.
  * To regenerate, run: npm run codegen:ts
  *
- * Generated at: 2025-12-12T11:13:16.730Z
+ * Generated at: 2025-12-15T07:01:16.361Z
  * Generator version: 1.0.0
  *
  * 🤖 Generated with ForgeCart SDK Generator
@@ -28,6 +28,8 @@ export interface SDKConfig {
   headers?: Record<string, string>;
   /** Custom WebSocket implementation (optional, auto-detected if not provided) */
   webSocketImpl?: unknown;
+  /** Use HTTP only, skip WebSocket initialization (default: false) */
+  httpOnly?: boolean;
 }
 
 export type ActiveAdministratorQueryVariables = Types.ActiveAdministratorQueryVariables;
@@ -462,12 +464,51 @@ export type UpdateCustomerNoteMutationResult = Types.UpdateCustomerNoteMutation;
 export type DeleteCustomerNoteMutationVariables = Types.DeleteCustomerNoteMutationVariables;
 export type DeleteCustomerNoteMutation = Types.DeleteCustomerNoteMutation;
 export type DeleteCustomerNoteMutationResult = Types.DeleteCustomerNoteMutation;
+export type DeploymentsQueryVariables = Types.DeploymentsQueryVariables;
+export type DeploymentsQuery = Types.DeploymentsQuery;
+export type DeploymentsQueryResult = Types.DeploymentsQuery;
+export type DeploymentQueryVariables = Types.DeploymentQueryVariables;
+export type DeploymentQuery = Types.DeploymentQuery;
+export type DeploymentQueryResult = Types.DeploymentQuery;
+export type DeploymentEnvQueryVariables = Types.DeploymentEnvQueryVariables;
+export type DeploymentEnvQuery = Types.DeploymentEnvQuery;
+export type DeploymentEnvQueryResult = Types.DeploymentEnvQuery;
+export type ChannelInfoQueryVariables = Types.ChannelInfoQueryVariables;
+export type ChannelInfoQuery = Types.ChannelInfoQuery;
+export type ChannelInfoQueryResult = Types.ChannelInfoQuery;
+export type ValidateChannelTokenQueryVariables = Types.ValidateChannelTokenQueryVariables;
+export type ValidateChannelTokenQuery = Types.ValidateChannelTokenQuery;
+export type ValidateChannelTokenQueryResult = Types.ValidateChannelTokenQuery;
+export type CreateDeploymentMutationVariables = Types.CreateDeploymentMutationVariables;
+export type CreateDeploymentMutation = Types.CreateDeploymentMutation;
+export type CreateDeploymentMutationResult = Types.CreateDeploymentMutation;
+export type DeleteDeploymentMutationVariables = Types.DeleteDeploymentMutationVariables;
+export type DeleteDeploymentMutation = Types.DeleteDeploymentMutation;
+export type DeleteDeploymentMutationResult = Types.DeleteDeploymentMutation;
+export type ScaleDeploymentMutationVariables = Types.ScaleDeploymentMutationVariables;
+export type ScaleDeploymentMutation = Types.ScaleDeploymentMutation;
+export type ScaleDeploymentMutationResult = Types.ScaleDeploymentMutation;
+export type SetDeploymentEnvMutationVariables = Types.SetDeploymentEnvMutationVariables;
+export type SetDeploymentEnvMutation = Types.SetDeploymentEnvMutation;
+export type SetDeploymentEnvMutationResult = Types.SetDeploymentEnvMutation;
+export type UnsetDeploymentEnvMutationVariables = Types.UnsetDeploymentEnvMutationVariables;
+export type UnsetDeploymentEnvMutation = Types.UnsetDeploymentEnvMutation;
+export type UnsetDeploymentEnvMutationResult = Types.UnsetDeploymentEnvMutation;
+export type RefreshDeploymentStatusMutationVariables = Types.RefreshDeploymentStatusMutationVariables;
+export type RefreshDeploymentStatusMutation = Types.RefreshDeploymentStatusMutation;
+export type RefreshDeploymentStatusMutationResult = Types.RefreshDeploymentStatusMutation;
+export type DeploymentLogsSubscriptionVariables = Types.DeploymentLogsSubscriptionVariables;
+export type DeploymentLogsSubscription = Types.DeploymentLogsSubscription;
+export type DeploymentLogsSubscriptionResult = Types.DeploymentLogsSubscription;
 export type EntityDuplicatorsQueryVariables = Types.EntityDuplicatorsQueryVariables;
 export type EntityDuplicatorsQuery = Types.EntityDuplicatorsQuery;
 export type EntityDuplicatorsQueryResult = Types.EntityDuplicatorsQuery;
 export type DuplicateEntityMutationVariables = Types.DuplicateEntityMutationVariables;
 export type DuplicateEntityMutation = Types.DuplicateEntityMutation;
 export type DuplicateEntityMutationResult = Types.DuplicateEntityMutation;
+export type EntityEventSubscriptionVariables = Types.EntityEventSubscriptionVariables;
+export type EntityEventSubscription = Types.EntityEventSubscription;
+export type EntityEventSubscriptionResult = Types.EntityEventSubscription;
 export type FacetQueryVariables = Types.FacetQueryVariables;
 export type FacetQuery = Types.FacetQuery;
 export type FacetQueryResult = Types.FacetQuery;
@@ -4448,6 +4489,108 @@ const deleteCustomerNoteDocument = `mutation deleteCustomerNote($id: ID!) {
   }
 }`;
 
+const deploymentsDocument = `query Deployments {
+  deployments {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+
+const deploymentDocument = `query Deployment($type: DeploymentType!) {
+  deployment(type: $type) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+
+const deploymentEnvDocument = `query DeploymentEnv($type: DeploymentType!) {
+  deploymentEnv(type: $type) {
+    key
+    value
+  }
+}`;
+
+const channelInfoDocument = `query ChannelInfo {
+  channelInfo {
+    id
+    code
+    name
+    domain
+    hasApplication
+    applicationName
+  }
+}`;
+
+const validateChannelTokenDocument = `query ValidateChannelToken {
+  validateChannelToken
+}`;
+
+const createDeploymentDocument = `mutation CreateDeployment($input: CreateDeploymentInput!) {
+  createDeployment(input: $input) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+
+const deleteDeploymentDocument = `mutation DeleteDeployment($type: DeploymentType!) {
+  deleteDeployment(type: $type)
+}`;
+
+const scaleDeploymentDocument = `mutation ScaleDeployment($input: ScaleDeploymentInput!) {
+  scaleDeployment(input: $input) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+
+const setDeploymentEnvDocument = `mutation SetDeploymentEnv($input: SetEnvInput!) {
+  setDeploymentEnv(input: $input)
+}`;
+
+const unsetDeploymentEnvDocument = `mutation UnsetDeploymentEnv($input: UnsetEnvInput!) {
+  unsetDeploymentEnv(input: $input)
+}`;
+
+const refreshDeploymentStatusDocument = `mutation RefreshDeploymentStatus($type: DeploymentType!) {
+  refreshDeploymentStatus(type: $type) {
+    id
+    type
+    status
+    url
+    instances
+    lastDeployedAt
+    errorMessage
+  }
+}`;
+
+const deploymentLogsDocument = `subscription DeploymentLogs($type: DeploymentType!) {
+  deploymentLogs(type: $type) {
+    timestamp
+    message
+    type
+  }
+}`;
+
 const entityDuplicatorsDocument = `query entityDuplicators {
   entityDuplicators {
     code
@@ -4479,6 +4622,19 @@ const duplicateEntityDocument = `mutation duplicateEntity($input: DuplicateEntit
   }
 }`;
 
+const entityEventDocument = `subscription entityEvent($categories: [EventCategory!]) {
+  entityEvent(categories: $categories) {
+    channelId
+    eventName
+    eventClass
+    type
+    entityId
+    entity
+    input
+    timestamp
+  }
+}`;
+
 const facetDocument = `query facet($id: ID!) {
   facet(id: $id) {
     id
@@ -8020,9 +8176,32 @@ class BaseGraphQLClient {
     this.wsEndpoint = config.wsEndpoint || 'wss://api.forgecart.com/admin-api';
     this.config = config;
 
-    // Initialize HTTP client (as fallback)
+    // Custom fetch that captures session token from response headers
+    const customFetch = async (url: RequestInfo | URL, options?: RequestInit): Promise<Response> => {
+      const response = await fetch(url, options);
+
+      // Capture session token from response header
+      const authToken = response.headers.get('forge-auth-token');
+      if (authToken && authToken !== this.authToken) {
+        this.authToken = authToken;
+        // Reconnect WebSocket with new token
+        if (this.wsClient) {
+          this.wsConnected = false;
+          this.wsClient.dispose();
+          this.wsClient = null;
+          this.wsInitializing = null;
+          this.initializeWebSocket();
+        }
+      }
+
+      return response;
+    };
+
+    // Initialize HTTP client with custom fetch
     this.httpClient = new GraphQLClient(this.endpoint, {
       headers: config.headers || {},
+      credentials: 'include',
+      fetch: customFetch,
     });
 
     // Initialize WebSocket connection immediately
@@ -8137,6 +8316,11 @@ class BaseGraphQLClient {
    * Connects immediately and tracks connection state
    */
   private initializeWebSocket(): void {
+    // Skip WebSocket if httpOnly mode is enabled
+    if (this.config.httpOnly) {
+      return;
+    }
+
     // Prevent multiple simultaneous initializations
     if (this.wsClient || this.wsInitializing) {
       return;
@@ -8159,7 +8343,23 @@ class BaseGraphQLClient {
           keepAlive: 10_000, // Send keep-alive pings every 10 seconds
           connectionParams: async () => {
             try {
-              return this.authToken ? { Authorization: `Bearer ${this.authToken}` } : {};
+              const params: Record<string, string> = {};
+
+              // Add session token if available
+              if (this.authToken) {
+                params.Authorization = `bearer ${this.authToken}`;
+              }
+
+              // Pass all configured headers (including forge-token for channel)
+              if (this.config.headers) {
+                Object.entries(this.config.headers).forEach(([key, value]) => {
+                  if (value) {
+                    params[key] = value;
+                  }
+                });
+              }
+
+              return params;
             } catch (error) {
               console.error('Error in connectionParams:', error);
               return {};
@@ -8308,6 +8508,72 @@ class BaseGraphQLClient {
   }
 }
 
+// Event handler types for SDK subscriptions
+export type EventCallback<T = EntityEventPayload> = (event: T) => void;
+export type BlockingEventCallback<T = EntityEventPayload> = (event: T) => Promise<void>;
+
+export interface EventSubscription {
+  unsubscribe: () => void;
+}
+
+interface EventHandlerRegistry {
+  handlers: Map<string, Set<EventCallback>>;
+  blockingHandlers: Map<string, Set<BlockingEventCallback>>;
+}
+
+// Entity event payload from server
+export interface EntityEventPayload {
+  channelId: string;
+  eventName: string;
+  eventClass: string;
+  type: string;
+  entityId: string | null;
+  entity: unknown;
+  input: unknown;
+  timestamp: string;
+}
+
+// Event categories for filtering
+export const ProductEvents = [
+  'product.created', 'product.updated', 'product.deleted',
+  'product.variant.created', 'product.variant.updated', 'product.variant.deleted',
+  'product.option.created', 'product.option.updated', 'product.option.deleted',
+  'product.optionGroup.created', 'product.optionGroup.updated', 'product.optionGroup.deleted',
+  'product.variant.price.updated',
+] as const;
+
+export const OrderEvents = [
+  'order.stateTransition', 'order.placementStateTransition', 'order.line.event',
+  'order.paymentStateTransition', 'order.refundStateTransition',
+  'order.coupon.applied', 'order.coupon.removed',
+] as const;
+
+export const CustomerEvents = [
+  'customer.created', 'customer.updated', 'customer.deleted',
+  'customer.address.created', 'customer.address.updated', 'customer.address.deleted',
+  'customer.groupChange', 'customer.login', 'customer.loginfail',
+] as const;
+
+export const FulfillmentEvents = [
+  'fulfillment.created', 'fulfillment.stateTransition',
+] as const;
+
+export const PaymentEvents = [
+  'payment.stateTransition', 'payment.method.created', 'payment.method.updated', 'payment.method.deleted',
+] as const;
+
+export const CatalogEvents = [
+  'collection.created', 'collection.updated', 'collection.deleted', 'collection.modification',
+  'facet.created', 'facet.updated', 'facet.deleted',
+  'facetValue.created', 'facetValue.updated', 'facetValue.deleted',
+  'asset.created', 'asset.updated', 'asset.deleted',
+] as const;
+
+export const AllEvents = [
+  ...ProductEvents, ...OrderEvents, ...CustomerEvents,
+  ...FulfillmentEvents, ...PaymentEvents, ...CatalogEvents,
+] as const;
+
 /**
  * Administrator operations
  */
@@ -8351,9 +8617,18 @@ class AdministratorOperations {
 
   /**
    * login mutation
+   * Automatically sets the auth token on successful login
    */
   async login(variables: Types.LoginMutationVariables): Promise<Types.LoginMutation> {
-    return await this.client.request<Types.LoginMutation>(loginDocument, variables);
+    const response = await this.client.request<Types.LoginMutation>(loginDocument, variables);
+
+    // Auto-set auth token if login was successful
+    const loginResult = (response as any)?.login;
+    if (loginResult && loginResult.__typename === 'CurrentUser' && loginResult.sessionToken) {
+      this.client.setAuthToken(loginResult.sessionToken);
+    }
+
+    return response;
   }
 
   /**
@@ -9386,6 +9661,100 @@ class CustomerOperations {
   }
 }
 
+/**
+ * Deployment operations
+ */
+class DeploymentOperations {
+  constructor(private client: BaseGraphQLClient) {}
+
+  /**
+   * Deployments query
+   */
+  async deployments(): Promise<Types.DeploymentsQuery> {
+    return await this.client.request<Types.DeploymentsQuery>(deploymentsDocument);
+  }
+
+  /**
+   * Deployment query
+   */
+  async deployment(variables: Types.DeploymentQueryVariables): Promise<Types.DeploymentQuery> {
+    return await this.client.request<Types.DeploymentQuery>(deploymentDocument, variables);
+  }
+
+  /**
+   * DeploymentEnv query
+   */
+  async deploymentEnv(variables: Types.DeploymentEnvQueryVariables): Promise<Types.DeploymentEnvQuery> {
+    return await this.client.request<Types.DeploymentEnvQuery>(deploymentEnvDocument, variables);
+  }
+
+  /**
+   * ChannelInfo query
+   */
+  async channelInfo(): Promise<Types.ChannelInfoQuery> {
+    return await this.client.request<Types.ChannelInfoQuery>(channelInfoDocument);
+  }
+
+  /**
+   * ValidateChannelToken query
+   */
+  async validateChannelToken(): Promise<Types.ValidateChannelTokenQuery> {
+    return await this.client.request<Types.ValidateChannelTokenQuery>(validateChannelTokenDocument);
+  }
+
+  /**
+   * CreateDeployment mutation
+   */
+  async createDeployment(variables: Types.CreateDeploymentMutationVariables): Promise<Types.CreateDeploymentMutation> {
+    return await this.client.request<Types.CreateDeploymentMutation>(createDeploymentDocument, variables);
+  }
+
+  /**
+   * DeleteDeployment mutation
+   */
+  async deleteDeployment(variables: Types.DeleteDeploymentMutationVariables): Promise<Types.DeleteDeploymentMutation> {
+    return await this.client.request<Types.DeleteDeploymentMutation>(deleteDeploymentDocument, variables);
+  }
+
+  /**
+   * ScaleDeployment mutation
+   */
+  async scaleDeployment(variables: Types.ScaleDeploymentMutationVariables): Promise<Types.ScaleDeploymentMutation> {
+    return await this.client.request<Types.ScaleDeploymentMutation>(scaleDeploymentDocument, variables);
+  }
+
+  /**
+   * SetDeploymentEnv mutation
+   */
+  async setDeploymentEnv(variables: Types.SetDeploymentEnvMutationVariables): Promise<Types.SetDeploymentEnvMutation> {
+    return await this.client.request<Types.SetDeploymentEnvMutation>(setDeploymentEnvDocument, variables);
+  }
+
+  /**
+   * UnsetDeploymentEnv mutation
+   */
+  async unsetDeploymentEnv(variables: Types.UnsetDeploymentEnvMutationVariables): Promise<Types.UnsetDeploymentEnvMutation> {
+    return await this.client.request<Types.UnsetDeploymentEnvMutation>(unsetDeploymentEnvDocument, variables);
+  }
+
+  /**
+   * RefreshDeploymentStatus mutation
+   */
+  async refreshDeploymentStatus(variables: Types.RefreshDeploymentStatusMutationVariables): Promise<Types.RefreshDeploymentStatusMutation> {
+    return await this.client.request<Types.RefreshDeploymentStatusMutation>(refreshDeploymentStatusDocument, variables);
+  }
+
+  /**
+   * DeploymentLogs subscription
+   */
+  async *deploymentLogs(variables: Types.DeploymentLogsSubscriptionVariables): AsyncIterableIterator<Types.DeploymentLogsSubscription> {
+    const iterator = this.client.subscribe<Types.DeploymentLogsSubscription>(deploymentLogsDocument, variables);
+    for await (const data of iterator) {
+      yield data;
+    }
+  }
+}
+
 /**
  * EntityDuplication operations
  */
@@ -9407,6 +9776,23 @@ class EntityDuplicationOperations {
   }
 }
 
+/**
+ * EntityEvents operations
+ */
+class EntityEventsOperations {
+  constructor(private client: BaseGraphQLClient) {}
+
+  /**
+   * entityEvent subscription
+   */
+  async *entityEvent(variables: Types.EntityEventSubscriptionVariables): AsyncIterableIterator<Types.EntityEventSubscription> {
+    const iterator = this.client.subscribe<Types.EntityEventSubscription>(entityEventDocument, variables);
+    for await (const data of iterator) {
+      yield data;
+    }
+  }
+}
+
 /**
  * Facet operations
  */
@@ -10680,7 +11066,9 @@ export class AdminNamespace {
   readonly customFields: CustomFieldsOperations;
   readonly customerGroup: CustomerGroupOperations;
   readonly customer: CustomerOperations;
+  readonly deployment: DeploymentOperations;
   readonly entityDuplication: EntityDuplicationOperations;
+  readonly entityEvents: EntityEventsOperations;
   readonly facet: FacetOperations;
   readonly fulfillment: FulfillmentOperations;
   readonly globalSettings: GlobalSettingsOperations;
@@ -10704,6 +11092,25 @@ export class AdminNamespace {
   readonly tax: TaxOperations;
   readonly zone: ZoneOperations;
 
+  // Event handler registry and state
+  private eventRegistry: EventHandlerRegistry = {
+    handlers: new Map(),
+    blockingHandlers: new Map(),
+  };
+  private eventSubscription: AsyncIterableIterator<{ entityEvent: EntityEventPayload }> | null = null;
+  private isListening = false;
+  private retryCount = 0;
+  private abortController: AbortController | null = null;
+
+  // Reconnection configuration
+  private static readonly RECONNECT_CONFIG = {
+    maxRetries: 5,
+    baseDelayMs: 1000,
+    maxDelayMs: 30000,
+    backoffMultiplier: 2,
+  };
+  private static readonly BLOCKING_TIMEOUT_MS = 1000;
+
   constructor(config: SDKConfig) {
     this.client = new BaseGraphQLClient(config);
 
@@ -10717,7 +11124,9 @@ export class AdminNamespace {
     this.customFields = new CustomFieldsOperations(this.client);
     this.customerGroup = new CustomerGroupOperations(this.client);
     this.customer = new CustomerOperations(this.client);
+    this.deployment = new DeploymentOperations(this.client);
     this.entityDuplication = new EntityDuplicationOperations(this.client);
+    this.entityEvents = new EntityEventsOperations(this.client);
     this.facet = new FacetOperations(this.client);
     this.fulfillment = new FulfillmentOperations(this.client);
     this.globalSettings = new GlobalSettingsOperations(this.client);
@@ -10763,4 +11172,173 @@ export class AdminNamespace {
   dispose(): void {
     this.client.dispose();
   }
+
+  /**
+   * Register a non-blocking event handler
+   * The callback will be called for each matching event without waiting
+   */
+  registerEventHandler(
+    eventName: string,
+    callback: EventCallback
+  ): EventSubscription {
+    if (!this.eventRegistry.handlers.has(eventName)) {
+      this.eventRegistry.handlers.set(eventName, new Set());
+    }
+    this.eventRegistry.handlers.get(eventName)!.add(callback);
+
+    void this.ensureEventListening();
+
+    return {
+      unsubscribe: () => {
+        this.eventRegistry.handlers.get(eventName)?.delete(callback);
+      },
+    };
+  }
+
+  /**
+   * Register a blocking event handler
+   * The callback must complete within 1000ms or it will timeout
+   */
+  registerBlockingEventHandler(
+    eventName: string,
+    callback: BlockingEventCallback
+  ): EventSubscription {
+    if (!this.eventRegistry.blockingHandlers.has(eventName)) {
+      this.eventRegistry.blockingHandlers.set(eventName, new Set());
+    }
+    this.eventRegistry.blockingHandlers.get(eventName)!.add(callback);
+
+    void this.ensureEventListening();
+
+    return {
+      unsubscribe: () => {
+        this.eventRegistry.blockingHandlers.get(eventName)?.delete(callback);
+      },
+    };
+  }
+
+  /**
+   * Start listening to events with retry logic
+   */
+  private async ensureEventListening(): Promise<void> {
+    if (this.isListening) return;
+    this.isListening = true;
+    this.retryCount = 0;
+    this.abortController = new AbortController();
+
+    await this.startSubscription();
+  }
+
+  private async startSubscription(): Promise<void> {
+    try {
+      this.eventSubscription = this.client.subscribe<{ entityEvent: EntityEventPayload }>(
+        entityEventDocument,
+        {}
+      );
+
+      // Reset retry count on successful connection
+      this.retryCount = 0;
+
+      // Process events
+      for await (const result of this.eventSubscription!) {
+        if (!this.isListening) break;
+        const event = result.entityEvent;
+        await this.dispatchEvent(event);
+      }
+    } catch (error) {
+      if (this.isListening) {
+        console.error('Event subscription error:', error);
+        await this.handleReconnect();
+      }
+    }
+  }
+
+  private async handleReconnect(): Promise<void> {
+    const { maxRetries, baseDelayMs, maxDelayMs, backoffMultiplier } = AdminNamespace.RECONNECT_CONFIG;
+
+    if (this.retryCount >= maxRetries) {
+      this.isListening = false;
+      throw new Error(`Max reconnection attempts (${maxRetries}) exceeded`);
+    }
+
+    // Calculate delay with exponential backoff
+    const delay = Math.min(
+      baseDelayMs * Math.pow(backoffMultiplier, this.retryCount),
+      maxDelayMs
+    );
+
+    this.retryCount++;
+    console.log(`Reconnecting in ${delay}ms (attempt ${this.retryCount}/${maxRetries})`);
+
+    await new Promise(resolve => setTimeout(resolve, delay));
+    await this.startSubscription();
+  }
+
+  /**
+   * Dispatch event to registered handlers
+   */
+  private async dispatchEvent(event: EntityEventPayload): Promise<void> {
+    const eventName = event.eventName;
+
+    // Non-blocking handlers (fire-and-forget)
+    const handlers = this.eventRegistry.handlers.get(eventName);
+    if (handlers) {
+      for (const handler of handlers) {
+        try {
+          handler(event);
+        } catch (error) {
+          console.error(`Error in event handler for ${eventName}:`, error);
+        }
+      }
+    }
+
+    // Blocking handlers (with timeout)
+    const blockingHandlers = this.eventRegistry.blockingHandlers.get(eventName);
+    if (blockingHandlers) {
+      for (const handler of blockingHandlers) {
+        try {
+          await this.executeWithTimeout(
+            handler(event),
+            AdminNamespace.BLOCKING_TIMEOUT_MS,
+            `Blocking handler for ${eventName} exceeded ${AdminNamespace.BLOCKING_TIMEOUT_MS}ms`
+          );
+        } catch (error) {
+          console.error(`Error in blocking event handler for ${eventName}:`, error);
+          throw error; // Re-throw for blocking handlers
+        }
+      }
+    }
+  }
+
+  /**
+   * Execute promise with timeout
+   */
+  private async executeWithTimeout<T>(
+    promise: Promise<T>,
+    timeoutMs: number,
+    errorMessage: string
+  ): Promise<T> {
+    return Promise.race([
+      promise,
+      new Promise<never>((_, reject) =>
+        setTimeout(() => reject(new Error(errorMessage)), timeoutMs)
+      ),
+    ]);
+  }
+
+  /**
+   * Stop all event listening
+   */
+  stopEventListening(): void {
+    this.isListening = false;
+    this.retryCount = 0;
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this.eventSubscription = null;
+    this.eventRegistry.handlers.clear();
+    this.eventRegistry.blockingHandlers.clear();
+  }
+
 }