@ldtr/nestjs-webtransport 0.0.1

package/README.md

@@ -0,0 +1,80 @@
+NestJS module for creating WebTransport servers and gateways.
+
+Installation
+============
+
+```bash
+npm install @ldtr/nestjs-webtransport
+```
+
+Usage
+=====
+
+Declare a server and a gateway:
+```ts
+import {
+    WtSession,
+    WtStreamRW,
+    WtStreamRO,
+    WebTransportServer,
+    WebTransportGateway,
+    type HttpServerInit,
+    type WebTransportGatewayLifecycle,
+    type WebTransportServerOptionsFactory
+} from "@ldtr/nestjs-webtransport"
+import { readFile } from "node:fs/promises"
+
+@WebTransportServer({ name: "main" })
+export class MainWebTransportServer implements WebTransportServerOptionsFactory {
+    constructor(
+        private readonly configService: ConfigService
+    ) {
+    }
+
+    async options(): Promise<HttpServerInit> {
+        const cert = await readFile("./certs/cert.pem", { encoding: "utf-8" })
+        const privKey = await readFile("./certs/key.pem", { encoding: "utf-8" })
+        const secret = this.configService.secret
+        return {
+            port: 3001,
+            host: "0.0.0.0",
+            secret,
+            cert,
+            privKey,
+            defaultDatagramsReadableMode: "bytes",
+        }
+    }
+}
+
+@WebTransportGateway({ server: "main", path: "/events" })
+export class EventsGateway implements WebTransportGatewayLifecycle {
+    onSession(session: WtSession): void {
+        // new WebTransport session
+    }
+
+    onStreamRW(stream: WtStreamRW): void {
+        // new bidirectional stream
+    }
+
+    onStreamRO(stream: WtStreamRO): void {
+        // new unidirectional stream
+    }
+}
+```
+
+Then import them in your application with the ```WebTransportModule```:
+
+```ts
+import { WebTransportModule } from "@ldtr/nestjs-webtransport"
+import { Module } from "@nestjs/common"
+
+@Module({
+    imports: [
+      WebTransportModule],
+    providers: [
+        EventsGateway,
+        MainWebTransportServer]
+})
+export class AppModule {
+}
+```

package/dist/index.cjs

