@mercuryworkshop/scramjet-controller 0.0.1 → 0.0.3

package/src/sw.ts

@@ -0,0 +1,160 @@
+declare var clients: Clients;
+import { RpcHelper } from "@mercuryworkshop/rpc";
+import type { Controllerbound, SWbound } from "./types";
+import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
+import { ScramjetHeaders } from "@mercuryworkshop/scramjet";
+
+function makeId(): string {
+	return Math.random().toString(36).substring(2, 10);
+}
+
+let cookieResolvers: Record<string, (value: void) => void> = {};
+addEventListener("message", (e) => {
+	if (!e.data) return;
+	if (typeof e.data != "object") return;
+	if (e.data.$sw$setCookieDone && typeof e.data.$sw$setCookieDone == "object") {
+		const done = e.data.$sw$setCookieDone;
+
+		const resolver = cookieResolvers[done.id];
+		if (resolver) {
+			resolver();
+			delete cookieResolvers[done.id];
+		}
+	}
+
+	if (
+		e.data.$sw$initRemoteTransport &&
+		typeof e.data.$sw$initRemoteTransport == "object"
+	) {
+		const { port, prefix } = e.data.$sw$initRemoteTransport;
+
+		console.error(prefix, tabs);
+		const relevantcontroller = tabs.find((tab) =>
+			new URL(prefix).pathname.startsWith(tab.prefix)
+		);
+		if (!relevantcontroller) {
+			console.error("No relevant controller found for transport init");
+			return;
+		}
+		relevantcontroller.rpc.call("initRemoteTransport", port, [port]);
+	}
+});
+
+class ControllerReference {
+	rpc: RpcHelper<SWbound, Controllerbound>;
+
+	constructor(
+		public prefix: string,
+		public id: string,
+		port: MessagePort
+	) {
+		this.rpc = new RpcHelper(
+			{
+				sendSetCookie: async ({ url, cookie }) => {
+					let clients = await self.clients.matchAll();
+					let promises = [];
+
+					for (const client of clients) {
+						let id = makeId();
+						client.postMessage({
+							$controller$setCookie: {
+								url,
+								cookie,
+								id,
+							},
+						});
+						promises.push(
+							new Promise<void>((resolve) => {
+								cookieResolvers[id] = resolve;
+							})
+						);
+					}
+					await Promise.race([
+						new Promise<void>((resolve) =>
+							setTimeout(() => {
+								console.error(
+									"timed out waiting for set cookie response (deadlock?)"
+								);
+								resolve();
+							}, 1000)
+						),
+						promises,
+					]);
+				},
+			},
+			"tabchannel-" + id,
+			(data, transfer) => {
+				port.postMessage(data, transfer);
+			}
+		);
+		port.addEventListener("message", (e) => {
+			this.rpc.recieve(e.data);
+		});
+		port.onmessageerror = console.error;
+
+		this.rpc.call("ready", null);
+	}
+}
+
+const tabs: ControllerReference[] = [];
+
+addEventListener("message", (e) => {
+	if (!e.data) return;
+	if (typeof e.data != "object") return;
+	if (!e.data.$controller$init) return;
+	if (typeof e.data.$controller$init != "object") return;
+	const init = e.data.$controller$init;
+
+	tabs.push(new ControllerReference(init.prefix, init.id, e.ports[0]));
+});
+
+export function shouldRoute(event: FetchEvent): boolean {
+	const url = new URL(event.request.url);
+	const tab = tabs.find((tab) => url.pathname.startsWith(tab.prefix));
+	return tab !== undefined;
+}
+
+export async function route(event: FetchEvent): Promise<Response> {
+	try {
+		const url = new URL(event.request.url);
+		const tab = tabs.find((tab) => url.pathname.startsWith(tab.prefix))!;
+		const client = await clients.get(event.clientId);
+
+		const rawheaders: RawHeaders = [...event.request.headers];
+
+		const response = await tab.rpc.call(
+			"request",
+			{
+				rawUrl: event.request.url,
+				destination: event.request.destination,
+				mode: event.request.mode,
+				referrer: event.request.referrer,
+				method: event.request.method,
+				body: event.request.body,
+				cache: event.request.cache,
+				forceCrossOriginIsolated: false,
+				initialHeaders: rawheaders,
+				rawClientUrl: client ? client.url : undefined,
+			},
+			event.request.body instanceof ReadableStream ||
+				// @ts-expect-error the types for fetchevent are messed up
+				event.request.body instanceof ArrayBuffer
+				? [event.request.body]
+				: undefined
+		);
+
+		return new Response(response.body, {
+			status: response.status,
+			statusText: response.statusText,
+			headers: response.headers,
+		});
+	} catch (e) {
+		console.error("Service Worker error:", e);
+		return new Response(
+			"Internal Service Worker Error: " + (e as Error).message,
+			{
+				status: 500,
+			}
+		);
+	}
+}

