nitro-graphql 1.6.1 → 1.7.0-beta.0

package/dist/subscribe/index.mjs

@@ -0,0 +1,830 @@
+//#region src/subscribe/index.ts
+const DEFAULT_CONNECTION_TIMEOUT_MS = 1e4;
+const DEFAULT_MAX_RETRIES = 5;
+const MAX_BACKOFF_MS = 3e4;
+const DEFAULT_PING_INTERVAL_MS = 25e3;
+const DEFAULT_PONG_TIMEOUT_MS = 5e3;
+function generateSubscriptionId() {
+	return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
+}
+function calculateBackoffDelay(retryCount) {
+	const baseDelay = 1e3 * 2 ** retryCount;
+	return Math.min(baseDelay, MAX_BACKOFF_MS) + Math.random() * 1e3;
+}
+function extractErrorMessage(errors, fallback) {
+	return errors?.[0]?.message || fallback;
+}
+function extractDataValue(data) {
+	if (!data) return;
+	return Object.values(data)[0];
+}
+function isWebSocketAvailable() {
+	return typeof globalThis.WebSocket !== "undefined";
+}
+function toWebSocketUrl(httpUrl) {
+	if (httpUrl.startsWith("/")) return `${typeof window !== "undefined" && window.location.protocol === "https:" ? "wss:" : "ws:"}//${typeof window !== "undefined" ? window.location.host : "localhost"}${httpUrl}`;
+	return httpUrl.replace(/^http/, "ws");
+}
+function parseMessage(data) {
+	try {
+		return JSON.parse(data);
+	} catch {
+		return null;
+	}
+}
+function createTimerManager() {
+	const manager = {
+		reconnectTimeout: null,
+		connectionTimeout: null,
+		pingInterval: null,
+		pongTimeout: null,
+		clearReconnect() {
+			if (manager.reconnectTimeout) {
+				clearTimeout(manager.reconnectTimeout);
+				manager.reconnectTimeout = null;
+			}
+		},
+		clearConnection() {
+			if (manager.connectionTimeout) {
+				clearTimeout(manager.connectionTimeout);
+				manager.connectionTimeout = null;
+			}
+		},
+		clearPing() {
+			if (manager.pingInterval) {
+				clearInterval(manager.pingInterval);
+				manager.pingInterval = null;
+			}
+		},
+		clearPong() {
+			if (manager.pongTimeout) {
+				clearTimeout(manager.pongTimeout);
+				manager.pongTimeout = null;
+			}
+		},
+		clearAll() {
+			manager.clearReconnect();
+			manager.clearConnection();
+			manager.clearPing();
+			manager.clearPong();
+		}
+	};
+	return manager;
+}
+function createKeepAliveHandler(config, timers) {
+	function start() {
+		stop();
+		timers.pingInterval = setInterval(() => {
+			if (!config.isActive()) return;
+			config.sendMessage({ type: "ping" });
+			timers.pongTimeout = setTimeout(() => {
+				config.onPongTimeout();
+			}, DEFAULT_PONG_TIMEOUT_MS);
+		}, DEFAULT_PING_INTERVAL_MS);
+	}
+	function stop() {
+		timers.clearPing();
+		timers.clearPong();
+	}
+	function handlePong() {
+		timers.clearPong();
+	}
+	return {
+		start,
+		stop,
+		handlePong
+	};
+}
+function createDedicatedSubscription(endpoint, options) {
+	let ws = null;
+	let isConnected = false;
+	let connectionState = "idle";
+	let retryCount = 0;
+	let subscriptionId = null;
+	let intentionalClose = false;
+	let hasConnectedBefore = false;
+	let messageIdCounter = 0;
+	const maxRetries = options.maxRetries ?? DEFAULT_MAX_RETRIES;
+	const connectionTimeoutMs = options.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+	const id = generateSubscriptionId();
+	const timers = createTimerManager();
+	function setState(state) {
+		connectionState = state;
+		options.onStateChange?.(state);
+	}
+	function sendMessage(message) {
+		if (ws && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(message));
+	}
+	const keepAlive = createKeepAliveHandler({
+		sendMessage,
+		isActive: () => isConnected,
+		onPongTimeout: () => {
+			options.onError?.(/* @__PURE__ */ new Error("Server not responding to ping"));
+			cleanupConnection();
+			scheduleReconnect();
+		}
+	}, timers);
+	function subscribe() {
+		subscriptionId = String(++messageIdCounter);
+		sendMessage({
+			id: subscriptionId,
+			type: "subscribe",
+			payload: {
+				query: options.query,
+				variables: options.variables
+			}
+		});
+	}
+	function cleanupConnection() {
+		keepAlive.stop();
+		if (ws) {
+			if (subscriptionId) sendMessage({
+				id: subscriptionId,
+				type: "complete"
+			});
+			ws.close();
+			ws = null;
+			isConnected = false;
+			subscriptionId = null;
+		}
+	}
+	function scheduleReconnect() {
+		timers.clearReconnect();
+		if (retryCount < maxRetries) {
+			retryCount++;
+			setState("reconnecting");
+			options.onRetrying?.(retryCount, maxRetries);
+			const delay = calculateBackoffDelay(retryCount);
+			timers.reconnectTimeout = setTimeout(connect, delay);
+		} else {
+			setState("error");
+			options.onMaxRetriesReached?.();
+			options.onError?.(/* @__PURE__ */ new Error("Max reconnection attempts reached"));
+		}
+	}
+	function handleMessage(data) {
+		const message = parseMessage(data);
+		if (!message) {
+			options.onError?.(/* @__PURE__ */ new Error("Failed to parse message"));
+			return;
+		}
+		switch (message.type) {
+			case "connection_ack":
+				handleConnectionAck();
+				break;
+			case "connection_error":
+				handleConnectionError(message);
+				break;
+			case "next":
+				handleNext(message);
+				break;
+			case "error":
+				handleSubscriptionError(message);
+				break;
+			case "complete":
+				subscriptionId = null;
+				break;
+			case "ping":
+				sendMessage({ type: "pong" });
+				break;
+			case "pong":
+				keepAlive.handlePong();
+				break;
+		}
+	}
+	function handleConnectionAck() {
+		timers.clearConnection();
+		isConnected = true;
+		retryCount = 0;
+		setState("connected");
+		if (hasConnectedBefore) options.onReconnected?.();
+		else {
+			hasConnectedBefore = true;
+			options.onConnected?.();
+		}
+		keepAlive.start();
+		subscribe();
+	}
+	function handleConnectionError(message) {
+		timers.clearConnection();
+		const payload = message.payload;
+		options.onError?.(new Error(payload?.message || "Connection rejected"));
+		setState("error");
+	}
+	function handleNext(message) {
+		if (message.payload && typeof message.payload === "object") {
+			const payload = message.payload;
+			if (payload.errors) options.onError?.(new Error(extractErrorMessage(payload.errors, "GraphQL Error")));
+			else if (payload.data) {
+				const value = extractDataValue(payload.data);
+				if (value !== void 0) options.onData?.(value);
+			}
+		}
+	}
+	function handleSubscriptionError(message) {
+		if (Array.isArray(message.payload)) {
+			const errors = message.payload;
+			options.onError?.(new Error(extractErrorMessage(errors, "Subscription error")));
+		}
+	}
+	function connect() {
+		if (!isWebSocketAvailable()) {
+			options.onError?.(/* @__PURE__ */ new Error("WebSocket not available"));
+			setState("error");
+			return;
+		}
+		timers.clearReconnect();
+		cleanupConnection();
+		setState("connecting");
+		const wsUrl = toWebSocketUrl(endpoint);
+		ws = new WebSocket(wsUrl, "graphql-transport-ws");
+		ws.onopen = () => {
+			timers.connectionTimeout = setTimeout(() => {
+				options.onError?.(/* @__PURE__ */ new Error("Connection timeout"));
+				setState("error");
+				cleanupConnection();
+				scheduleReconnect();
+			}, connectionTimeoutMs);
+			sendMessage({
+				type: "connection_init",
+				payload: options.connectionParams || {}
+			});
+		};
+		ws.onmessage = (event) => {
+			handleMessage(typeof event.data === "string" ? event.data : String(event.data));
+		};
+		ws.onerror = () => {
+			options.onError?.(/* @__PURE__ */ new Error("WebSocket connection error"));
+		};
+		ws.onclose = () => {
+			isConnected = false;
+			subscriptionId = null;
+			timers.clearConnection();
+			options.onDisconnected?.();
+			if (intentionalClose) {
+				intentionalClose = false;
+				setState("disconnected");
+				return;
+			}
+			scheduleReconnect();
+		};
+	}
+	function disconnect() {
+		intentionalClose = true;
+		timers.clearAll();
+		cleanupConnection();
+		setState("disconnected");
+	}
+	connect();
+	return {
+		unsubscribe: disconnect,
+		get isConnected() {
+			return isConnected;
+		},
+		get state() {
+			return connectionState;
+		},
+		id,
+		transport: "websocket"
+	};
+}
+function createSession(endpoint, connectionParams, maxRetries, connectionTimeoutMs) {
+	let ws = null;
+	let connectionState = "idle";
+	let retryCount = 0;
+	let hasConnectedBefore = false;
+	let intentionalClose = false;
+	const subscriptions = /* @__PURE__ */ new Map();
+	const pendingSubscriptions = [];
+	let messageIdCounter = 0;
+	const stateChangeListeners = /* @__PURE__ */ new Set();
+	const timers = createTimerManager();
+	function notifyStateChange() {
+		for (const listener of stateChangeListeners) listener(connectionState, subscriptions.size);
+	}
+	function setState(state) {
+		connectionState = state;
+		for (const sub of subscriptions.values()) sub.onStateChange?.(state);
+		notifyStateChange();
+	}
+	function generateId() {
+		return String(++messageIdCounter);
+	}
+	function sendMessage(message) {
+		if (ws && ws.readyState === WebSocket.OPEN) ws.send(JSON.stringify(message));
+	}
+	const keepAlive = createKeepAliveHandler({
+		sendMessage,
+		isActive: () => connectionState === "connected",
+		onPongTimeout: () => {
+			notifyAllError(/* @__PURE__ */ new Error("Server not responding to ping"));
+			cleanupConnection();
+			scheduleReconnect();
+		}
+	}, timers);
+	function notifyAllError(error) {
+		for (const sub of subscriptions.values()) sub.onError?.(error);
+	}
+	function cleanupConnection() {
+		keepAlive.stop();
+		if (ws) {
+			ws.close();
+			ws = null;
+		}
+	}
+	function scheduleReconnect() {
+		timers.clearReconnect();
+		if (retryCount < maxRetries) {
+			retryCount++;
+			setState("reconnecting");
+			for (const sub of subscriptions.values()) sub.onRetrying?.(retryCount, maxRetries);
+			const delay = calculateBackoffDelay(retryCount);
+			timers.reconnectTimeout = setTimeout(() => connect(), delay);
+		} else {
+			setState("error");
+			for (const sub of subscriptions.values()) {
+				sub.onMaxRetriesReached?.();
+				sub.onError?.(/* @__PURE__ */ new Error("Max reconnection attempts reached"));
+			}
+		}
+	}
+	function sendSubscribe(sub) {
+		sendMessage({
+			id: sub.id,
+			type: "subscribe",
+			payload: {
+				query: sub.query,
+				variables: sub.variables
+			}
+		});
+	}
+	function subscribeInternal(sub) {
+		subscriptions.set(sub.id, sub);
+		notifyStateChange();
+		if (connectionState === "connected") {
+			sendSubscribe(sub);
+			if (!sub.hasNotifiedConnect) {
+				sub.hasNotifiedConnect = true;
+				sub.onConnected?.();
+			}
+		}
+	}
+	function handleMessage(data) {
+		const message = parseMessage(data);
+		if (!message) {
+			notifyAllError(/* @__PURE__ */ new Error("Failed to parse message"));
+			return;
+		}
+		switch (message.type) {
+			case "connection_ack":
+				handleConnectionAck();
+				break;
+			case "connection_error":
+				handleConnectionError(message);
+				break;
+			case "next":
+				handleNext(message);
+				break;
+			case "error":
+				handleSubscriptionError(message);
+				break;
+			case "complete":
+				handleComplete(message);
+				break;
+			case "ping":
+				sendMessage({ type: "pong" });
+				break;
+			case "pong":
+				keepAlive.handlePong();
+				break;
+		}
+	}
+	function handleConnectionAck() {
+		timers.clearConnection();
+		retryCount = 0;
+		setState("connected");
+		keepAlive.start();
+		const isReconnect = hasConnectedBefore;
+		hasConnectedBefore = true;
+		for (const sub of pendingSubscriptions) subscribeInternal(sub);
+		pendingSubscriptions.length = 0;
+		if (isReconnect) for (const sub of subscriptions.values()) {
+			sub.onReconnected?.();
+			sendSubscribe(sub);
+		}
+		else for (const sub of subscriptions.values()) if (!sub.hasNotifiedConnect) {
+			sub.hasNotifiedConnect = true;
+			sub.onConnected?.();
+		}
+	}
+	function handleConnectionError(message) {
+		timers.clearConnection();
+		const payload = message.payload;
+		notifyAllError(new Error(payload?.message || "Connection rejected"));
+		setState("error");
+	}
+	function handleNext(message) {
+		if (!message.id) return;
+		const sub = subscriptions.get(message.id);
+		if (!sub) return;
+		if (message.payload && typeof message.payload === "object") {
+			const payload = message.payload;
+			if (payload.errors) sub.onError?.(new Error(extractErrorMessage(payload.errors, "GraphQL Error")));
+			else if (payload.data) {
+				const value = extractDataValue(payload.data);
+				if (value !== void 0) sub.onData?.(value);
+			}
+		}
+	}
+	function handleSubscriptionError(message) {
+		if (!message.id) return;
+		const sub = subscriptions.get(message.id);
+		if (sub && Array.isArray(message.payload)) {
+			const errors = message.payload;
+			sub.onError?.(new Error(extractErrorMessage(errors, "Subscription error")));
+		}
+	}
+	function handleComplete(message) {
+		if (message.id) {
+			subscriptions.delete(message.id);
+			notifyStateChange();
+		}
+	}
+	function connect() {
+		if (connectionState === "connected" || connectionState === "connecting") return;
+		if (!isWebSocketAvailable()) {
+			notifyAllError(/* @__PURE__ */ new Error("WebSocket not available"));
+			setState("error");
+			return;
+		}
+		timers.clearReconnect();
+		setState("connecting");
+		const wsUrl = toWebSocketUrl(endpoint);
+		ws = new WebSocket(wsUrl, "graphql-transport-ws");
+		ws.onopen = () => {
+			timers.connectionTimeout = setTimeout(() => {
+				notifyAllError(/* @__PURE__ */ new Error("Connection timeout"));
+				setState("error");
+				cleanupConnection();
+				scheduleReconnect();
+			}, connectionTimeoutMs);
+			sendMessage({
+				type: "connection_init",
+				payload: connectionParams
+			});
+		};
+		ws.onmessage = (event) => {
+			handleMessage(typeof event.data === "string" ? event.data : String(event.data));
+		};
+		ws.onerror = () => {
+			notifyAllError(/* @__PURE__ */ new Error("WebSocket connection error"));
+		};
+		ws.onclose = () => {
+			timers.clearConnection();
+			for (const sub of subscriptions.values()) sub.onDisconnected?.();
+			if (intentionalClose) {
+				intentionalClose = false;
+				setState("disconnected");
+				return;
+			}
+			scheduleReconnect();
+		};
+	}
+	function unsubscribe(id) {
+		if (subscriptions.get(id)) {
+			if (connectionState === "connected") sendMessage({
+				id,
+				type: "complete"
+			});
+			subscriptions.delete(id);
+			notifyStateChange();
+		}
+		const pendingIdx = pendingSubscriptions.findIndex((s) => s.id === id);
+		if (pendingIdx !== -1) pendingSubscriptions.splice(pendingIdx, 1);
+		if (subscriptions.size === 0 && pendingSubscriptions.length === 0) close();
+	}
+	function close() {
+		intentionalClose = true;
+		timers.clearAll();
+		if (connectionState === "connected") for (const sub of subscriptions.values()) sendMessage({
+			id: sub.id,
+			type: "complete"
+		});
+		subscriptions.clear();
+		pendingSubscriptions.length = 0;
+		cleanupConnection();
+		setState("disconnected");
+	}
+	return {
+		subscribe(query, variables, onData, onError) {
+			const id = generateId();
+			const entry = {
+				id,
+				query,
+				variables,
+				onData,
+				onError,
+				hasNotifiedConnect: false
+			};
+			if (connectionState === "connected") subscribeInternal(entry);
+			else {
+				pendingSubscriptions.push(entry);
+				notifyStateChange();
+				connect();
+			}
+			return {
+				unsubscribe: () => unsubscribe(id),
+				get isConnected() {
+					return connectionState === "connected";
+				},
+				get state() {
+					return connectionState;
+				},
+				id,
+				transport: "websocket"
+			};
+		},
+		get state() {
+			return connectionState;
+		},
+		get isConnected() {
+			return connectionState === "connected";
+		},
+		get subscriptionCount() {
+			return subscriptions.size;
+		},
+		close,
+		onStateChange(callback) {
+			stateChangeListeners.add(callback);
+			return () => stateChangeListeners.delete(callback);
+		}
+	};
+}
+/**
+* Resolve transport type from options
+*/
+function resolveTransport(options) {
+	if (options?.sse) return "sse";
+	return options?.transport ?? "websocket";
+}
+function createSubscriptionClient(config = {}) {
+	const wsEndpoint = config.wsEndpoint ?? "/api/graphql/ws";
+	const sseEndpoint = config.sseEndpoint ?? "/api/graphql";
+	const configConnectionParams = config.connectionParams;
+	const connectionTimeoutMs = config.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS;
+	const maxRetries = config.maxRetries ?? DEFAULT_MAX_RETRIES;
+	function getConnectionParams() {
+		if (!configConnectionParams) return {};
+		if (typeof configConnectionParams === "function") {
+			const result = configConnectionParams();
+			if (result instanceof Promise) {
+				console.warn("[nitro-graphql] Async connectionParams not supported in subscribe(), use subscribeAsync()");
+				return {};
+			}
+			return result;
+		}
+		return configConnectionParams;
+	}
+	return {
+		subscribe(query, variables, onData, onError, transportOptions) {
+			const transport = resolveTransport(transportOptions);
+			const subscriptionOptions = {
+				query,
+				variables,
+				onData,
+				onError,
+				connectionParams: getConnectionParams(),
+				connectionTimeoutMs,
+				maxRetries
+			};
+			if (transport === "sse") return createSseDedicatedSubscription(sseEndpoint, subscriptionOptions);
+			if (transport === "auto") return createAutoSubscription(wsEndpoint, sseEndpoint, subscriptionOptions);
+			return createDedicatedSubscription(wsEndpoint, subscriptionOptions);
+		},
+		async subscribeAsync(options, transportOptions) {
+			let connectionParams = options.connectionParams;
+			if (!connectionParams && configConnectionParams) connectionParams = typeof configConnectionParams === "function" ? await configConnectionParams() : configConnectionParams;
+			const transport = resolveTransport(transportOptions);
+			const subscriptionOptions = {
+				...options,
+				connectionParams,
+				connectionTimeoutMs: options.connectionTimeoutMs ?? connectionTimeoutMs,
+				maxRetries: options.maxRetries ?? maxRetries
+			};
+			if (transport === "sse") return createSseDedicatedSubscription(sseEndpoint, subscriptionOptions);
+			if (transport === "auto") return createAutoSubscription(wsEndpoint, sseEndpoint, subscriptionOptions);
+			return createDedicatedSubscription(wsEndpoint, subscriptionOptions);
+		},
+		createSession() {
+			return createSession(wsEndpoint, getConnectionParams(), maxRetries, connectionTimeoutMs);
+		}
+	};
+}
+/**
+* Create an SSE subscription using native EventSource (legacy API)
+* Use this when WebSocket is blocked (corporate firewalls, etc.)
+*
+* @deprecated Use the unified client with { transport: 'sse' } instead
+*
+* @example
+* ```typescript
+* const handle = createSseSubscription('/api/graphql', {
+*   query: 'subscription { countdown(from: 10) }',
+*   onData: (data) => console.log(data),
+* })
+*
+* // Later...
+* handle.close()
+* ```
+*/
+function createSseSubscription(endpoint, options) {
+	const url = new URL(endpoint, typeof window !== "undefined" ? window.location.origin : "http://localhost");
+	url.searchParams.set("query", options.query);
+	if (options.variables) url.searchParams.set("variables", JSON.stringify(options.variables));
+	const es = new EventSource(url.toString());
+	es.onmessage = (event) => {
+		try {
+			const response = JSON.parse(event.data);
+			if (response.errors && response.errors.length > 0) options.onError?.(new Error(response.errors[0]?.message || "SSE Error"));
+			else if (response.data) {
+				const value = Object.values(response.data)[0];
+				options.onData?.(value);
+			}
+		} catch {}
+	};
+	es.onerror = () => {
+		options.onError?.(/* @__PURE__ */ new Error("SSE connection error"));
+		es.close();
+	};
+	return { close: () => es.close() };
+}
+/**
+* Create an SSE subscription with full state management (matching WebSocket API)
+* Uses native EventSource which handles reconnection automatically.
+*/
+function createSseDedicatedSubscription(endpoint, options) {
+	let es = null;
+	let connectionState = "idle";
+	let hasConnectedBefore = false;
+	let intentionalClose = false;
+	const id = generateSubscriptionId();
+	function setState(state) {
+		connectionState = state;
+		options.onStateChange?.(state);
+	}
+	function buildUrl() {
+		const url = new URL(endpoint, typeof window !== "undefined" ? window.location.origin : "http://localhost");
+		url.searchParams.set("query", options.query);
+		if (options.variables) url.searchParams.set("variables", JSON.stringify(options.variables));
+		return url.toString();
+	}
+	function connect() {
+		if (typeof EventSource === "undefined") {
+			options.onError?.(/* @__PURE__ */ new Error("EventSource not available"));
+			setState("error");
+			return;
+		}
+		setState("connecting");
+		es = new EventSource(buildUrl());
+		es.onopen = () => {
+			setState("connected");
+			if (hasConnectedBefore) options.onReconnected?.();
+			else {
+				hasConnectedBefore = true;
+				options.onConnected?.();
+			}
+		};
+		function handleSseData(event) {
+			try {
+				const response = JSON.parse(event.data);
+				if (response.errors && response.errors.length > 0) options.onError?.(new Error(response.errors[0]?.message || "SSE Error"));
+				else if (response.data) {
+					const value = extractDataValue(response.data);
+					if (value !== void 0) options.onData?.(value);
+				}
+			} catch {}
+		}
+		es.addEventListener("next", handleSseData);
+		es.onmessage = handleSseData;
+		es.onerror = () => {
+			if (es?.readyState === EventSource.CONNECTING) {
+				setState("reconnecting");
+				options.onRetrying?.(1, 999);
+			} else if (es?.readyState === EventSource.CLOSED) {
+				if (!intentionalClose) {
+					options.onError?.(/* @__PURE__ */ new Error("SSE connection closed"));
+					setState("error");
+				}
+			}
+		};
+	}
+	function disconnect() {
+		intentionalClose = true;
+		if (es) {
+			es.close();
+			es = null;
+		}
+		options.onDisconnected?.();
+		setState("disconnected");
+	}
+	connect();
+	return {
+		unsubscribe: disconnect,
+		get isConnected() {
+			return connectionState === "connected";
+		},
+		get state() {
+			return connectionState;
+		},
+		id,
+		transport: "sse"
+	};
+}
+/**
+* Create a subscription with auto transport selection
+* Tries WebSocket first, falls back to SSE if WebSocket fails to connect
+*/
+function createAutoSubscription(wsEndpoint, sseEndpoint, options) {
+	let activeHandle = null;
+	let activeTransport = "websocket";
+	let connectionState = "idle";
+	const id = generateSubscriptionId();
+	let hasNotifiedConnect = false;
+	const wrappedOptions = {
+		...options,
+		onStateChange: (state) => {
+			connectionState = state;
+			options.onStateChange?.(state);
+		},
+		onConnected: () => {
+			if (!hasNotifiedConnect) {
+				hasNotifiedConnect = true;
+				options.onConnected?.();
+			}
+		},
+		onReconnected: () => {
+			options.onReconnected?.();
+		}
+	};
+	function tryWebSocket() {
+		if (!isWebSocketAvailable()) {
+			trySSE();
+			return;
+		}
+		activeTransport = "websocket";
+		let wsConnectionTimeout = null;
+		let wsConnected = false;
+		activeHandle = createDedicatedSubscription(wsEndpoint, {
+			...wrappedOptions,
+			onConnected: () => {
+				wsConnected = true;
+				if (wsConnectionTimeout) {
+					clearTimeout(wsConnectionTimeout);
+					wsConnectionTimeout = null;
+				}
+				wrappedOptions.onConnected?.();
+			},
+			onError: (error) => {
+				if (!wsConnected && !hasNotifiedConnect) {
+					activeHandle?.unsubscribe();
+					trySSE();
+				} else options.onError?.(error);
+			},
+			onMaxRetriesReached: () => {
+				if (!wsConnected && !hasNotifiedConnect) {
+					activeHandle?.unsubscribe();
+					trySSE();
+				} else options.onMaxRetriesReached?.();
+			}
+		});
+		wsConnectionTimeout = setTimeout(() => {
+			if (!wsConnected && !hasNotifiedConnect) {
+				activeHandle?.unsubscribe();
+				trySSE();
+			}
+		}, options.connectionTimeoutMs ?? DEFAULT_CONNECTION_TIMEOUT_MS);
+	}
+	function trySSE() {
+		activeTransport = "sse";
+		activeHandle = createSseDedicatedSubscription(sseEndpoint, wrappedOptions);
+	}
+	tryWebSocket();
+	return {
+		unsubscribe: () => {
+			activeHandle?.unsubscribe();
+		},
+		get isConnected() {
+			return activeHandle?.isConnected ?? false;
+		},
+		get state() {
+			return connectionState;
+		},
+		id,
+		get transport() {
+			return activeTransport;
+		}
+	};
+}
+
+//#endregion
+export { createSseSubscription, createSubscriptionClient };