statewire 0.9.2 → 0.11.0

package/src/host/http.ts

@@ -0,0 +1,280 @@
+import type { StatewireHost } from "../host";
+import {
+  CLIENT_ID_RE,
+  admitFrame,
+  closeConn,
+  flush,
+  parseFrame,
+  parseFrameValue,
+  register,
+  sendTo,
+} from "./socket";
+import type { ParsedFrame, Registration, SocketHostState } from "./socket";
+
+const CLIENT_ID_HEADER = "Statewire-Client-Id";
+const LEASE_HEADER = "Statewire-Lease";
+const VERSION_HEADER = "Statewire-Version";
+const VERSION = "1";
+const encoder = new TextEncoder();
+
+const invalidClientIdReason = (clientId: string): string | null => {
+  if (clientId === "") return "id must be non-empty";
+  if (clientId.length > 256) return "id must be at most 256 characters";
+  if (!CLIENT_ID_RE.test(clientId)) {
+    return "id must contain only [A-Za-z0-9._~-]";
+  }
+  return null;
+};
+
+const clientIdResponse = (
+  request: Request,
+): { clientId: string } | { response: Response } => {
+  const clientId = request.headers.get(CLIENT_ID_HEADER);
+  if (clientId === null) {
+    return {
+      response: Response.json(
+        { detail: `missing ${CLIENT_ID_HEADER} header` },
+        { status: 400 },
+      ),
+    };
+  }
+  const reason = invalidClientIdReason(clientId);
+  if (reason !== null) {
+    return {
+      response: Response.json(
+        { detail: `invalid ${CLIENT_ID_HEADER}: ${reason}` },
+        { status: 400 },
+      ),
+    };
+  }
+  return { clientId };
+};
+
+const headersOf = (request: Request): Record<string, string> =>
+  Object.fromEntries(request.headers);
+
+const mergedHeaders = (
+  request: Request,
+  extra: Record<string, string>,
+): Record<string, string> => {
+  const headers = headersOf(request);
+  for (const [name, value] of Object.entries(extra)) {
+    headers[name.toLowerCase()] = value;
+  }
+  return headers;
+};
+
+const authorize = async (
+  h: SocketHostState,
+  headers: Record<string, string>,
+): Promise<Response | null> => {
+  try {
+    await h.authorize?.({ headers });
+    return null;
+  } catch (error) {
+    if (error instanceof Response) return error;
+    throw error;
+  }
+};
+
+const mintLease = (): string => {
+  const bytes = crypto.getRandomValues(new Uint8Array(16));
+  return btoa(String.fromCharCode(...bytes))
+    .replaceAll("+", "-")
+    .replaceAll("/", "_")
+    .replace(/=+$/, "");
+};
+
+type SseAttachment = {
+  body: ReadableStream<Uint8Array>;
+  registration: Registration | null;
+};
+
+const attachSse = (h: SocketHostState, clientId: string): SseAttachment => {
+  let controller: ReadableStreamDefaultController<Uint8Array>;
+  let connection: Registration["connection"] | null = null;
+  let open = true;
+  const body = new ReadableStream({
+    start: (next) => {
+      controller = next;
+    },
+    cancel: () => {
+      open = false;
+      connection?.close();
+    },
+  });
+  const socket = {
+    send: (data: string) => {
+      if (!open) return;
+      const frame = data === "{}" ? ": ping\n\n" : `data: ${data}\n\n`;
+      try {
+        controller.enqueue(encoder.encode(frame));
+      } catch {
+        open = false;
+        connection?.close();
+      }
+    },
+    close: () => {
+      if (!open) return;
+      open = false;
+      try {
+        controller.close();
+      } catch {
+        return;
+      }
+    },
+  };
+  const registration = register(h, clientId, socket);
+  connection = registration?.connection ?? null;
+  if (!open) connection?.close();
+  return { body, registration };
+};
+
+const streamResponse = (
+  attachment: SseAttachment,
+  lease: string | null,
+): Response =>
+  new Response(attachment.body, {
+    status: 200,
+    headers: {
+      "Content-Type": "text/event-stream",
+      [VERSION_HEADER]: VERSION,
+      ...(lease !== null && { [LEASE_HEADER]: lease }),
+    },
+  });
+
+const admitAttachFrame = (
+  h: SocketHostState,
+  registration: Registration,
+  frame: ParsedFrame,
+) => {
+  if (frame.ctx.length === 0 && frame.cmd.length === 0) return;
+  const admission = admitFrame(h, registration.rec, frame);
+  if (admission.type === "refused") {
+    sendTo(h, registration.conn, JSON.stringify(admission.syn));
+  }
+};
+
+const getStream = async (
+  h: SocketHostState,
+  request: Request,
+): Promise<Response> => {
+  const refused = await authorize(h, headersOf(request));
+  if (refused !== null) return refused;
+  const client = clientIdResponse(request);
+  if ("response" in client) return client.response;
+  const attachment = attachSse(h, client.clientId);
+  const lease = attachment.registration === null ? null : mintLease();
+  if (attachment.registration !== null)
+    attachment.registration.rec.lease = lease;
+  return streamResponse(attachment, lease);
+};
+
+const postStream = async (
+  h: SocketHostState,
+  request: Request,
+): Promise<Response> => {
+  const client = clientIdResponse(request);
+  if ("response" in client) return client.response;
+  let body: unknown;
+  try {
+    body = JSON.parse(await request.text());
+  } catch {
+    return Response.json({ detail: "body must be JSON" }, { status: 400 });
+  }
+  let frame: ParsedFrame;
+  try {
+    frame = parseFrameValue(body, true);
+  } catch (error) {
+    if (!(error instanceof Error) || error.name !== "StatewireViolation") {
+      throw error;
+    }
+    return Response.json({ detail: error.message }, { status: 400 });
+  }
+  if (frame.headers === null) {
+    return Response.json(
+      { detail: "first frame must carry headers" },
+      { status: 400 },
+    );
+  }
+  const refused = await authorize(h, mergedHeaders(request, frame.headers));
+  if (refused !== null) return refused;
+  const attachment = attachSse(h, client.clientId);
+  if (attachment.registration === null) return streamResponse(attachment, null);
+  const lease = mintLease();
+  attachment.registration.rec.lease = lease;
+  admitAttachFrame(h, attachment.registration, frame);
+  return streamResponse(attachment, lease);
+};
+
+export const stream = async (
+  h: SocketHostState,
+  request: Request,
+): Promise<Response> => {
+  if (request.method === "GET") return getStream(h, request);
+  if (request.method === "POST") return postStream(h, request);
+  return new Response(null, {
+    status: 405,
+    headers: { Allow: "GET, POST" },
+  });
+};
+
+const finClient = (
+  h: SocketHostState,
+  clientId: string,
+  fin: StatewireHost.Fin,
+) => {
+  flush(h);
+  for (const conn of [...h.conns]) {
+    if (conn.clientId !== clientId) continue;
+    sendTo(h, conn, JSON.stringify({ fin }));
+    closeConn(h, conn);
+  }
+};
+
+const violationResponse = (
+  h: SocketHostState,
+  clientId: string,
+  reason: string,
+) => {
+  finClient(h, clientId, {
+    reason: "error",
+    message: `protocol violation: ${reason}`,
+  });
+  return Response.json({ error: reason }, { status: 400 });
+};
+
+export const frames = async (
+  h: SocketHostState,
+  request: Request,
+): Promise<Response> => {
+  const refused = await authorize(h, headersOf(request));
+  if (refused !== null) return refused;
+  const client = clientIdResponse(request);
+  if ("response" in client) return client.response;
+  const rec = h.clients.get(client.clientId);
+  const lease = request.headers.get(LEASE_HEADER);
+  if (
+    h.disposed ||
+    h.finished !== null ||
+    rec === undefined ||
+    lease === null ||
+    lease !== rec.lease
+  ) {
+    return Response.json({ error: "stale-lease" }, { status: 423 });
+  }
+  let frame: ParsedFrame;
+  try {
+    frame = parseFrame(await request.text(), false);
+  } catch (error) {
+    if (!(error instanceof Error) || error.name !== "StatewireViolation") {
+      throw error;
+    }
+    return violationResponse(h, client.clientId, error.message);
+  }
+  const admission = admitFrame(h, rec, frame);
+  if (admission.type === "refused") {
+    return Response.json(admission.syn, { status: 409 });
+  }
+  return Response.json({});
+};