vg-x07df 0.1.0

package/packages/sdk/src/core/socketio/socket.manager.ts

@@ -0,0 +1,187 @@
+import { type Socket, io } from "socket.io-client";
+import { createLogger } from "../../utils/logger";
+import type { AuthManager } from "../auth.manager";
+import type { AutoJoinConfig, Nullable } from "../types";
+import { SocketHandlerRegistry } from "./handlers";
+import type { SocketHandlerOptions } from "./handlers/base.handler";
+import type { ConnectionConfig, ConnectionState } from "./types";
+
+export class SocketManager {
+  private static instance: Nullable<SocketManager> = null;
+  private logger = createLogger("socket");
+
+  private socket: Nullable<Socket> = null;
+  private connectionState: ConnectionState = "DISCONNECTED";
+  private livekit: any = null;
+  private autoJoinConfig: Nullable<AutoJoinConfig> = null;
+  private handlerRegistry: Nullable<SocketHandlerRegistry> = null;
+  private authManager: Nullable<AuthManager> = null;
+
+  private constructor() {}
+
+  static getInstance(): SocketManager {
+    if (!SocketManager.instance) {
+      SocketManager.instance = new SocketManager();
+    }
+    return SocketManager.instance;
+  }
+
+  async initialize(
+    baseUrl: string,
+    authManager: AuthManager,
+    config: ConnectionConfig = {},
+    livekit?: any,
+    autoJoinConfig?: AutoJoinConfig
+  ): Promise<void> {
+    this.livekit = livekit;
+    this.autoJoinConfig = autoJoinConfig || null;
+    this.authManager = authManager;
+    if (this.socket?.connected) {
+      return;
+    }
+
+    this.updateConnectionState("CONNECTING");
+    const token = authManager.getCurrentToken();
+    if (!token) {
+      throw new Error("No authentication token available");
+    }
+
+    try {
+      this.socket = io(baseUrl, {
+        auth: { token },
+        autoConnect: false,
+        reconnection: true,
+        reconnectionAttempts: config.reconnectAttempts ?? 5,
+        reconnectionDelay: config.reconnectDelay ?? 1000,
+        reconnectionDelayMax: config.reconnectDelayMax ?? 30000,
+        timeout: config.timeout ?? 10000,
+        forceNew: true,
+        path: "/signal/socket.io",
+        transports: ["websocket"],
+        withCredentials: false,
+      });
+
+      this.setupConnectionHandlers(authManager);
+      this.setupEventHandlers();
+      this.socket.connect();
+    } catch (error) {
+      this.updateConnectionState("ERROR");
+      throw error;
+    }
+  }
+
+  private setupConnectionHandlers(authManager: AuthManager): void {
+    if (!this.socket) return;
+
+    this.socket.on("connect", () => {
+      this.updateConnectionState("CONNECTED");
+      this.logger.info("Connected to server");
+    });
+
+    this.socket.on("disconnect", (reason: string) => {
+      this.updateConnectionState("DISCONNECTED");
+      this.logger.info("Disconnected", { reason });
+    });
+
+    this.socket.on("connect_error", (error: Error) => {
+      this.updateConnectionState("ERROR");
+      this.logger.error("Connection error", { error: error.message });
+    });
+
+    this.socket.io.on("reconnect_attempt", () => {
+      this.updateConnectionState("RECONNECTING");
+      const freshToken = authManager.getCurrentToken();
+      if (freshToken && this.socket) {
+        this.logger.debug("Refreshing auth token for reconnection");
+        this.socket.auth = { token: freshToken };
+      }
+    });
+
+    this.socket.io.on("reconnect", (attemptNumber: number) => {
+      this.logger.info("Reconnected successfully", { attemptNumber });
+    });
+
+    this.socket.io.on("reconnect_error", (error: Error) => {
+      this.logger.error("Reconnection error", { error: error.message });
+      if (this.isAuthError(error)) {
+        this.updateConnectionState("FAILED");
+      }
+    });
+
+    this.socket.io.on("reconnect_failed", () => {
+      this.updateConnectionState("FAILED");
+      this.logger.error("All reconnection attempts failed");
+    });
+  }
+
+  private setupEventHandlers(): void {
+    if (!this.socket) {
+      return;
+    }
+
+    this.logger.debug("Setting up event handlers via registry");
+
+    console.log("[SOCKET_MANAGER] Setting up event handlers", {
+      socketId: this.socket.id,
+      connected: this.socket.connected,
+    });
+
+    // Clean up existing handlers to prevent duplicate registrations
+    if (this.handlerRegistry) {
+      this.handlerRegistry.removeEventListeners(this.socket);
+      this.handlerRegistry.destroy();
+    }
+
+    const options: SocketHandlerOptions = {
+      livekit: this.livekit,
+      autoJoinConfig: this.autoJoinConfig,
+    };
+    
+    if (this.authManager) {
+      options.authManager = this.authManager;
+    }
+
+    this.handlerRegistry = new SocketHandlerRegistry(options);
+
+    this.handlerRegistry.registerEventListeners(this.socket);
+    
+    console.log("[SOCKET_MANAGER] Event handlers registered successfully");
+  }
+
+  private isAuthError(error: Error): boolean {
+    const authErrorIndicators = [
+      "unauthorized",
+      "authentication",
+      "token",
+      "401",
+      "403",
+    ];
+    const errorMessage = error.message.toLowerCase();
+    return authErrorIndicators.some((indicator) =>
+      errorMessage.includes(indicator)
+    );
+  }
+
+  private updateConnectionState(newState: ConnectionState): void {
+    if (this.connectionState !== newState) {
+      this.connectionState = newState;
+      this.logger.debug("Connection state changed", { newState });
+    }
+  }
+
+  destroy(): void {
+    if (this.socket) {
+      if (this.handlerRegistry) {
+        this.handlerRegistry.removeEventListeners(this.socket);
+        this.handlerRegistry.destroy();
+        this.handlerRegistry = null;
+      }
+      this.socket.removeAllListeners();
+      this.socket.disconnect();
+      this.socket = null;
+    }
+    this.connectionState = "DISCONNECTED";
+    SocketManager.instance = null;
+    this.logger.debug("Destroyed and cleaned up");
+  }
+}

