@oxyhq/services 5.16.35 → 5.16.36

package/src/shared/transport/index.ts

@@ -1,349 +0,0 @@
-/**
- * Transport Abstraction
- * 
- * Unified transport layer for WebSocket, SSE, and polling.
- * Provides automatic fallback and unified configuration.
- */
-
-export type TransportType = 'websocket' | 'sse' | 'polling';
-
-export interface TransportConfig {
-  baseURL: string;
-  namespace?: string;
-  sessionToken?: string;
-  accessToken?: string;
-  pollingInterval?: number; // milliseconds
-  reconnectAttempts?: number;
-  reconnectDelay?: number; // milliseconds
-  timeout?: number; // milliseconds
-}
-
-export interface TransportUpdate {
-  status: 'authorized' | 'cancelled' | 'expired' | 'pending';
-  sessionId?: string;
-  publicKey?: string;
-  userId?: string;
-  username?: string;
-  [key: string]: unknown;
-}
-
-export interface TransportCallbacks {
-  onUpdate?: (update: TransportUpdate) => void;
-  onConnect?: () => void;
-  onDisconnect?: () => void;
-  onError?: (error: Error) => void;
-}
-
-/**
- * Transport Interface
- * All transport implementations must implement this
- */
-export interface Transport {
-  /**
-   * Connect to the transport
-   */
-  connect(): Promise<void>;
-
-  /**
-   * Disconnect from the transport
-   */
-  disconnect(): void;
-
-  /**
-   * Check if currently connected
-   */
-  isConnected(): boolean;
-
-  /**
-   * Get the transport type
-   */
-  getType(): TransportType;
-}
-
-/**
- * Transport Factory
- * Creates the appropriate transport based on availability and configuration
- */
-export class TransportFactory {
-  /**
-   * Create a transport with automatic fallback
-   * Tries WebSocket first, then SSE, then polling
-   */
-  static async create(
-    config: TransportConfig,
-    callbacks: TransportCallbacks
-  ): Promise<Transport> {
-    // Try WebSocket first (best for real-time)
-    if (await this.isWebSocketAvailable()) {
-      try {
-        return new WebSocketTransport(config, callbacks);
-      } catch (error) {
-        // Fall through to SSE
-      }
-    }
-
-    // Try SSE second (good for one-way updates)
-    if (await this.isSSEAvailable()) {
-      try {
-        return new SSETransport(config, callbacks);
-      } catch (error) {
-        // Fall through to polling
-      }
-    }
-
-    // Fall back to polling (always available)
-    return new PollingTransport(config, callbacks);
-  }
-
-  /**
-   * Check if WebSocket is available
-   */
-  private static async isWebSocketAvailable(): Promise<boolean> {
-    // WebSocket is available in browsers and Node.js with socket.io-client
-    return typeof window !== 'undefined' || typeof process !== 'undefined';
-  }
-
-  /**
-   * Check if SSE is available
-   */
-  private static async isSSEAvailable(): Promise<boolean> {
-    // SSE is available in browsers via EventSource
-    // In Node.js, would need a polyfill or library
-    return typeof EventSource !== 'undefined' || 
-           (typeof window !== 'undefined' && 'EventSource' in window);
-  }
-}
-
-/**
- * WebSocket Transport Implementation
- * Uses socket.io-client for WebSocket connections
- */
-class WebSocketTransport implements Transport {
-  private socket: any = null;
-  private config: TransportConfig;
-  private callbacks: TransportCallbacks;
-  private connected = false;
-
-  constructor(config: TransportConfig, callbacks: TransportCallbacks) {
-    this.config = config;
-    this.callbacks = callbacks;
-  }
-
-  async connect(): Promise<void> {
-    // Dynamic import to avoid bundling socket.io-client if not needed
-    let io: any;
-    try {
-      io = (await import('socket.io-client')).default;
-    } catch (error) {
-      throw new Error('socket.io-client is required for WebSocket transport. Install it as a dependency.');
-    }
-    
-    const url = this.config.namespace
-      ? `${this.config.baseURL}/${this.config.namespace}`
-      : this.config.baseURL;
-
-    const socketOptions: any = {
-      transports: ['websocket', 'polling'],
-      reconnection: true,
-      reconnectionAttempts: this.config.reconnectAttempts ?? 3,
-      reconnectionDelay: this.config.reconnectDelay ?? 1000,
-    };
-
-    if (this.config.accessToken) {
-      socketOptions.auth = { token: this.config.accessToken };
-    }
-
-    this.socket = io(url, socketOptions);
-
-    this.socket.on('connect', () => {
-      this.connected = true;
-      if (this.config.sessionToken) {
-        this.socket.emit('join', this.config.sessionToken);
-      }
-      this.callbacks.onConnect?.();
-    });
-
-    this.socket.on('auth_update', (payload: TransportUpdate) => {
-      this.callbacks.onUpdate?.(payload);
-    });
-
-    this.socket.on('connect_error', (error: Error) => {
-      this.callbacks.onError?.(error);
-    });
-
-    this.socket.on('disconnect', () => {
-      this.connected = false;
-      this.callbacks.onDisconnect?.();
-    });
-  }
-
-  disconnect(): void {
-    if (this.socket) {
-      this.socket.disconnect();
-      this.socket = null;
-      this.connected = false;
-    }
-  }
-
-  isConnected(): boolean {
-    return this.connected && this.socket?.connected === true;
-  }
-
-  getType(): TransportType {
-    return 'websocket';
-  }
-}
-
-/**
- * SSE Transport Implementation
- * Uses EventSource for Server-Sent Events
- */
-class SSETransport implements Transport {
-  private eventSource: EventSource | null = null;
-  private config: TransportConfig;
-  private callbacks: TransportCallbacks;
-  private connected = false;
-
-  constructor(config: TransportConfig, callbacks: TransportCallbacks) {
-    this.config = config;
-    this.callbacks = callbacks;
-  }
-
-  async connect(): Promise<void> {
-    if (typeof EventSource === 'undefined') {
-      throw new Error('EventSource is not available in this environment');
-    }
-
-    const url = this.config.sessionToken
-      ? `${this.config.baseURL}/auth/session/stream/${this.config.sessionToken}`
-      : `${this.config.baseURL}/auth/session/stream`;
-
-    this.eventSource = new EventSource(url);
-
-    this.eventSource.onopen = () => {
-      this.connected = true;
-      this.callbacks.onConnect?.();
-    };
-
-    this.eventSource.onmessage = (event) => {
-      try {
-        const update = JSON.parse(event.data) as TransportUpdate;
-        this.callbacks.onUpdate?.(update);
-      } catch (error) {
-        this.callbacks.onError?.(error as Error);
-      }
-    };
-
-    this.eventSource.onerror = (error) => {
-      this.callbacks.onError?.(new Error('SSE connection error'));
-    };
-  }
-
-  disconnect(): void {
-    if (this.eventSource) {
-      this.eventSource.close();
-      this.eventSource = null;
-      this.connected = false;
-    }
-  }
-
-  isConnected(): boolean {
-    return this.connected && this.eventSource?.readyState === EventSource.OPEN;
-  }
-
-  getType(): TransportType {
-    return 'sse';
-  }
-}
-
-/**
- * Polling Transport Implementation
- * Uses HTTP polling as fallback
- */
-class PollingTransport implements Transport {
-  private intervalId: ReturnType<typeof setInterval> | null = null;
-  private config: TransportConfig;
-  private callbacks: TransportCallbacks;
-  private connected = false;
-  private abortController: AbortController | null = null;
-
-  constructor(config: TransportConfig, callbacks: TransportCallbacks) {
-    this.config = config;
-    this.callbacks = callbacks;
-  }
-
-  async connect(): Promise<void> {
-    this.connected = true;
-    this.callbacks.onConnect?.();
-
-    const poll = async () => {
-      if (!this.config.sessionToken) {
-        return;
-      }
-
-      try {
-        this.abortController = new AbortController();
-        const response = await fetch(
-          `${this.config.baseURL}/api/auth/session/status/${this.config.sessionToken}`,
-          {
-            signal: this.abortController.signal,
-            headers: this.config.accessToken
-              ? { Authorization: `Bearer ${this.config.accessToken}` }
-              : {},
-          }
-        );
-
-        if (!response.ok) {
-          throw new Error(`Polling failed: ${response.statusText}`);
-        }
-
-        const data = await response.json();
-        
-        if (data.authorized && data.sessionId) {
-          this.callbacks.onUpdate?.({
-            status: 'authorized',
-            sessionId: data.sessionId,
-            publicKey: data.publicKey,
-          });
-        } else if (data.status === 'expired') {
-          this.callbacks.onUpdate?.({ status: 'expired' });
-        } else if (data.status === 'cancelled') {
-          this.callbacks.onUpdate?.({ status: 'cancelled' });
-        }
-      } catch (error) {
-        if (error instanceof Error && error.name !== 'AbortError') {
-          this.callbacks.onError?.(error);
-        }
-      }
-    };
-
-    // Poll immediately, then at intervals
-    await poll();
-    this.intervalId = setInterval(
-      poll,
-      this.config.pollingInterval ?? 3000
-    );
-  }
-
-  disconnect(): void {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-    }
-    if (this.abortController) {
-      this.abortController.abort();
-      this.abortController = null;
-    }
-    this.connected = false;
-    this.callbacks.onDisconnect?.();
-  }
-
-  isConnected(): boolean {
-    return this.connected && this.intervalId !== null;
-  }
-
-  getType(): TransportType {
-    return 'polling';
-  }
-}
-

