void 0.7.2 → 0.7.4

package/dist/runtime/live.mjs

@@ -0,0 +1,409 @@
+import { i as getRawRuntimeEnv } from "../env-raw-DtfQ9E31.mjs";
+import { getUser } from "./auth.mjs";
+//#region src/runtime/live.ts
+let liveBindingName = "VOID_LIVE";
+const registeredStreamIds = /* @__PURE__ */ new Set();
+const DEFAULT_LIMITS = {
+	maxSubscriptionsPerConnection: 256,
+	maxSubscriptionsPerTopic: 256,
+	maxOperationsPerControlRequest: 100,
+	maxQueuedEventsPerConnection: 100,
+	maxEncodedEventSize: 64 * 1024,
+	deliveryAttemptTimeoutMs: 1500
+};
+const MAX_SUBSCRIPTIONS_PER_TOPIC = 256;
+function __setLiveBindingName(name) {
+	liveBindingName = assertBindingName(name);
+}
+function __getLiveBindingName() {
+	return liveBindingName;
+}
+function defineLiveStream(options) {
+	const streamId = assertStreamId(options.id);
+	const limits = resolveLiveLimits(options.limits);
+	if (registeredStreamIds.has(streamId)) throw new Error(`live: duplicate stream id "${streamId}".`);
+	registeredStreamIds.add(streamId);
+	async function resolveOwner(ctx, request, connectOptions) {
+		const resolvedUser = connectOptions && "user" in connectOptions ? connectOptions.user : getContextUser(ctx) ?? getUser();
+		const hookContext = {
+			request,
+			env: ctx.env,
+			user: resolvedUser ?? null,
+			owner: connectOptions?.owner ?? null
+		};
+		const owner = (connectOptions && "owner" in connectOptions ? connectOptions.owner : await options.identifyConnection?.(hookContext)) ?? defaultOwner(resolvedUser);
+		if (owner == null && !options.allowAnonymousControl) throw liveResponseError("FORBIDDEN", "live: anonymous control is not enabled.", 403);
+		assertOwner(owner);
+		return {
+			owner,
+			user: resolvedUser ?? null
+		};
+	}
+	async function publishWithEnv(env, topic, data, publishOptions = {}) {
+		const binding = getLiveBinding(env);
+		assertTopic(topic);
+		assertOptionalString("type", publishOptions.type);
+		assertOptionalString("eventId", publishOptions.eventId);
+		assertJsonSerializable(data);
+		const topicKey = await topicDigest(streamId, topic);
+		const id = binding.idFromName(topicInstanceName(streamId, topicKey));
+		const response = await binding.get(id).fetch(internalUrl("/publish"), {
+			method: "POST",
+			body: JSON.stringify({
+				streamId,
+				topic,
+				topicKey,
+				data,
+				type: publishOptions.type,
+				eventId: publishOptions.eventId,
+				limits
+			})
+		});
+		if (!response.ok) {
+			const body = await response.text();
+			const parsed = parseLiveControlResponse(body);
+			if (parsed && !parsed.accepted) throw new Error(`${parsed.error.code}: ${parsed.error.message}`);
+			throw new Error(body || response.statusText);
+		}
+	}
+	return {
+		async connect(ctx, connectOptions) {
+			try {
+				const request = ctx.req.raw;
+				const connectionId = getConnectionId(request);
+				const { owner, user } = await resolveOwner(ctx, request, connectOptions);
+				const decision = await options.onConnect?.({
+					request,
+					env: ctx.env,
+					user,
+					owner,
+					connection: { id: connectionId }
+				});
+				if (decision instanceof Response) return decision;
+				const binding = getLiveBinding(ctx.env);
+				const id = binding.idFromName(connectionInstanceName(streamId, connectionId));
+				return binding.get(id).fetch(internalUrl("/connect"), {
+					method: "POST",
+					body: JSON.stringify({
+						streamId,
+						connectionId,
+						owner,
+						limits
+					})
+				});
+			} catch (error) {
+				return errorToResponse(error);
+			}
+		},
+		async control(ctx, controlOptions) {
+			try {
+				const request = ctx.req.raw;
+				const body = await readControlRequest(request, limits);
+				const { owner, user } = await resolveOwner(ctx, request, controlOptions);
+				const authorized = [];
+				const results = [];
+				for (const entry of body.operations) {
+					if (!entry.ok) {
+						results[entry.index] = entry.result;
+						continue;
+					}
+					const { operation, index } = entry;
+					if (operation.kind === "unsubscribe") {
+						authorized.push({
+							operation,
+							index
+						});
+						continue;
+					}
+					const decision = await options.onSubscribe?.({
+						request,
+						env: ctx.env,
+						user,
+						owner,
+						connection: { id: body.connectionId },
+						subscription: { id: operation.id },
+						topic: operation.topic,
+						lastEventId: operation.lastEventId
+					});
+					if (decision instanceof Response) {
+						results[index] = {
+							ok: false,
+							kind: "subscribe",
+							id: operation.id,
+							error: await responseToControlError(decision)
+						};
+						continue;
+					}
+					authorized.push({
+						operation,
+						index
+					});
+				}
+				if (authorized.length > 0) {
+					const binding = getLiveBinding(ctx.env);
+					const id = binding.idFromName(connectionInstanceName(streamId, body.connectionId));
+					const response = await binding.get(id).fetch(internalUrl("/control"), {
+						method: "POST",
+						body: JSON.stringify({
+							streamId,
+							connectionId: body.connectionId,
+							owner,
+							operations: authorized.map((entry) => entry.operation),
+							limits
+						})
+					});
+					const controlResponse = await response.json();
+					if (!controlResponse.accepted) return Response.json(controlResponse, { status: response.status });
+					for (const [resultIndex, result] of controlResponse.results.entries()) {
+						const operation = authorized[resultIndex];
+						if (operation) results[operation.index] = result;
+					}
+				}
+				for (const entry of body.operations) {
+					if (!entry.ok) continue;
+					const { operation, index } = entry;
+					results[index] ??= {
+						ok: false,
+						kind: operation.kind,
+						id: operation.id,
+						error: {
+							code: "INTERNAL_ERROR",
+							message: "live: missing control result."
+						}
+					};
+				}
+				return Response.json({
+					accepted: true,
+					connectionId: body.connectionId,
+					results
+				});
+			} catch (error) {
+				return errorToResponse(error);
+			}
+		},
+		publish(topic, data, publishOptions) {
+			let env;
+			try {
+				env = getRawRuntimeEnv();
+			} catch {
+				throw new Error("live: publish() was called outside a Void server runtime context. Pass an explicit env with stream.withEnv(env).publish(...).");
+			}
+			return publishWithEnv(env, topic, data, publishOptions);
+		},
+		withEnv(env) {
+			return { publish(topic, data, publishOptions) {
+				return publishWithEnv(env, topic, data, publishOptions);
+			} };
+		}
+	};
+}
+function defaultOwner(user) {
+	if (user && typeof user === "object" && "id" in user && typeof user.id === "string") return `user:${user.id}`;
+	return null;
+}
+function getContextUser(ctx) {
+	try {
+		return ctx.get("user");
+	} catch {
+		return null;
+	}
+}
+function parseLiveControlResponse(body) {
+	try {
+		const parsed = JSON.parse(body);
+		return typeof parsed === "object" && parsed !== null && "accepted" in parsed ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+async function readControlRequest(request, limits) {
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		throw liveResponseError("BAD_REQUEST", "live: control request body must be JSON.", 400);
+	}
+	if (typeof body !== "object" || body === null || Array.isArray(body)) throw liveResponseError("BAD_REQUEST", "live: control request body must be an object.", 400);
+	const record = body;
+	const connectionId = assertConnectionId(record.connectionId);
+	if (!Array.isArray(record.operations)) throw liveResponseError("BAD_REQUEST", "live: operations must be an array.", 400);
+	if (record.operations.length > limits.maxOperationsPerControlRequest) throw liveResponseError("BAD_REQUEST", "live: too many operations in one control request.", 400);
+	return {
+		connectionId,
+		operations: record.operations.map(parseOperation)
+	};
+}
+function parseOperation(value, index) {
+	if (typeof value !== "object" || value === null || Array.isArray(value)) throw liveResponseError("BAD_REQUEST", "live: operation must be an object.", 400);
+	const record = value;
+	if (record.kind === "subscribe") {
+		const id = parseBoundedString(record.id, 1, 256);
+		if (id == null) return invalidOperation(index, "subscribe", record.id, "INVALID_SUBSCRIPTION_ID");
+		const topic = parseBoundedString(record.topic, 1, 512);
+		if (topic == null) return invalidOperation(index, "subscribe", id, "INVALID_TOPIC");
+		let lastEventId;
+		if (record.lastEventId !== void 0) {
+			lastEventId = parseBoundedString(record.lastEventId, 0, 512) ?? void 0;
+			if (lastEventId === void 0) return invalidOperation(index, "subscribe", id, "BAD_REQUEST");
+		}
+		return {
+			ok: true,
+			index,
+			operation: {
+				kind: "subscribe",
+				id,
+				topic,
+				...lastEventId !== void 0 && { lastEventId }
+			}
+		};
+	}
+	if (record.kind === "unsubscribe") {
+		const id = parseBoundedString(record.id, 1, 256);
+		if (id == null) return invalidOperation(index, "unsubscribe", record.id, "INVALID_SUBSCRIPTION_ID");
+		return {
+			ok: true,
+			index,
+			operation: {
+				kind: "unsubscribe",
+				id
+			}
+		};
+	}
+	throw liveResponseError("BAD_REQUEST", "live: operation kind is invalid.", 400);
+}
+function invalidOperation(index, kind, id, code) {
+	return {
+		ok: false,
+		index,
+		result: {
+			ok: false,
+			kind,
+			id: typeof id === "string" ? id : "",
+			error: {
+				code,
+				message: {
+					BAD_REQUEST: "live: invalid control operation.",
+					CONNECTION_CLOSED: "live: connection closed.",
+					CONNECTION_NOT_FOUND: "live: connection not found.",
+					FORBIDDEN: "Forbidden",
+					INVALID_SUBSCRIPTION_ID: "live: invalid subscription id.",
+					INVALID_TOPIC: "live: invalid topic.",
+					OWNER_MISMATCH: "live: owner mismatch.",
+					SUBSCRIPTION_LIMIT: "live: subscription limit reached.",
+					TOPIC_FULL: "live: topic subscription limit reached.",
+					PAYLOAD_TOO_LARGE: "live: payload too large.",
+					INTERNAL_ERROR: "live: internal error."
+				}[code]
+			}
+		}
+	};
+}
+function getLiveBinding(env) {
+	if (typeof env !== "object" || env === null) throw new Error("live: Cloudflare env is unavailable.");
+	const binding = env[liveBindingName];
+	if (!binding) throw new Error(`live: Missing Durable Object binding "${liveBindingName}".`);
+	return binding;
+}
+function getConnectionId(request) {
+	return assertConnectionId(new URL(request.url).searchParams.get("connectionId"));
+}
+function assertStreamId(value) {
+	return assertBoundedString("stream id", value, 1, 128);
+}
+function assertBindingName(value) {
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) throw new Error(`live: invalid Durable Object binding name "${value}".`);
+	return value;
+}
+function assertConnectionId(value) {
+	return assertBoundedString("connectionId", value, 16, 256);
+}
+function assertTopic(value) {
+	return assertBoundedString("topic", value, 1, 512);
+}
+function assertOwner(value) {
+	if (value !== null) assertBoundedString("owner", value, 1, 512);
+}
+function assertOptionalString(name, value) {
+	if (value !== void 0) assertBoundedString(name, value, 1, 512);
+}
+function resolveLiveLimits(input) {
+	const limits = { ...DEFAULT_LIMITS };
+	for (const key of Object.keys(limits)) {
+		const value = input?.[key];
+		if (value === void 0) continue;
+		if (!Number.isFinite(value) || !Number.isInteger(value) || value <= 0) throw new Error(`live: limits.${key} must be a positive finite integer.`);
+		limits[key] = value;
+	}
+	if (limits.maxSubscriptionsPerTopic > MAX_SUBSCRIPTIONS_PER_TOPIC) throw new Error(`live: limits.maxSubscriptionsPerTopic must be at most ${MAX_SUBSCRIPTIONS_PER_TOPIC}.`);
+	return limits;
+}
+function assertBoundedString(name, value, min, max) {
+	const parsed = parseBoundedString(value, min, max);
+	if (parsed == null) throw liveResponseError("BAD_REQUEST", `live: invalid ${name}.`, 400);
+	return parsed;
+}
+function parseBoundedString(value, min, max) {
+	if (typeof value !== "string" || value.length < min || value.length > max || /[\r\n]/.test(value) || value.includes("\0")) return null;
+	return value;
+}
+function assertJsonSerializable(value) {
+	try {
+		if (typeof JSON.stringify(value) !== "string") throw new Error("unsupported value");
+	} catch (error) {
+		throw new Error(`live: payload must be JSON-serializable. ${error instanceof Error ? error.message : String(error)}`);
+	}
+}
+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}`;
+}
+var LiveResponseError = class extends Error {
+	constructor(code, message, status) {
+		super(message);
+		this.code = code;
+		this.status = status;
+	}
+};
+function liveResponseError(code, message, status) {
+	throw new LiveResponseError(code, message, status);
+}
+function errorToResponse(error) {
+	if (error instanceof LiveResponseError) return Response.json({
+		accepted: false,
+		error: {
+			code: error.code,
+			message: error.message
+		}
+	}, { status: error.status });
+	return Response.json({
+		accepted: false,
+		error: {
+			code: "INTERNAL_ERROR",
+			message: error instanceof Error ? error.message : String(error)
+		}
+	}, { status: 500 });
+}
+async function responseToControlError(response) {
+	const message = await response.text().catch(() => "") || response.statusText;
+	if (response.status === 403 || response.status === 401) return {
+		code: "FORBIDDEN",
+		message: message || "Forbidden"
+	};
+	return {
+		code: "BAD_REQUEST",
+		message: message || "Subscription rejected"
+	};
+}
+//#endregion
+export { __getLiveBindingName, __setLiveBindingName, defineLiveStream };

package/dist/runtime/migration-handler.mjs

@@ -62,7 +62,9 @@ async function runD1Migrations(db, migrations) {
 		}
 		const start = Date.now();
 		try {
-			await db.exec(m.sql);
+			const statements = splitMigrationSql(m.sql);
+			if (statements.length === 1 && statements[0] === m.sql) await db.exec(m.sql);
+			else for (const statement of statements) await db.prepare(statement).run();
 			await db.prepare("INSERT OR IGNORE INTO _void_migrations (name, applied_at) VALUES (?, ?)").bind(m.name, (/* @__PURE__ */ new Date()).toISOString()).run();
 			migrationResults.push({
 				name: m.name,
@@ -88,5 +90,36 @@ async function runD1Migrations(db, migrations) {
 		migrations: migrationResults
 	};
 }
+function splitMigrationSql(sql) {
+	const lines = sql.split(/\r?\n/);
+	if (!lines.some((line) => isStatementBreakpointLine(line) || hasInlineStatementBreakpoint(line))) return [sql];
+	const statements = [];
+	const current = [];
+	for (const line of lines) {
+		if (isStatementBreakpointLine(line)) {
+			const statement = current.join("\n").trim();
+			if (statement) statements.push(statement);
+			current.length = 0;
+			continue;
+		}
+		if (hasInlineStatementBreakpoint(line)) {
+			current.push(line.replace(/-->\s*statement-breakpoint\s*$/, ""));
+			const statement = current.join("\n").trim();
+			if (statement) statements.push(statement);
+			current.length = 0;
+			continue;
+		}
+		current.push(line);
+	}
+	const statement = current.join("\n").trim();
+	if (statement) statements.push(statement);
+	return statements.length > 0 ? statements : [sql];
+}
+function isStatementBreakpointLine(line) {
+	return line.trim() === "--> statement-breakpoint";
+}
+function hasInlineStatementBreakpoint(line) {
+	return /;\s*-->\s*statement-breakpoint\s*$/.test(line.trim());
+}
 //#endregion
 export { createMigrationHandler };

package/dist/runtime/sse-client.d.mts

@@ -0,0 +1,22 @@
+//#region src/runtime/sse-client.d.ts
+type SseClientEvent<T = unknown> = {
+  data: T;
+  event: string;
+  id: string;
+  raw: MessageEvent;
+};
+type SseEventMap = Record<string, unknown>;
+type SseClient<Events extends SseEventMap = SseEventMap> = {
+  on<Name extends Extract<keyof Events, string>>(event: Name, handler: (event: SseClientEvent<Events[Name]>) => void): () => void;
+  on<T = unknown>(event: string, handler: (event: SseClientEvent<T>) => void): () => void;
+  onError(handler: (event: Event) => void): () => void;
+  close(): void;
+};
+type ConnectEventStreamOptions = {
+  withCredentials?: boolean;
+  events?: Array<string>;
+  parse?: "json" | "text" | ((data: string) => unknown);
+};
+declare function connectEventStream<Events extends SseEventMap = SseEventMap>(url: string | URL, options?: ConnectEventStreamOptions): SseClient<Events>;
+//#endregion
+export { ConnectEventStreamOptions, SseClient, SseClientEvent, SseEventMap, connectEventStream };

package/dist/runtime/sse-client.mjs

@@ -0,0 +1,36 @@
+//#region src/runtime/sse-client.ts
+function connectEventStream(url, options = {}) {
+	const EventSourceCtor = globalThis.EventSource;
+	if (!EventSourceCtor) throw new Error("sse: EventSource is not available in this runtime.");
+	const source = new EventSourceCtor(String(url), { withCredentials: options.withCredentials });
+	const parse = getParser(options.parse);
+	return {
+		on(event, handler) {
+			const listener = (raw) => {
+				const message = raw;
+				handler({
+					data: parse(String(message.data)),
+					event,
+					id: message.lastEventId,
+					raw: message
+				});
+			};
+			source.addEventListener(event, listener);
+			return () => source.removeEventListener(event, listener);
+		},
+		onError(handler) {
+			source.addEventListener("error", handler);
+			return () => source.removeEventListener("error", handler);
+		},
+		close() {
+			source.close();
+		}
+	};
+}
+function getParser(parse) {
+	if (typeof parse === "function") return parse;
+	if (parse === "text") return (data) => data;
+	return (data) => JSON.parse(data);
+}
+//#endregion
+export { connectEventStream };

package/dist/runtime/sse.d.mts

@@ -0,0 +1,35 @@
+//#region src/runtime/sse.d.ts
+type SseMessage = {
+  data?: unknown;
+  event?: string;
+  id?: string;
+  retry?: number;
+};
+type SseTextMessage = Omit<SseMessage, "data"> & {
+  data?: string;
+};
+type SseStream = {
+  readonly signal: AbortSignal;
+  readonly closed: Promise<void>;
+  send(message: SseMessage): Promise<void>;
+  comment(text?: string): Promise<void>;
+  close(): Promise<void>;
+};
+type SseKeepAliveOptions = boolean | {
+  intervalMs?: number;
+  comment?: string;
+};
+type EventStreamOptions = {
+  headers?: HeadersInit;
+  keepAlive?: SseKeepAliveOptions;
+  signal?: AbortSignal;
+};
+declare class SseStreamClosedError extends Error {
+  constructor(message?: string);
+}
+declare function formatSse(message: SseMessage): string;
+declare function formatSseText(message: SseTextMessage): string;
+declare function getLastEventId(request: Request): string | null;
+declare function eventStream(start: (stream: SseStream) => void | Promise<void>, options?: EventStreamOptions): Response;
+//#endregion
+export { EventStreamOptions, SseKeepAliveOptions, SseMessage, SseStream, SseStreamClosedError, SseTextMessage, eventStream, formatSse, formatSseText, getLastEventId };