package/packages/sdk/src/core/socketio/types.ts

@@ -0,0 +1,14 @@
+export interface ConnectionConfig {
+  reconnectAttempts?: number;
+  reconnectDelay?: number;
+  reconnectDelayMax?: number;
+  timeout?: number;
+}
+
+export type ConnectionState =
+  | "DISCONNECTED"
+  | "CONNECTING"
+  | "CONNECTED"
+  | "RECONNECTING"
+  | "ERROR"
+  | "FAILED";

package/packages/sdk/src/core/types.ts

@@ -0,0 +1,23 @@
+export type AuthProvider = () => string | null;
+
+export interface TokenInfo {
+  token: string;
+  isExpired: boolean;
+  expiresAt?: number | undefined;
+}
+
+export interface JWTPayload {
+  exp?: number;
+  iat?: number;
+  sub?: string;
+  [key: string]: any;
+}
+
+export type Nullable<T> = T | null;
+
+// Auto-join configuration types
+export interface AutoJoinConfig {
+  enabled: boolean;
+  retryOnFailure: boolean;
+  maxRetries: number;
+}

package/packages/sdk/src/generated/api/core/ApiError.ts

@@ -0,0 +1,21 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+import type { ApiResult } from './ApiResult';
+
+export class ApiError extends Error {
+	public readonly url: string;
+	public readonly status: number;
+	public readonly statusText: string;
+	public readonly body: unknown;
+	public readonly request: ApiRequestOptions;
+
+	constructor(request: ApiRequestOptions, response: ApiResult, message: string) {
+		super(message);
+
+		this.name = 'ApiError';
+		this.url = response.url;
+		this.status = response.status;
+		this.statusText = response.statusText;
+		this.body = response.body;
+		this.request = request;
+	}
+}

package/packages/sdk/src/generated/api/core/ApiRequestOptions.ts

@@ -0,0 +1,13 @@
+export type ApiRequestOptions = {
+	readonly method: 'GET' | 'PUT' | 'POST' | 'DELETE' | 'OPTIONS' | 'HEAD' | 'PATCH';
+	readonly url: string;
+	readonly path?: Record<string, unknown>;
+	readonly cookies?: Record<string, unknown>;
+	readonly headers?: Record<string, unknown>;
+	readonly query?: Record<string, unknown>;
+	readonly formData?: Record<string, unknown>;
+	readonly body?: any;
+	readonly mediaType?: string;
+	readonly responseHeader?: string;
+	readonly errors?: Record<number, string>;
+};

package/packages/sdk/src/generated/api/core/ApiResult.ts

@@ -0,0 +1,7 @@
+export type ApiResult<TData = any> = {
+	readonly body: TData;
+	readonly ok: boolean;
+	readonly status: number;
+	readonly statusText: string;
+	readonly url: string;
+};

package/packages/sdk/src/generated/api/core/CancelablePromise.ts