package/src/types.d.ts

@@ -0,0 +1,95 @@
+import type { RawHeaders } from "@mercuryworkshop/proxy-transports";
+
+export type BodyType =
+	| string
+	| ArrayBuffer
+	| Blob
+	| ReadableStream<Uint8Array<ArrayBufferLike>>;
+
+export type TransferRequest = {
+	rawUrl: string;
+	destination: RequestDestination;
+	mode: RequestMode;
+	referrer: string;
+	method: string;
+	body: BodyType | null;
+	cache: RequestCache;
+	forceCrossOriginIsolated: boolean;
+	initialHeaders: RawHeaders;
+	rawClientUrl?: string;
+};
+
+export type TransferResponse = {
+	body: BodyType;
+	headers: RawHeaders;
+	status: number;
+	statusText: string;
+};
+
+export type Controllerbound = {
+	ready: [];
+	request: [TransferRequest, TransferResponse];
+	sendSetCookie: [
+		{
+			url: string;
+			cookie: string;
+		},
+	];
+	initRemoteTransport: [MessagePort];
+};
+
+export type SWbound = {
+	sendSetCookie: [
+		{
+			url: string;
+			cookie: string;
+		},
+	];
+};
+
+export type TransportToController = {
+	request: [
+		{
+			remote: string;
+			method: string;
+			body: BodyInit | null;
+			headers: RawHeaders;
+			// signal: AbortSignal | undefined
+		},
+		TransferrableResponse,
+	];
+	connect: [
+		{
+			url: string;
+			protocols: string[];
+			requestHeaders: RawHeaders;
+			port: MessagePort;
+		},
+		(
+			| {
+					result: "success";
+					protocol: string;
+					extensions: string;
+			  }
+			| {
+					result: "failure";
+					error: string;
+			  }
+		),
+	];
+};
+
+export type ControllerToTransport = {
+	ready: [];
+};
+export type WebSocketData = string | ArrayBuffer | Blob;
+export type WebSocketMessage =
+	| {
+			type: "data";
+			data: WebSocketData;
+	  }
+	| {
+			type: "close";
+			code: number;
+			reason: string;
+	  };

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+{
+	"compilerOptions": {
+		"target": "ES2022",
+		"useDefineForClassFields": true,
+		"module": "ESNext",
+		"lib": ["ES2022", "webworker", "DOM", "DOM.Iterable"],
+		"types": [],
+		"skipLibCheck": true,
+		/* Bundler mode */
+		"moduleResolution": "node",
+		"allowImportingTsExtensions": true,
+		"verbatimModuleSyntax": true,
+		"moduleDetection": "force",
+		"noEmit": true,
+		/* Linting */
+		"strict": true,
+		"noUnusedLocals": true,
+		"noUnusedParameters": false,
+		"erasableSyntaxOnly": false,
+		"noFallthroughCasesInSwitch": true,
+		"noUncheckedSideEffectImports": true,
+	},
+	"include": ["src"]
+}