void 0.7.3 → 0.7.5

package/dist/runtime/live-server.mjs

@@ -0,0 +1,417 @@
+import { eventStream } from "./sse.mjs";
+import { __getLiveBindingName } from "./live.mjs";
+//#region src/runtime/live-server.ts
+const GENERATION_KEY = "connection:generation";
+const TOPIC_PRUNE_ALARM_DELAY_MS = 6e4;
+const textEncoder = new TextEncoder();
+function createLiveDurableObject() {
+	class VoidLiveStreamDurableObject {
+		connection = null;
+		publishChain = Promise.resolve();
+		constructor(state, env) {
+			this.state = state;
+			this.env = env;
+		}
+		async fetch(request) {
+			const { pathname } = new URL(request.url);
+			if (request.method !== "POST") return new Response("Method Not Allowed", { status: 405 });
+			if (pathname === "/connect") return this.connect(await request.json());
+			if (pathname === "/control") return this.control(await request.json());
+			if (pathname === "/deliver") return this.deliver(await request.json());
+			if (pathname === "/check") return this.check(await request.json());
+			if (pathname === "/register") return this.register(await request.json());
+			if (pathname === "/unregister") return this.unregister(await request.json());
+			if (pathname === "/publish") return this.enqueuePublish(request);
+			return new Response("Not Found", { status: 404 });
+		}
+		async alarm() {
+			await this.pruneAllSubscribers();
+		}
+		enqueuePublish(request) {
+			const run = this.publishChain.catch(() => {}).then(async () => {
+				return this.publish(await request.json());
+			});
+			this.publishChain = run.then(() => {}, () => {});
+			return run;
+		}
+		async connect(message) {
+			const previous = this.connection;
+			if (previous) {
+				const active = [...previous.subscriptions.values()].filter((sub) => sub.active);
+				for (const subscription of previous.subscriptions.values()) subscription.active = false;
+				await previous.stream.close().catch(() => {});
+				await Promise.all(active.map((sub) => this.unregisterTopic(message.streamId, message.connectionId, sub)));
+			}
+			const generation = (await this.state.storage.get(GENERATION_KEY) ?? 0) + 1;
+			await this.state.storage.put(GENERATION_KEY, generation);
+			return eventStream(async (stream) => {
+				const subscriptions = previous?.owner === message.owner ? previous.subscriptions : /* @__PURE__ */ new Map();
+				for (const subscription of subscriptions.values()) subscription.active = false;
+				this.connection = {
+					stream,
+					owner: message.owner,
+					generation,
+					subscriptions,
+					writeChain: Promise.resolve(),
+					queued: 0,
+					limits: message.limits
+				};
+				await stream.comment("connected");
+				await stream.closed;
+				if (this.connection?.generation === generation) {
+					const active = [...this.connection.subscriptions.values()].filter((sub) => sub.active);
+					this.connection = null;
+					await Promise.all(active.map((sub) => this.unregisterTopic(message.streamId, message.connectionId, sub)));
+				}
+			}, { keepAlive: {
+				intervalMs: 15e3,
+				comment: "keep-alive"
+			} });
+		}
+		async control(message) {
+			const connection = this.connection;
+			if (!connection) return controlBatchError("CONNECTION_NOT_FOUND", "live: connection is not open.", 404);
+			if (connection.owner !== message.owner) return controlBatchError("OWNER_MISMATCH", "live: connection owner mismatch.", 403);
+			const results = [];
+			for (const operation of message.operations) {
+				if (operation.kind === "unsubscribe") {
+					const existing = connection.subscriptions.get(operation.id);
+					if (existing) {
+						existing.active = false;
+						await this.unregisterTopic(message.streamId, message.connectionId, existing);
+						connection.subscriptions.delete(operation.id);
+					}
+					results.push({
+						ok: true,
+						kind: "unsubscribe",
+						id: operation.id
+					});
+					continue;
+				}
+				if (!connection.subscriptions.has(operation.id) && activeSubscriptionCount(connection) >= message.limits.maxSubscriptionsPerConnection) {
+					results.push({
+						ok: false,
+						kind: "subscribe",
+						id: operation.id,
+						error: {
+							code: "SUBSCRIPTION_LIMIT",
+							message: "live: subscription limit reached."
+						}
+					});
+					continue;
+				}
+				const topicKey = await topicDigest(message.streamId, operation.topic);
+				const existing = connection.subscriptions.get(operation.id);
+				const revision = (existing?.revision ?? 0) + 1;
+				const row = {
+					streamId: message.streamId,
+					topic: operation.topic,
+					topicKey,
+					connectionId: message.connectionId,
+					subscriptionId: operation.id,
+					generation: connection.generation,
+					revision,
+					lastSeenAt: Date.now()
+				};
+				const response = await this.topicStub(message.streamId, topicKey).fetch(internalUrl("/register"), {
+					method: "POST",
+					body: JSON.stringify({
+						...row,
+						limits: message.limits
+					})
+				});
+				if (!response.ok) {
+					results.push({
+						ok: false,
+						kind: "subscribe",
+						id: operation.id,
+						error: response.status === 409 ? {
+							code: "TOPIC_FULL",
+							message: "live: topic subscription limit reached."
+						} : {
+							code: "INTERNAL_ERROR",
+							message: await response.text()
+						}
+					});
+					continue;
+				}
+				if (existing) {
+					existing.active = false;
+					await this.unregisterTopic(message.streamId, message.connectionId, existing).catch(() => {});
+				}
+				connection.subscriptions.set(operation.id, {
+					id: operation.id,
+					topic: operation.topic,
+					topicKey,
+					generation: connection.generation,
+					revision,
+					active: true
+				});
+				results.push({
+					ok: true,
+					kind: "subscribe",
+					id: operation.id,
+					topic: operation.topic
+				});
+			}
+			return Response.json({
+				accepted: true,
+				connectionId: message.connectionId,
+				results
+			});
+		}
+		async deliver(message) {
+			const connection = this.connection;
+			if (!connection) return new Response("connection missing", { status: 410 });
+			let delivered = 0;
+			const stale = [];
+			for (const [index, row] of message.subscriptions.entries()) {
+				if (isStaleSubscriber(row, connection)) {
+					stale.push(index);
+					continue;
+				}
+				if (connection.queued >= connection.limits.maxQueuedEventsPerConnection) {
+					await connection.stream.close().catch(() => {});
+					this.connection = null;
+					return new Response("connection queue full", { status: 410 });
+				}
+				const event = {
+					subscriptionId: row.subscriptionId,
+					topic: message.topic,
+					...message.type !== void 0 && { type: message.type },
+					...message.eventId !== void 0 && { eventId: message.eventId },
+					data: message.data
+				};
+				if (encodedLiveEventSize(event) > connection.limits.maxEncodedEventSize) return payloadTooLargeResponse(connection.limits.maxEncodedEventSize);
+				connection.queued++;
+				const activeConnection = connection;
+				connection.writeChain = connection.writeChain.catch(() => {}).then(() => connection.stream.send({
+					event: "message",
+					data: event
+				})).catch(() => {
+					if (this.connection === activeConnection) this.connection = null;
+					connection.stream.close().catch(() => {});
+				}).finally(() => {
+					connection.queued--;
+				});
+				delivered++;
+			}
+			return Response.json({
+				delivered,
+				stale
+			});
+		}
+		check(message) {
+			const connection = this.connection;
+			if (!connection) return new Response("connection missing", { status: 410 });
+			const stale = [];
+			for (const [index, row] of message.subscriptions.entries()) if (isStaleSubscriber(row, connection)) stale.push(index);
+			return Response.json({ stale });
+		}
+		async register(row) {
+			const prefix = subscriberPrefix(row.streamId, row.topicKey);
+			const current = await this.state.storage.list({ prefix });
+			const deletedKeys = /* @__PURE__ */ new Set();
+			for (const [key, value] of current) {
+				if (value.connectionId === row.connectionId && value.generation < row.generation) {
+					deletedKeys.add(key);
+					continue;
+				}
+				if (value.connectionId === row.connectionId && value.subscriptionId === row.subscriptionId) deletedKeys.add(key);
+			}
+			let activeRows = [...current].filter(([key]) => !deletedKeys.has(key));
+			if (activeRows.length >= row.limits.maxSubscriptionsPerTopic) {
+				for (const key of await this.findStaleSubscriberKeys(activeRows, row.limits)) deletedKeys.add(key);
+				activeRows = activeRows.filter(([key]) => !deletedKeys.has(key));
+			}
+			if (activeRows.length >= row.limits.maxSubscriptionsPerTopic) return new Response("topic full", { status: 409 });
+			if (deletedKeys.size > 0) await this.state.storage.delete([...deletedKeys]);
+			await this.state.storage.put(subscriberKey(row), withoutLimits(row));
+			await this.schedulePruneAlarm();
+			return Response.json({ ok: true });
+		}
+		async unregister(row) {
+			if (!row.streamId || !row.topicKey) return Response.json({ ok: true });
+			const key = row.connectionId && row.subscriptionId && row.generation != null && row.revision != null ? subscriberKey(row) : void 0;
+			if (key) await this.state.storage.delete(key);
+			return Response.json({ ok: true });
+		}
+		async publish(message) {
+			const rows = await this.state.storage.list({ prefix: subscriberPrefix(message.streamId, message.topicKey) });
+			const grouped = /* @__PURE__ */ new Map();
+			for (const [key, row] of rows) {
+				const list = grouped.get(row.connectionId) ?? [];
+				list.push({
+					key,
+					row
+				});
+				grouped.set(row.connectionId, list);
+			}
+			for (const { row } of [...grouped.values()].flat()) if (encodedLiveEventSize({
+				subscriptionId: row.subscriptionId,
+				topic: message.topic,
+				...message.type !== void 0 && { type: message.type },
+				...message.eventId !== void 0 && { eventId: message.eventId },
+				data: message.data
+			}) > message.limits.maxEncodedEventSize) return payloadTooLargeResponse(message.limits.maxEncodedEventSize);
+			for (const [connectionId, items] of grouped) {
+				const response = await fetchWithTimeout(this.connectionStub(message.streamId, connectionId), internalUrl("/deliver"), {
+					method: "POST",
+					body: JSON.stringify({
+						streamId: message.streamId,
+						topic: message.topic,
+						data: message.data,
+						type: message.type,
+						eventId: message.eventId,
+						subscriptions: items.map((item) => item.row)
+					})
+				}, message.limits.deliveryAttemptTimeoutMs);
+				if (!response || response.status === 410 || response.status === 404) {
+					await this.state.storage.delete(items.map((item) => item.key));
+					continue;
+				}
+				if (response.status === 413) return response;
+				if (response.ok) {
+					const staleKeys = (await response.json().catch(() => null))?.stale.map((index) => items[index]?.key).filter((key) => typeof key === "string");
+					if (staleKeys?.length) await this.state.storage.delete(staleKeys);
+				}
+			}
+			return Response.json({ ok: true });
+		}
+		async pruneAllSubscribers() {
+			const rows = await this.state.storage.list({ prefix: "sub:" });
+			const staleKeys = await this.findStaleSubscriberKeys([...rows], { deliveryAttemptTimeoutMs: 1500 });
+			if (staleKeys.length > 0) await this.state.storage.delete(staleKeys);
+			if (rows.size > staleKeys.length) await this.schedulePruneAlarm();
+		}
+		async findStaleSubscriberKeys(entries, limits) {
+			const grouped = /* @__PURE__ */ new Map();
+			for (const [key, row] of entries) {
+				const list = grouped.get(row.connectionId) ?? [];
+				list.push({
+					key,
+					row
+				});
+				grouped.set(row.connectionId, list);
+			}
+			const staleKeys = [];
+			for (const [connectionId, items] of grouped) {
+				const response = await fetchWithTimeout(this.connectionStub(items[0].row.streamId, connectionId), internalUrl("/check"), {
+					method: "POST",
+					body: JSON.stringify({ subscriptions: items.map((item) => item.row) })
+				}, limits.deliveryAttemptTimeoutMs);
+				if (!response || response.status === 410 || response.status === 404) {
+					staleKeys.push(...items.map((item) => item.key));
+					continue;
+				}
+				if (response.ok) {
+					const result = await response.json().catch(() => null);
+					for (const index of result?.stale ?? []) {
+						const key = items[index]?.key;
+						if (key) staleKeys.push(key);
+					}
+				}
+			}
+			return staleKeys;
+		}
+		async schedulePruneAlarm() {
+			await this.state.storage.setAlarm?.(Date.now() + TOPIC_PRUNE_ALARM_DELAY_MS);
+		}
+		topicStub(streamId, topicKey) {
+			const binding = this.env[__getLiveBindingName()];
+			return binding.get(binding.idFromName(topicInstanceName(streamId, topicKey)));
+		}
+		connectionStub(streamId, connectionId) {
+			const binding = this.env[__getLiveBindingName()];
+			return binding.get(binding.idFromName(connectionInstanceName(streamId, connectionId)));
+		}
+		unregisterTopic(streamId, connectionId, subscription) {
+			return this.topicStub(streamId, subscription.topicKey).fetch(internalUrl("/unregister"), {
+				method: "POST",
+				body: JSON.stringify({
+					streamId,
+					topic: subscription.topic,
+					topicKey: subscription.topicKey,
+					connectionId,
+					subscriptionId: subscription.id,
+					revision: subscription.revision,
+					generation: subscription.generation
+				})
+			});
+		}
+	}
+	return VoidLiveStreamDurableObject;
+}
+function controlBatchError(code, message, status) {
+	return Response.json({
+		accepted: false,
+		error: {
+			code,
+			message
+		}
+	}, { status });
+}
+function activeSubscriptionCount(connection) {
+	let count = 0;
+	for (const subscription of connection.subscriptions.values()) if (subscription.active) count++;
+	return count;
+}
+function isStaleSubscriber(row, connection) {
+	if (row.generation !== connection.generation) return true;
+	const subscription = connection.subscriptions.get(row.subscriptionId);
+	return !subscription || !subscription.active || subscription.revision !== row.revision;
+}
+function encodedLiveEventSize(event) {
+	return textEncoder.encode(JSON.stringify(event)).byteLength;
+}
+function payloadTooLargeResponse(maxEncodedEventSize) {
+	return Response.json({
+		accepted: false,
+		error: {
+			code: "PAYLOAD_TOO_LARGE",
+			message: `live: encoded event exceeds ${maxEncodedEventSize} bytes.`
+		}
+	}, { status: 413 });
+}
+async function fetchWithTimeout(stub, input, init, timeoutMs) {
+	const fetchPromise = stub.fetch(input, init);
+	fetchPromise.catch(() => {});
+	let timeout;
+	const timeoutPromise = new Promise((resolve) => {
+		timeout = setTimeout(() => resolve(null), Math.max(1, timeoutMs));
+	});
+	try {
+		return await Promise.race([fetchPromise, timeoutPromise]);
+	} catch {
+		return null;
+	} finally {
+		if (timeout) clearTimeout(timeout);
+	}
+}
+function withoutLimits(row) {
+	const { limits: _limits, ...rest } = row;
+	return rest;
+}
+function subscriberPrefix(streamId, topicKey) {
+	return `sub:${streamId}:${topicKey}:`;
+}
+function subscriberKey(row) {
+	return `${subscriberPrefix(row.streamId, row.topicKey)}${row.connectionId}:${row.subscriptionId}:${row.generation}:${row.revision}`;
+}
+async function topicDigest(streamId, topic) {
+	const bytes = new TextEncoder().encode(`${streamId}\u0000${topic}`);
+	const digest = await crypto.subtle.digest("SHA-256", bytes);
+	const binary = String.fromCharCode(...new Uint8Array(digest));
+	return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/, "");
+}
+function connectionInstanceName(streamId, connectionId) {
+	return `live:${streamId}:connection:${connectionId}`;
+}
+function topicInstanceName(streamId, topicKey) {
+	return `live:${streamId}:topic:${topicKey}`;
+}
+function internalUrl(path) {
+	return `https://void.live${path}`;
+}
+//#endregion
+export { createLiveDurableObject };