@@ -0,0 +1,126 @@
+export class CancelError extends Error {
+	constructor(message: string) {
+		super(message);
+		this.name = 'CancelError';
+	}
+
+	public get isCancelled(): boolean {
+		return true;
+	}
+}
+
+export interface OnCancel {
+	readonly isResolved: boolean;
+	readonly isRejected: boolean;
+	readonly isCancelled: boolean;
+
+	(cancelHandler: () => void): void;
+}
+
+export class CancelablePromise<T> implements Promise<T> {
+	private _isResolved: boolean;
+	private _isRejected: boolean;
+	private _isCancelled: boolean;
+	readonly cancelHandlers: (() => void)[];
+	readonly promise: Promise<T>;
+	private _resolve?: (value: T | PromiseLike<T>) => void;
+	private _reject?: (reason?: unknown) => void;
+
+	constructor(
+		executor: (
+			resolve: (value: T | PromiseLike<T>) => void,
+			reject: (reason?: unknown) => void,
+			onCancel: OnCancel
+		) => void
+	) {
+		this._isResolved = false;
+		this._isRejected = false;
+		this._isCancelled = false;
+		this.cancelHandlers = [];
+		this.promise = new Promise<T>((resolve, reject) => {
+			this._resolve = resolve;
+			this._reject = reject;
+
+			const onResolve = (value: T | PromiseLike<T>): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
+					return;
+				}
+				this._isResolved = true;
+				if (this._resolve) this._resolve(value);
+			};
+
+			const onReject = (reason?: unknown): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
+					return;
+				}
+				this._isRejected = true;
+				if (this._reject) this._reject(reason);
+			};
+
+			const onCancel = (cancelHandler: () => void): void => {
+				if (this._isResolved || this._isRejected || this._isCancelled) {
+					return;
+				}
+				this.cancelHandlers.push(cancelHandler);
+			};
+
+			Object.defineProperty(onCancel, 'isResolved', {
+				get: (): boolean => this._isResolved,
+			});
+
+			Object.defineProperty(onCancel, 'isRejected', {
+				get: (): boolean => this._isRejected,
+			});
+
+			Object.defineProperty(onCancel, 'isCancelled', {
+				get: (): boolean => this._isCancelled,
+			});
+
+			return executor(onResolve, onReject, onCancel as OnCancel);
+		});
+	}
+
+	get [Symbol.toStringTag]() {
+		return "Cancellable Promise";
+	}
+
+	public then<TResult1 = T, TResult2 = never>(
+		onFulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+		onRejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | null
+	): Promise<TResult1 | TResult2> {
+		return this.promise.then(onFulfilled, onRejected);
+	}
+
+	public catch<TResult = never>(
+		onRejected?: ((reason: unknown) => TResult | PromiseLike<TResult>) | null
+	): Promise<T | TResult> {
+		return this.promise.catch(onRejected);
+	}
+
+	public finally(onFinally?: (() => void) | null): Promise<T> {
+		return this.promise.finally(onFinally);
+	}
+
+	public cancel(): void {
+		if (this._isResolved || this._isRejected || this._isCancelled) {
+			return;
+		}
+		this._isCancelled = true;
+		if (this.cancelHandlers.length) {
+			try {
+				for (const cancelHandler of this.cancelHandlers) {
+					cancelHandler();
+				}
+			} catch (error) {
+				// Silently ignore cancellation errors
+				return;
+			}
+		}
+		this.cancelHandlers.length = 0;
+		if (this._reject) this._reject(new CancelError('Request aborted'));
+	}
+
+	public get isCancelled(): boolean {
+		return this._isCancelled;
+	}
+}

package/packages/sdk/src/generated/api/core/OpenAPI.ts

@@ -0,0 +1,55 @@
+import type { ApiRequestOptions } from './ApiRequestOptions';
+
+type Headers = Record<string, string>;
+type Middleware<T> = (value: T) => T | Promise<T>;
+type Resolver<T> = (options: ApiRequestOptions) => Promise<T>;
+
+export class Interceptors<T> {
+  _fns: Middleware<T>[];
+
+  constructor() {
+    this._fns = [];
+  }
+
+  eject(fn: Middleware<T>) {
+    const index = this._fns.indexOf(fn);
+    if (index !== -1) {
+      this._fns = [
+        ...this._fns.slice(0, index),
+        ...this._fns.slice(index + 1),
+      ];
+    }
+  }
+
+  use(fn: Middleware<T>) {
+    this._fns = [...this._fns, fn];
+  }
+}
+
+export type OpenAPIConfig = {
+	BASE: string;
+	CREDENTIALS: 'include' | 'omit' | 'same-origin';
+	ENCODE_PATH?: ((path: string) => string) | undefined;
+	HEADERS?: Headers | Resolver<Headers> | undefined;
+	PASSWORD?: string | Resolver<string> | undefined;
+	TOKEN?: string | Resolver<string> | undefined;
+	USERNAME?: string | Resolver<string> | undefined;
+	VERSION: string;
+	WITH_CREDENTIALS: boolean;
+	interceptors: {request: Interceptors<RequestInit>;
+		response: Interceptors<Response>;};
+};
+
+export const OpenAPI: OpenAPIConfig = {
+	BASE: '',
+	CREDENTIALS: 'include',
+	ENCODE_PATH: undefined,
+	HEADERS: undefined,
+	PASSWORD: undefined,
+	TOKEN: undefined,
+	USERNAME: undefined,
+	VERSION: '0.0.1',
+	WITH_CREDENTIALS: false,
+	interceptors: {request: new Interceptors(),response: new Interceptors(),
+	},
+};