package/src/shared/utils/index.ts

@@ -1,73 +0,0 @@
-/**
- * Shared Utilities
- * 
- * Common utility functions used across Accounts, Services SDK, and API packages.
- */
-
-/**
- * Get a shortened display version of a public key
- * Format: first 8 chars ... last 8 chars
- */
-export function shortenPublicKey(publicKey: string): string {
-  if (publicKey.length <= 16) return publicKey;
-  return `${publicKey.slice(0, 8)}...${publicKey.slice(-8)}`;
-}
-
-/**
- * Generate a secure random session token
- * Uses crypto.randomBytes (Node) or Web Crypto API (Browser/RN)
- */
-export async function generateSessionToken(size: number = 32): Promise<string> {
-  // Use platform-appropriate random bytes
-  if (typeof window !== 'undefined' && window.crypto) {
-    // Web platform
-    const array = new Uint8Array(size);
-    window.crypto.getRandomValues(array);
-    return Array.from(array, byte => byte.toString(16).padStart(2, '0')).join('');
-  }
-
-  if (typeof process !== 'undefined' && process.versions?.node) {
-    // Node.js platform
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval
-    const getCrypto = new Function('return require("crypto")');
-    const crypto = getCrypto();
-    return crypto.randomBytes(size).toString('hex');
-  }
-
-  // React Native - will be handled by platform adapter
-  // For now, throw an error if we can't determine platform
-  throw new Error('Unable to generate session token: no crypto implementation available');
-}
-
-/**
- * Generate a session token synchronously (Node.js only)
- */
-export function generateSessionTokenSync(size: number = 32): string {
-  if (typeof process === 'undefined' || !process.versions?.node) {
-    throw new Error('generateSessionTokenSync can only be used in Node.js');
-  }
-
-  // eslint-disable-next-line @typescript-eslint/no-implied-eval
-  const getCrypto = new Function('return require("crypto")');
-  const crypto = getCrypto();
-  return crypto.randomBytes(size).toString('hex');
-}
-
-/**
- * Convert bytes to hex string
- */
-export function bytesToHex(bytes: Uint8Array): string {
-  return Array.from(bytes, byte => byte.toString(16).padStart(2, '0')).join('');
-}
-
-/**
- * Convert hex string to bytes
- */
-export function hexToBytes(hex: string): Uint8Array {
-  const bytes = new Uint8Array(hex.length / 2);
-  for (let i = 0; i < hex.length; i += 2) {
-    bytes[i / 2] = parseInt(hex.substr(i, 2), 16);
-  }
-  return bytes;
-}
-