124 lines
3.8 KiB
TypeScript
124 lines
3.8 KiB
TypeScript
import {request as httpRequest} from "node:http"
|
|
import WebSocket from "ws"
|
|
import {parseJson} from "@welshman/lib"
|
|
import type {ClientMessage, RelayMessage} from "@welshman/net"
|
|
import type {RelayConnection} from "./types"
|
|
|
|
/** The only place that knows the container has a loopback address. A relay selection drops a local url. */
|
|
|
|
// Must match the published port in zooid/docker/compose.yaml.
|
|
export const port = 3334
|
|
|
|
const headersFor = (host: string) => ({Host: host, "X-Forwarded-Proto": "https"})
|
|
|
|
export type ZooidConnection = RelayConnection & {
|
|
// Resolves with the first message the relay sends that matches.
|
|
wait(match: (message: RelayMessage) => boolean): Promise<RelayMessage>
|
|
}
|
|
|
|
// Node's own WebSocket cannot carry a Host header, which fetch forbids, so this depends on `ws`.
|
|
export const connectToZooid = (host: string): ZooidConnection => {
|
|
const socket = new WebSocket(`ws://127.0.0.1:${port}/`, {headers: headersFor(host)})
|
|
const listeners = new Set<(message: RelayMessage) => void>()
|
|
const pending: ClientMessage[] = []
|
|
|
|
const write = (message: ClientMessage) => socket.send(JSON.stringify(message))
|
|
|
|
socket.on("open", () => pending.splice(0).forEach(write))
|
|
|
|
socket.on("message", data => {
|
|
const message = parseJson<RelayMessage>(data.toString())
|
|
|
|
if (message) {
|
|
for (const listener of listeners) {
|
|
listener(message)
|
|
}
|
|
}
|
|
})
|
|
|
|
// A 404 from zooid's dispatcher means `tenants` and the tenant toml's `host` have drifted apart.
|
|
socket.on("error", error =>
|
|
console.error(`The zooid container refused a socket for ${host}: ${error.message}`),
|
|
)
|
|
|
|
return {
|
|
onMessage: listener => {
|
|
listeners.add(listener)
|
|
},
|
|
// A client may speak before the container has finished its handshake.
|
|
send: message => {
|
|
if (socket.readyState === WebSocket.OPEN) {
|
|
write(message)
|
|
} else {
|
|
pending.push(message)
|
|
}
|
|
},
|
|
close: () => socket.close(),
|
|
wait: match =>
|
|
new Promise(resolve => {
|
|
const listener = (message: RelayMessage) => {
|
|
if (match(message)) {
|
|
listeners.delete(listener)
|
|
resolve(message)
|
|
}
|
|
}
|
|
|
|
listeners.add(listener)
|
|
}),
|
|
}
|
|
}
|
|
|
|
export type ZooidResponse = {
|
|
status: number
|
|
headers: Record<string, string>
|
|
body: Buffer
|
|
}
|
|
|
|
// Carries the same two headers, so the nip-11 and nip-86 answers the browser reads are the relay's.
|
|
export const requestZooid = (
|
|
host: string,
|
|
method: string,
|
|
path: string,
|
|
requestHeaders: Record<string, string>,
|
|
body?: Buffer,
|
|
): Promise<ZooidResponse> =>
|
|
new Promise((resolve, reject) => {
|
|
const request = httpRequest(
|
|
{
|
|
method,
|
|
path,
|
|
host: "127.0.0.1",
|
|
port,
|
|
headers: {
|
|
// A pseudo-header describes the request line, and node:http rejects a header name with a colon in it.
|
|
...Object.fromEntries(
|
|
Object.entries(requestHeaders).filter(([name]) => !name.startsWith(":")),
|
|
),
|
|
...headersFor(host),
|
|
},
|
|
},
|
|
response => {
|
|
const chunks: Buffer[] = []
|
|
const responseHeaders: Record<string, string> = {}
|
|
|
|
for (const [name, value] of Object.entries(response.headers)) {
|
|
// Hop-by-hop headers describe the connection this answer arrived on, not the browser's.
|
|
if (value && !["connection", "keep-alive", "transfer-encoding"].includes(name)) {
|
|
responseHeaders[name] = Array.isArray(value) ? value.join(", ") : value
|
|
}
|
|
}
|
|
|
|
response.on("data", chunk => chunks.push(chunk))
|
|
response.on("end", () =>
|
|
resolve({
|
|
status: response.statusCode ?? 500,
|
|
headers: responseHeaders,
|
|
body: Buffer.concat(chunks),
|
|
}),
|
|
)
|
|
},
|
|
)
|
|
|
|
request.on("error", reject)
|
|
request.end(body)
|
|
})
|