@@ -0,0 +1,430 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let _nestjs_common = require("@nestjs/common");
+let _nestjs_core = require("@nestjs/core");
+//#region src/lib/decorators/webtransport-gateway.decorator.ts
+const DiscoverableWebTransportGateway = _nestjs_core.DiscoveryService.createDecorator();
+function WebTransportGateway(options) {
+	return (0, _nestjs_common.applyDecorators)((0, _nestjs_common.Injectable)(), DiscoverableWebTransportGateway(options));
+}
+//#endregion
+//#region src/lib/decorators/webtransport-server.decorator.ts
+const DiscoverableWebTransportServer = _nestjs_core.DiscoveryService.createDecorator();
+function WebTransportServer(options) {
+	return (0, _nestjs_common.applyDecorators)((0, _nestjs_common.Injectable)(), DiscoverableWebTransportServer(options));
+}
+//#endregion
+//#region src/lib/bootstraps/helpers.ts
+async function* generateSession(stream) {
+	const reader = stream.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* generateBStream(session) {
+	const reader = session.incomingBidirectionalStreams.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* generateUStream(session) {
+	const reader = session.incomingUnidirectionalStreams.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* generateChunks(reader) {
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+function fireAndForget(task, logger) {
+	if (!task) return;
+	try {
+		Promise.resolve(task()).catch((error) => {
+			logger?.error(error);
+		});
+	} catch (error) {
+		logger?.error(error);
+	}
+}
+//#endregion
+//#region src/lib/classes/wt-stream.ts
+var AbstractStreamHandler = class {
+	closed = false;
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		await this.localClose();
+	}
+};
+var ReadableStreamHandler = class extends AbstractStreamHandler {
+	reader;
+	chunks;
+	constructor(reader) {
+		super();
+		this.reader = reader;
+		this.chunks = generateChunks(this.reader);
+	}
+	read() {
+		if (this.closed) throw new Error("Can't read stream");
+		return this.chunks;
+	}
+	async localClose() {
+		await this.reader.cancel();
+	}
+};
+var WritableStreamHandler = class extends AbstractStreamHandler {
+	writer;
+	constructor(writer) {
+		super();
+		this.writer = writer;
+	}
+	async write(chunk) {
+		if (this.closed) throw new Error("Can't write stream");
+		await this.writer.write(chunk);
+	}
+	async localClose() {
+		await this.writer.close();
+	}
+};
+var AbstractWtStream = class {
+	session;
+	webTransportStream;
+	constructor(session, webTransportStream) {
+		this.session = session;
+		this.webTransportStream = webTransportStream;
+	}
+};
+var WtStreamRW = class extends AbstractWtStream {
+	readableStreamHandler;
+	writableStreamHandler;
+	constructor(session, webTransportStream) {
+		super(session, webTransportStream);
+		this.readableStreamHandler = new ReadableStreamHandler(webTransportStream.readable.getReader());
+		this.writableStreamHandler = new WritableStreamHandler(webTransportStream.writable.getWriter());
+	}
+	read() {
+		return this.readableStreamHandler.read();
+	}
+	async write(data) {
+		await this.writableStreamHandler.write(data);
+	}
+	async closeReadable() {
+		await this.readableStreamHandler.close();
+	}
+	async closeWritable() {
+		await this.writableStreamHandler.close();
+	}
+	async close() {
+		await Promise.all([this.closeReadable(), this.closeWritable()]);
+	}
+};
+var WtStreamRO = class extends AbstractWtStream {
+	readableStreamHandler;
+	constructor(session, webTransportStream) {
+		super(session, webTransportStream);
+		this.readableStreamHandler = new ReadableStreamHandler(webTransportStream.getReader());
+	}
+	read() {
+		return this.readableStreamHandler.read();
+	}
+	async closeReadable() {
+		await this.readableStreamHandler.close();
+	}
+};
+var WtStreamWO = class extends AbstractWtStream {
+	writableStreamHandler;
+	constructor(session, webTransportStream) {
+		super(session, webTransportStream);
+		this.writableStreamHandler = new WritableStreamHandler(webTransportStream.getWriter());
+	}
+	async write(data) {
+		await this.writableStreamHandler.write(data);
+	}
+	async closeWritable() {
+		await this.writableStreamHandler.close();
+	}
+};
+//#endregion
+//#region src/lib/explorers/webtransport-gateway.explorer.ts
+var WebTransportGatewayExplorer = @((0, _nestjs_common.Injectable)()) class {
+	discoveryService;
+	constructor(discoveryService) {
+		this.discoveryService = discoveryService;
+	}
+	discover(serverNames) {
+		const gatewaysByNameByPath = /* @__PURE__ */ new Map();
+		const wrappers = this.discoveryService.getProviders({ metadataKey: DiscoverableWebTransportGateway.KEY });
+		for (const wrapper of wrappers) {
+			const metadata = this.discoveryService.getMetadataByDecorator(DiscoverableWebTransportGateway, wrapper);
+			if (!metadata || !wrapper.metatype) continue;
+			const { server } = metadata;
+			let { path } = metadata;
+			if (!path.startsWith("/")) path = "/" + path;
+			const gateway = wrapper.instance;
+			if (!gatewaysByNameByPath.has(server)) {
+				if (!serverNames.includes(server)) throw new Error(`@WebTransportGateway() server name doesn't exist: ${server}`);
+				gatewaysByNameByPath.set(server, /* @__PURE__ */ new Map());
+			}
+			if (gatewaysByNameByPath.get(server).has(path)) throw new Error(`Duplicate @WebTransportGateway() path: ${path}`);
+			gatewaysByNameByPath.get(server).set(path, gateway);
+		}
+		return gatewaysByNameByPath;
+	}
+};
+//#endregion
+//#region src/lib/explorers/webtransport-server.explorer.ts
+var WebTransportServerExplorer = @((0, _nestjs_common.Injectable)()) class {
+	discoveryService;
+	constructor(discoveryService) {
+		this.discoveryService = discoveryService;
+	}
+	discover() {
+		const serversByName = /* @__PURE__ */ new Map();
+		const wrappers = this.discoveryService.getProviders({ metadataKey: DiscoverableWebTransportServer.KEY });
+		for (const wrapper of wrappers) {
+			const metadata = this.discoveryService.getMetadataByDecorator(DiscoverableWebTransportServer, wrapper);
+			if (!metadata || !wrapper.metatype) continue;
+			const { name } = metadata;
+			if (serversByName.has(name)) throw new Error(`Duplicate @WebTransportServer() name: ${name}`);
+			const server = wrapper.instance;
+			serversByName.set(name, server);
+		}
+		return serversByName;
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/web-transport-bootstrapper.ts
+var WebTransportBootstrapper = @((0, _nestjs_common.Injectable)()) class WebTransportBootstrapper {
+	serverFactory;
+	webTransportExplorer;
+	logger = new _nestjs_common.Logger(WebTransportBootstrapper.name);
+	h3ServersWithInfo = [];
+	constructor(serverFactory, webTransportExplorer) {
+		this.serverFactory = serverFactory;
+		this.webTransportExplorer = webTransportExplorer;
+	}
+	async onApplicationBootstrap() {
+		const serverBindings = this.webTransportExplorer.discover();
+		this.h3ServersWithInfo = await this.serverFactory.createH3Servers(serverBindings);
+		await Promise.all(this.h3ServersWithInfo.map(async ({ options, name, h3Server }) => {
+			try {
+				h3Server.startServer();
+				await h3Server.ready;
+				this.logger.log(`WebTransport server "${name}" is ready on ${options.host}:${options.port}`);
+			} catch (e) {
+				this.logger.error(`Failed to start WebTransport server "${name}" on ${options.host}:${options.port}`);
+				throw e;
+			}
+		}));
+	}
+	async onApplicationShutdown() {
+		await Promise.all(this.h3ServersWithInfo.map(async ({ name, h3Server }) => {
+			h3Server.stopServer();
+			await h3Server.closed;
+			this.logger.log(`WebTransport server "${name}" stopped`);
+		}));
+	}
+};
+//#endregion
+//#region src/lib/explorers/web-transport.explorer.ts
+var WebTransportExplorer = @((0, _nestjs_common.Injectable)()) class WebTransportExplorer {
+	webTransportServerExplorer;
+	webTransportGatewayExplorer;
+	logger = new _nestjs_common.Logger(WebTransportExplorer.name);
+	constructor(webTransportServerExplorer, webTransportGatewayExplorer) {
+		this.webTransportServerExplorer = webTransportServerExplorer;
+		this.webTransportGatewayExplorer = webTransportGatewayExplorer;
+	}
+	discover() {
+		const serversByName = this.webTransportServerExplorer.discover();
+		const gatewaysByNameByPath = this.webTransportGatewayExplorer.discover(Array.from(serversByName.keys()));
+		const serverBindings = [];
+		serversByName.forEach((server, name) => {
+			const gatewaysByPath = gatewaysByNameByPath.get(name);
+			if (gatewaysByPath === void 0) this.logger.warn(`WebTransport server "${name}" has no gateways, skipping`);
+			else serverBindings.push({
+				server,
+				name,
+				gatewaysByPath
+			});
+		});
+		return serverBindings;
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/consumers/abstract-stream.consumer.ts
+var AbstractStreamConsumer = class {
+	async consume(gateway, webTransportSession, session) {
+		for await (const webTransportStream of this.generateStream(webTransportSession)) this.handleStream(gateway, session, webTransportStream);
+	}
+	handleStream(gateway, session, webTransportStream) {
+		const stream = this.createStream(session, webTransportStream);
+		this.consumeHook(gateway, stream);
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/consumers/stream-ro.consumer.ts
+var StreamROConsumer = @((0, _nestjs_common.Injectable)()) class StreamROConsumer extends AbstractStreamConsumer {
+	logger = new _nestjs_common.Logger(StreamROConsumer.name);
+	generateStream(session) {
+		return generateUStream(session);
+	}
+	createStream(session, webTransportStream) {
+		return new WtStreamRO(session, webTransportStream);
+	}
+	consumeHook(gateway, stream) {
+		fireAndForget(() => gateway.onStreamRO?.(stream), this.logger);
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/consumers/stream-rw.consumer.ts
+var StreamRWConsumer = @((0, _nestjs_common.Injectable)()) class StreamRWConsumer extends AbstractStreamConsumer {
+	logger = new _nestjs_common.Logger(StreamRWConsumer.name);
+	generateStream(session) {
+		return generateBStream(session);
+	}
+	createStream(session, webTransportStream) {
+		return new WtStreamRW(session, webTransportStream);
+	}
+	consumeHook(gateway, stream) {
+		fireAndForget(() => gateway.onStreamRW?.(stream), this.logger);
+	}
+};
+//#endregion
+//#region src/lib/classes/wt-session.ts
+var WtSession = class {
+	webTransportSession;
+	constructor(webTransportSession) {
+		this.webTransportSession = webTransportSession;
+	}
+	async createStreamWO() {
+		const stream = await this.webTransportSession.createUnidirectionalStream();
+		return new WtStreamWO(this, stream);
+	}
+	async createStreamRW() {
+		const stream = await this.webTransportSession.createBidirectionalStream();
+		return new WtStreamRW(this, stream);
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/server-factory.ts
+let webtransport;
+const getLib = eval(`import('@fails-components/webtransport')`).then((module) => {
+	webtransport = module;
+});
+function createHandshakeResponse(request, host, status) {
+	const url = new URL(request.header[":path"], `https://${host}`);
+	return {
+		...request,
+		path: url.pathname,
+		header: {
+			...request.header,
+			":path": url.pathname
+		},
+		status
+	};
+}
+var ServerFactory = @((0, _nestjs_common.Injectable)()) class ServerFactory {
+	streamRWConsumer;
+	streamROConsumer;
+	logger = new _nestjs_common.Logger(ServerFactory.name);
+	constructor(streamRWConsumer, streamROConsumer) {
+		this.streamRWConsumer = streamRWConsumer;
+		this.streamROConsumer = streamROConsumer;
+	}
+	async createH3Servers(serverBindings) {
+		await getLib;
+		const h3ServersWithInfo = [];
+		for (const { server, name, gatewaysByPath } of serverBindings) {
+			const options = await server.options();
+			const h3Server = this.createH3Server(options, gatewaysByPath);
+			h3ServersWithInfo.push({
+				options,
+				h3Server,
+				name
+			});
+		}
+		return h3ServersWithInfo;
+	}
+	createH3Server(options, gatewaysByPath) {
+		const h3Server = new webtransport.Http3Server(options);
+		h3Server.setRequestCallback(async (request) => {
+			const status = await this.getRequestStatus(request, gatewaysByPath);
+			return createHandshakeResponse(request, options.host, status);
+		});
+		for (const [path, gateway] of gatewaysByPath.entries()) this.consumeSession(gateway, h3Server, path).catch((error) => this.logger.error(error));
+		return h3Server;
+	}
+	async getRequestStatus(request, gatewaysByPath) {
+		const { pathname } = new URL(request.header[":path"], "https://0.0.0.0");
+		const gateway = gatewaysByPath.get(pathname);
+		if (gateway === void 0) return 404;
+		try {
+			await gateway.allowRequest?.(request);
+			return 200;
+		} catch (e) {
+			if (e instanceof _nestjs_common.HttpException) return e.getStatus();
+			return 400;
+		}
+	}
+	async consumeSession(gateway, h3Server, path) {
+		const stream = h3Server.sessionStream(path);
+		for await (const session of generateSession(stream)) this.handleSession(gateway, session);
+	}
+	handleSession(gateway, webTransportSession) {
+		const session = new WtSession(webTransportSession);
+		fireAndForget(() => gateway.onSession?.(session), this.logger);
+		webTransportSession.closed.catch((error) => this.logger.error(error)).finally(() => {
+			fireAndForget(() => gateway.onSessionClosed?.(session), this.logger);
+		});
+		this.streamRWConsumer.consume(gateway, webTransportSession, session).catch((error) => this.logger.error(error));
+		this.streamROConsumer.consume(gateway, webTransportSession, session).catch((error) => this.logger.error(error));
+	}
+};
+//#endregion
+//#region src/lib/webtransport.module.ts
+var WebTransportModule = @((0, _nestjs_common.Module)({
+	imports: [_nestjs_core.DiscoveryModule],
+	providers: [
+		ServerFactory,
+		StreamRWConsumer,
+		StreamROConsumer,
+		WebTransportExplorer,
+		WebTransportBootstrapper,
+		WebTransportServerExplorer,
+		WebTransportGatewayExplorer
+	]
+})) class {};
+//#endregion
+exports.WebTransportGateway = WebTransportGateway;
+exports.WebTransportModule = WebTransportModule;
+exports.WebTransportServer = WebTransportServer;
+exports.WtSession = WtSession;
+exports.WtStreamRO = WtStreamRO;
+exports.WtStreamRW = WtStreamRW;
+exports.WtStreamWO = WtStreamWO;

package/dist/index.d.cts

@@ -0,0 +1,85 @@
+import { HttpServerInit, HttpServerInit as HttpServerInit$1, WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream, WebTransportSession } from "@fails-components/webtransport";
+//#region src/lib/decorators/webtransport-gateway.decorator.d.ts
+type WebTransportGatewayOptions = {
+  readonly path: string;
+  readonly server: string;
+};
+declare function WebTransportGateway(options: WebTransportGatewayOptions): ClassDecorator;
+//#endregion
+//#region src/lib/decorators/webtransport-server.decorator.d.ts
+interface WebTransportServerOptions {
+  readonly name: string;
+}
+declare function WebTransportServer(options: WebTransportServerOptions): ClassDecorator;
+//#endregion
+//#region src/lib/explorers/webtransport-server.explorer.d.ts
+type WebTransportServerOptionsFactory = {
+  options(): HttpServerInit$1 | Promise<HttpServerInit$1>;
+};
+//#endregion
+//#region src/lib/classes/wt-session.d.ts
+declare class WtSession {
+  private readonly webTransportSession;
+  constructor(webTransportSession: WebTransportSession);
+  createStreamWO(): Promise<WtStreamWO>;
+  createStreamRW(): Promise<WtStreamRW>;
+}
+//#endregion
+//#region src/lib/classes/wt-stream.d.ts
+declare abstract class AbstractWtStream<TWebStream> {
+  readonly session: WtSession;
+  protected readonly webTransportStream: TWebStream;
+  protected constructor(session: WtSession, webTransportStream: TWebStream);
+}
+interface WtReadableStream {
+  read(): AsyncIterableIterator<Uint8Array>;
+  closeReadable(): Promise<void>;
+}
+interface WtWritableStream {
+  write(data: Uint8Array): Promise<void>;
+  closeWritable(): Promise<void>;
+}
+declare class WtStreamRW extends AbstractWtStream<WebTransportBidirectionalStream> implements WtReadableStream, WtWritableStream {
+  private readonly readableStreamHandler;
+  private readonly writableStreamHandler;
+  constructor(session: WtSession, webTransportStream: WebTransportBidirectionalStream);
+  read(): AsyncIterableIterator<Uint8Array>;
+  write(data: Uint8Array): Promise<void>;
+  closeReadable(): Promise<void>;
+  closeWritable(): Promise<void>;
+  close(): Promise<void>;
+}
+declare class WtStreamRO extends AbstractWtStream<WebTransportReceiveStream> implements WtReadableStream {
+  private readonly readableStreamHandler;
+  constructor(session: WtSession, webTransportStream: WebTransportReceiveStream);
+  read(): AsyncIterableIterator<Uint8Array>;
+  closeReadable(): Promise<void>;
+}
+declare class WtStreamWO extends AbstractWtStream<WebTransportSendStream> implements WtWritableStream {
+  private readonly writableStreamHandler;
+  constructor(session: WtSession, webTransportStream: WebTransportSendStream);
+  write(data: Uint8Array): Promise<void>;
+  closeWritable(): Promise<void>;
+}
+//#endregion
+//#region src/lib/bootstraps/types.d.ts
+type WebTransportRequestHeader = {
+  readonly ':path': string;
+};
+type WebTransportRequest = {
+  readonly header: WebTransportRequestHeader;
+};
+//#endregion
+//#region src/lib/explorers/webtransport-gateway.explorer.d.ts
+type WebTransportGatewayLifecycle = {
+  allowRequest?(request: WebTransportRequest): void | Promise<void>;
+  onSession?(session: WtSession): void | Promise<void>;
+  onSessionClosed?(session: WtSession): void | Promise<void>;
+  onStreamRW?(stream: WtStreamRW): void | Promise<void>;
+  onStreamRO?(stream: WtStreamRO): void | Promise<void>;
+};
+//#endregion
+//#region src/lib/webtransport.module.d.ts
+declare class WebTransportModule {}
+//#endregion
+export { type HttpServerInit, WebTransportGateway, type WebTransportGatewayLifecycle, type WebTransportGatewayOptions, WebTransportModule, WebTransportServer, type WebTransportServerOptions, type WebTransportServerOptionsFactory, WtSession, WtStreamRO, WtStreamRW, WtStreamWO };

package/dist/index.d.mts

@@ -0,0 +1,87 @@
+import { DiscoveryService } from "@nestjs/core";
+import { HttpServerInit, HttpServerInit as HttpServerInit$1, WebTransportBidirectionalStream, WebTransportReceiveStream, WebTransportSendStream, WebTransportSession } from "@fails-components/webtransport";
+
+//#region src/lib/decorators/webtransport-gateway.decorator.d.ts
+type WebTransportGatewayOptions = {
+  readonly path: string;
+  readonly server: string;
+};
+declare function WebTransportGateway(options: WebTransportGatewayOptions): ClassDecorator;
+//#endregion
+//#region src/lib/decorators/webtransport-server.decorator.d.ts
+interface WebTransportServerOptions {
+  readonly name: string;
+}
+declare function WebTransportServer(options: WebTransportServerOptions): ClassDecorator;
+//#endregion
+//#region src/lib/explorers/webtransport-server.explorer.d.ts
+type WebTransportServerOptionsFactory = {
+  options(): HttpServerInit$1 | Promise<HttpServerInit$1>;
+};
+//#endregion
+//#region src/lib/classes/wt-session.d.ts
+declare class WtSession {
+  private readonly webTransportSession;
+  constructor(webTransportSession: WebTransportSession);
+  createStreamWO(): Promise<WtStreamWO>;
+  createStreamRW(): Promise<WtStreamRW>;
+}
+//#endregion
+//#region src/lib/classes/wt-stream.d.ts
+declare abstract class AbstractWtStream<TWebStream> {
+  readonly session: WtSession;
+  protected readonly webTransportStream: TWebStream;
+  protected constructor(session: WtSession, webTransportStream: TWebStream);
+}
+interface WtReadableStream {
+  read(): AsyncIterableIterator<Uint8Array>;
+  closeReadable(): Promise<void>;
+}
+interface WtWritableStream {
+  write(data: Uint8Array): Promise<void>;
+  closeWritable(): Promise<void>;
+}
+declare class WtStreamRW extends AbstractWtStream<WebTransportBidirectionalStream> implements WtReadableStream, WtWritableStream {
+  private readonly readableStreamHandler;
+  private readonly writableStreamHandler;
+  constructor(session: WtSession, webTransportStream: WebTransportBidirectionalStream);
+  read(): AsyncIterableIterator<Uint8Array>;
+  write(data: Uint8Array): Promise<void>;
+  closeReadable(): Promise<void>;
+  closeWritable(): Promise<void>;
+  close(): Promise<void>;
+}
+declare class WtStreamRO extends AbstractWtStream<WebTransportReceiveStream> implements WtReadableStream {
+  private readonly readableStreamHandler;
+  constructor(session: WtSession, webTransportStream: WebTransportReceiveStream);
+  read(): AsyncIterableIterator<Uint8Array>;
+  closeReadable(): Promise<void>;
+}
+declare class WtStreamWO extends AbstractWtStream<WebTransportSendStream> implements WtWritableStream {
+  private readonly writableStreamHandler;
+  constructor(session: WtSession, webTransportStream: WebTransportSendStream);
+  write(data: Uint8Array): Promise<void>;
+  closeWritable(): Promise<void>;
+}
+//#endregion
+//#region src/lib/bootstraps/types.d.ts
+type WebTransportRequestHeader = {
+  readonly ':path': string;
+};
+type WebTransportRequest = {
+  readonly header: WebTransportRequestHeader;
+};
+//#endregion
+//#region src/lib/explorers/webtransport-gateway.explorer.d.ts
+type WebTransportGatewayLifecycle = {
+  allowRequest?(request: WebTransportRequest): void | Promise<void>;
+  onSession?(session: WtSession): void | Promise<void>;
+  onSessionClosed?(session: WtSession): void | Promise<void>;
+  onStreamRW?(stream: WtStreamRW): void | Promise<void>;
+  onStreamRO?(stream: WtStreamRO): void | Promise<void>;
+};
+//#endregion
+//#region src/lib/webtransport.module.d.ts
+declare class WebTransportModule {}
+//#endregion
+export { type HttpServerInit, WebTransportGateway, type WebTransportGatewayLifecycle, type WebTransportGatewayOptions, WebTransportModule, WebTransportServer, type WebTransportServerOptions, type WebTransportServerOptionsFactory, WtSession, WtStreamRO, WtStreamRW, WtStreamWO };

package/dist/index.mjs

@@ -0,0 +1,423 @@
+import { HttpException, Injectable, Logger, Module, applyDecorators } from "@nestjs/common";
+import { DiscoveryModule, DiscoveryService } from "@nestjs/core";
+//#region src/lib/decorators/webtransport-gateway.decorator.ts
+const DiscoverableWebTransportGateway = DiscoveryService.createDecorator();
+function WebTransportGateway(options) {
+	return applyDecorators(Injectable(), DiscoverableWebTransportGateway(options));
+}
+//#endregion
+//#region src/lib/decorators/webtransport-server.decorator.ts
+const DiscoverableWebTransportServer = DiscoveryService.createDecorator();
+function WebTransportServer(options) {
+	return applyDecorators(Injectable(), DiscoverableWebTransportServer(options));
+}
+//#endregion
+//#region src/lib/bootstraps/helpers.ts
+async function* generateSession(stream) {
+	const reader = stream.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* generateBStream(session) {
+	const reader = session.incomingBidirectionalStreams.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* generateUStream(session) {
+	const reader = session.incomingUnidirectionalStreams.getReader();
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+async function* generateChunks(reader) {
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			yield value;
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}
+function fireAndForget(task, logger) {
+	if (!task) return;
+	try {
+		Promise.resolve(task()).catch((error) => {
+			logger?.error(error);
+		});
+	} catch (error) {
+		logger?.error(error);
+	}
+}
+//#endregion
+//#region src/lib/classes/wt-stream.ts
+var AbstractStreamHandler = class {
+	closed = false;
+	async close() {
+		if (this.closed) return;
+		this.closed = true;
+		await this.localClose();
+	}
+};
+var ReadableStreamHandler = class extends AbstractStreamHandler {
+	reader;
+	chunks;
+	constructor(reader) {
+		super();
+		this.reader = reader;
+		this.chunks = generateChunks(this.reader);
+	}
+	read() {
+		if (this.closed) throw new Error("Can't read stream");
+		return this.chunks;
+	}
+	async localClose() {
+		await this.reader.cancel();
+	}
+};
+var WritableStreamHandler = class extends AbstractStreamHandler {
+	writer;
+	constructor(writer) {
+		super();
+		this.writer = writer;
+	}
+	async write(chunk) {
+		if (this.closed) throw new Error("Can't write stream");
+		await this.writer.write(chunk);
+	}
+	async localClose() {
+		await this.writer.close();
+	}
+};
+var AbstractWtStream = class {
+	session;
+	webTransportStream;
+	constructor(session, webTransportStream) {
+		this.session = session;
+		this.webTransportStream = webTransportStream;
+	}
+};
+var WtStreamRW = class extends AbstractWtStream {
+	readableStreamHandler;
+	writableStreamHandler;
+	constructor(session, webTransportStream) {
+		super(session, webTransportStream);
+		this.readableStreamHandler = new ReadableStreamHandler(webTransportStream.readable.getReader());
+		this.writableStreamHandler = new WritableStreamHandler(webTransportStream.writable.getWriter());
+	}
+	read() {
+		return this.readableStreamHandler.read();
+	}
+	async write(data) {
+		await this.writableStreamHandler.write(data);
+	}
+	async closeReadable() {
+		await this.readableStreamHandler.close();
+	}
+	async closeWritable() {
+		await this.writableStreamHandler.close();
+	}
+	async close() {
+		await Promise.all([this.closeReadable(), this.closeWritable()]);
+	}
+};
+var WtStreamRO = class extends AbstractWtStream {
+	readableStreamHandler;
+	constructor(session, webTransportStream) {
+		super(session, webTransportStream);
+		this.readableStreamHandler = new ReadableStreamHandler(webTransportStream.getReader());
+	}
+	read() {
+		return this.readableStreamHandler.read();
+	}
+	async closeReadable() {
+		await this.readableStreamHandler.close();
+	}
+};
+var WtStreamWO = class extends AbstractWtStream {
+	writableStreamHandler;
+	constructor(session, webTransportStream) {
+		super(session, webTransportStream);
+		this.writableStreamHandler = new WritableStreamHandler(webTransportStream.getWriter());
+	}
+	async write(data) {
+		await this.writableStreamHandler.write(data);
+	}
+	async closeWritable() {
+		await this.writableStreamHandler.close();
+	}
+};
+//#endregion
+//#region src/lib/explorers/webtransport-gateway.explorer.ts
+var WebTransportGatewayExplorer = @Injectable() class {
+	discoveryService;
+	constructor(discoveryService) {
+		this.discoveryService = discoveryService;
+	}
+	discover(serverNames) {
+		const gatewaysByNameByPath = /* @__PURE__ */ new Map();
+		const wrappers = this.discoveryService.getProviders({ metadataKey: DiscoverableWebTransportGateway.KEY });
+		for (const wrapper of wrappers) {
+			const metadata = this.discoveryService.getMetadataByDecorator(DiscoverableWebTransportGateway, wrapper);
+			if (!metadata || !wrapper.metatype) continue;
+			const { server } = metadata;
+			let { path } = metadata;
+			if (!path.startsWith("/")) path = "/" + path;
+			const gateway = wrapper.instance;
+			if (!gatewaysByNameByPath.has(server)) {
+				if (!serverNames.includes(server)) throw new Error(`@WebTransportGateway() server name doesn't exist: ${server}`);
+				gatewaysByNameByPath.set(server, /* @__PURE__ */ new Map());
+			}
+			if (gatewaysByNameByPath.get(server).has(path)) throw new Error(`Duplicate @WebTransportGateway() path: ${path}`);
+			gatewaysByNameByPath.get(server).set(path, gateway);
+		}
+		return gatewaysByNameByPath;
+	}
+};
+//#endregion
+//#region src/lib/explorers/webtransport-server.explorer.ts
+var WebTransportServerExplorer = @Injectable() class {
+	discoveryService;
+	constructor(discoveryService) {
+		this.discoveryService = discoveryService;
+	}
+	discover() {
+		const serversByName = /* @__PURE__ */ new Map();
+		const wrappers = this.discoveryService.getProviders({ metadataKey: DiscoverableWebTransportServer.KEY });
+		for (const wrapper of wrappers) {
+			const metadata = this.discoveryService.getMetadataByDecorator(DiscoverableWebTransportServer, wrapper);
+			if (!metadata || !wrapper.metatype) continue;
+			const { name } = metadata;
+			if (serversByName.has(name)) throw new Error(`Duplicate @WebTransportServer() name: ${name}`);
+			const server = wrapper.instance;
+			serversByName.set(name, server);
+		}
+		return serversByName;
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/web-transport-bootstrapper.ts
+var WebTransportBootstrapper = @Injectable() class WebTransportBootstrapper {
+	serverFactory;
+	webTransportExplorer;
+	logger = new Logger(WebTransportBootstrapper.name);
+	h3ServersWithInfo = [];
+	constructor(serverFactory, webTransportExplorer) {
+		this.serverFactory = serverFactory;
+		this.webTransportExplorer = webTransportExplorer;
+	}
+	async onApplicationBootstrap() {
+		const serverBindings = this.webTransportExplorer.discover();
+		this.h3ServersWithInfo = await this.serverFactory.createH3Servers(serverBindings);
+		await Promise.all(this.h3ServersWithInfo.map(async ({ options, name, h3Server }) => {
+			try {
+				h3Server.startServer();
+				await h3Server.ready;
+				this.logger.log(`WebTransport server "${name}" is ready on ${options.host}:${options.port}`);
+			} catch (e) {
+				this.logger.error(`Failed to start WebTransport server "${name}" on ${options.host}:${options.port}`);
+				throw e;
+			}
+		}));
+	}
+	async onApplicationShutdown() {
+		await Promise.all(this.h3ServersWithInfo.map(async ({ name, h3Server }) => {
+			h3Server.stopServer();
+			await h3Server.closed;
+			this.logger.log(`WebTransport server "${name}" stopped`);
+		}));
+	}
+};
+//#endregion
+//#region src/lib/explorers/web-transport.explorer.ts
+var WebTransportExplorer = @Injectable() class WebTransportExplorer {
+	webTransportServerExplorer;
+	webTransportGatewayExplorer;
+	logger = new Logger(WebTransportExplorer.name);
+	constructor(webTransportServerExplorer, webTransportGatewayExplorer) {
+		this.webTransportServerExplorer = webTransportServerExplorer;
+		this.webTransportGatewayExplorer = webTransportGatewayExplorer;
+	}
+	discover() {
+		const serversByName = this.webTransportServerExplorer.discover();
+		const gatewaysByNameByPath = this.webTransportGatewayExplorer.discover(Array.from(serversByName.keys()));
+		const serverBindings = [];
+		serversByName.forEach((server, name) => {
+			const gatewaysByPath = gatewaysByNameByPath.get(name);
+			if (gatewaysByPath === void 0) this.logger.warn(`WebTransport server "${name}" has no gateways, skipping`);
+			else serverBindings.push({
+				server,
+				name,
+				gatewaysByPath
+			});
+		});
+		return serverBindings;
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/consumers/abstract-stream.consumer.ts
+var AbstractStreamConsumer = class {
+	async consume(gateway, webTransportSession, session) {
+		for await (const webTransportStream of this.generateStream(webTransportSession)) this.handleStream(gateway, session, webTransportStream);
+	}
+	handleStream(gateway, session, webTransportStream) {
+		const stream = this.createStream(session, webTransportStream);
+		this.consumeHook(gateway, stream);
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/consumers/stream-ro.consumer.ts
+var StreamROConsumer = @Injectable() class StreamROConsumer extends AbstractStreamConsumer {
+	logger = new Logger(StreamROConsumer.name);
+	generateStream(session) {
+		return generateUStream(session);
+	}
+	createStream(session, webTransportStream) {
+		return new WtStreamRO(session, webTransportStream);
+	}
+	consumeHook(gateway, stream) {
+		fireAndForget(() => gateway.onStreamRO?.(stream), this.logger);
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/consumers/stream-rw.consumer.ts
+var StreamRWConsumer = @Injectable() class StreamRWConsumer extends AbstractStreamConsumer {
+	logger = new Logger(StreamRWConsumer.name);
+	generateStream(session) {
+		return generateBStream(session);
+	}
+	createStream(session, webTransportStream) {
+		return new WtStreamRW(session, webTransportStream);
+	}
+	consumeHook(gateway, stream) {
+		fireAndForget(() => gateway.onStreamRW?.(stream), this.logger);
+	}
+};
+//#endregion
+//#region src/lib/classes/wt-session.ts
+var WtSession = class {
+	webTransportSession;
+	constructor(webTransportSession) {
+		this.webTransportSession = webTransportSession;
+	}
+	async createStreamWO() {
+		const stream = await this.webTransportSession.createUnidirectionalStream();
+		return new WtStreamWO(this, stream);
+	}
+	async createStreamRW() {
+		const stream = await this.webTransportSession.createBidirectionalStream();
+		return new WtStreamRW(this, stream);
+	}
+};
+//#endregion
+//#region src/lib/bootstraps/server-factory.ts
+let webtransport;
+const getLib = eval(`import('@fails-components/webtransport')`).then((module) => {
+	webtransport = module;
+});
+function createHandshakeResponse(request, host, status) {
+	const url = new URL(request.header[":path"], `https://${host}`);
+	return {
+		...request,
+		path: url.pathname,
+		header: {
+			...request.header,
+			":path": url.pathname
+		},
+		status
+	};
+}
+var ServerFactory = @Injectable() class ServerFactory {
+	streamRWConsumer;
+	streamROConsumer;
+	logger = new Logger(ServerFactory.name);
+	constructor(streamRWConsumer, streamROConsumer) {
+		this.streamRWConsumer = streamRWConsumer;
+		this.streamROConsumer = streamROConsumer;
+	}
+	async createH3Servers(serverBindings) {
+		await getLib;
+		const h3ServersWithInfo = [];
+		for (const { server, name, gatewaysByPath } of serverBindings) {
+			const options = await server.options();
+			const h3Server = this.createH3Server(options, gatewaysByPath);
+			h3ServersWithInfo.push({
+				options,
+				h3Server,
+				name
+			});
+		}
+		return h3ServersWithInfo;
+	}
+	createH3Server(options, gatewaysByPath) {
+		const h3Server = new webtransport.Http3Server(options);
+		h3Server.setRequestCallback(async (request) => {
+			const status = await this.getRequestStatus(request, gatewaysByPath);
+			return createHandshakeResponse(request, options.host, status);
+		});
+		for (const [path, gateway] of gatewaysByPath.entries()) this.consumeSession(gateway, h3Server, path).catch((error) => this.logger.error(error));
+		return h3Server;
+	}
+	async getRequestStatus(request, gatewaysByPath) {
+		const { pathname } = new URL(request.header[":path"], "https://0.0.0.0");
+		const gateway = gatewaysByPath.get(pathname);
+		if (gateway === void 0) return 404;
+		try {
+			await gateway.allowRequest?.(request);
+			return 200;
+		} catch (e) {
+			if (e instanceof HttpException) return e.getStatus();
+			return 400;
+		}
+	}
+	async consumeSession(gateway, h3Server, path) {
+		const stream = h3Server.sessionStream(path);
+		for await (const session of generateSession(stream)) this.handleSession(gateway, session);
+	}
+	handleSession(gateway, webTransportSession) {
+		const session = new WtSession(webTransportSession);
+		fireAndForget(() => gateway.onSession?.(session), this.logger);
+		webTransportSession.closed.catch((error) => this.logger.error(error)).finally(() => {
+			fireAndForget(() => gateway.onSessionClosed?.(session), this.logger);
+		});
+		this.streamRWConsumer.consume(gateway, webTransportSession, session).catch((error) => this.logger.error(error));
+		this.streamROConsumer.consume(gateway, webTransportSession, session).catch((error) => this.logger.error(error));
+	}
+};
+//#endregion
+//#region src/lib/webtransport.module.ts
+var WebTransportModule = @Module({
+	imports: [DiscoveryModule],
+	providers: [
+		ServerFactory,
+		StreamRWConsumer,
+		StreamROConsumer,
+		WebTransportExplorer,
+		WebTransportBootstrapper,
+		WebTransportServerExplorer,
+		WebTransportGatewayExplorer
+	]
+}) class {};
+//#endregion
+export { WebTransportGateway, WebTransportModule, WebTransportServer, WtSession, WtStreamRO, WtStreamRW, WtStreamWO };

package/package.json

@@ -0,0 +1,32 @@
+ {
+    "name": "@ldtr/nestjs-webtransport",
+    "version": "0.0.1",
+    "type": "module",
+    "files": ["dist"],
+    "main": "./dist/index.cjs",
+    "module": "./dist/index.js",
+    "types": "./dist/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./dist/index.d.ts",
+            "import": "./dist/index.js",
+            "require": "./dist/index.cjs"
+        }
+    },
+    "scripts": {
+        "build": "tsdown",
+        "typecheck": "tsc --noEmit"
+    },
+    "dependencies": {
+        "@fails-components/webtransport": "^1.6.3",
+        "@fails-components/webtransport-transport-http3-quiche": "^1.6.3",
+        "reflect-metadata": "^0.1.13",
+        "tslib": "^2.3.0",
+        "tsdown": "^0.22.3",
+        "typescript": "^6.0.3"
+    },
+    "peerDependencies": {
+        "@nestjs/common": "^11.0.0",
+        "@nestjs/core": "^11.0.0"
+    }
+}