package/dist/runtime/live.d.mts

@@ -0,0 +1,107 @@
+/// <reference types="@cloudflare/workers-types" />
+import { r as AuthUser } from "../auth-DrfOTMmr.mjs";
+import { i as CloudEnv, n as CloudContext } from "../handler-dKQWyF-G.mjs";
+
+//#region src/runtime/live.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type LiveControlRequest = {
+  connectionId: string;
+  operations: Array<LiveControlOperation>;
+};
+type LiveControlOperation = {
+  kind: "subscribe";
+  id: string;
+  topic: string;
+  lastEventId?: string;
+} | {
+  kind: "unsubscribe";
+  id: string;
+};
+type LiveControlErrorCode = "BAD_REQUEST" | "CONNECTION_CLOSED" | "CONNECTION_NOT_FOUND" | "FORBIDDEN" | "INVALID_SUBSCRIPTION_ID" | "INVALID_TOPIC" | "OWNER_MISMATCH" | "SUBSCRIPTION_LIMIT" | "TOPIC_FULL" | "PAYLOAD_TOO_LARGE" | "INTERNAL_ERROR";
+type LiveControlError = {
+  code: LiveControlErrorCode;
+  message: string;
+};
+type LiveControlOperationResult = {
+  ok: true;
+  kind: "subscribe" | "unsubscribe";
+  id: string;
+  topic?: string;
+} | {
+  ok: false;
+  kind: "subscribe" | "unsubscribe";
+  id: string;
+  error: LiveControlError;
+};
+type LiveControlResponse = {
+  accepted: true;
+  connectionId: string;
+  results: Array<LiveControlOperationResult>;
+} | {
+  accepted: false;
+  error: LiveControlError;
+};
+type LiveClientEvent<Data = unknown> = {
+  subscriptionId: string;
+  topic: string;
+  type?: string;
+  eventId?: string;
+  data: Data;
+};
+type LivePublishOptions = {
+  type?: string;
+  eventId?: string;
+};
+type LiveConnectOptions = {
+  owner?: string | null;
+  user?: unknown;
+};
+type LiveControlOptions = LiveConnectOptions;
+type LiveHookContext = {
+  request: Request;
+  env: CloudEnv["Bindings"];
+  user: AuthUser | unknown | null;
+  owner: string | null;
+};
+type LiveConnectHookContext = LiveHookContext & {
+  connection: {
+    id: string;
+  };
+};
+type LiveSubscribeHookContext = LiveHookContext & {
+  connection: {
+    id: string;
+  };
+  subscription: {
+    id: string;
+  };
+  topic: string;
+  lastEventId?: string;
+};
+type LiveStreamOptions = {
+  id: string;
+  allowAnonymousControl?: boolean;
+  identifyConnection?: (ctx: LiveHookContext) => MaybePromise<string | null | undefined>;
+  onConnect?: (ctx: LiveConnectHookContext) => MaybePromise<Response | void>;
+  onSubscribe?: (ctx: LiveSubscribeHookContext) => MaybePromise<Response | void>;
+  limits?: Partial<LiveLimits>;
+};
+type LiveLimits = {
+  maxSubscriptionsPerConnection: number;
+  maxSubscriptionsPerTopic: number;
+  maxOperationsPerControlRequest: number;
+  maxQueuedEventsPerConnection: number;
+  maxEncodedEventSize: number;
+  deliveryAttemptTimeoutMs: number;
+};
+type LiveStream = {
+  connect(ctx: CloudContext, options?: LiveConnectOptions): Promise<Response>;
+  control(ctx: CloudContext, options?: LiveControlOptions): Promise<Response>;
+  publish(topic: string, data: unknown, options?: LivePublishOptions): Promise<void>;
+  withEnv(env: unknown): Pick<LiveStream, "publish">;
+};
+declare function __setLiveBindingName(name: string): void;
+declare function __getLiveBindingName(): string;
+declare function defineLiveStream(options: LiveStreamOptions): LiveStream;
+//#endregion
+export { LiveClientEvent, LiveConnectHookContext, LiveConnectOptions, LiveControlError, LiveControlErrorCode, LiveControlOperation, LiveControlOperationResult, LiveControlOptions, LiveControlRequest, LiveControlResponse, LiveHookContext, LiveLimits, LivePublishOptions, LiveStream, LiveStreamOptions, LiveSubscribeHookContext, __getLiveBindingName, __setLiveBindingName, defineLiveStream };