Server-Sent Events (SSE)

Vous pouvez gérer un flux SSE en utilisant le contrat de réponse approprié.

import { ResponseContract, useRouteBuilder } from "@duplojs/http";
import { D, DPE, sleep } from "@duplojs/utils";

useRouteBuilder("GET", "/some-route")
	.extract({
		headers: {
			superToken: DPE.string(),
		},
	})
	.cut(
		ResponseContract.unauthorized("invalid-token"),
		({ superToken }, { response, output }) => {
			if (superToken !== "valid-token") {
				return response("invalid-token");
			}

			return output();
		},
	)
	.handler(
		ResponseContract.serverSentEvents(
			"SSE",
			DPE.object({ value: DPE.string() }),
			{ otherEvent: DPE.string() },
		),
		(__, { serverSentEventsResponse }) => serverSentEventsResponse(
			"SSE",
			async({ send, lastId, isAbort }) => {
				if (lastId !== null) {
					await send(
						"otherEvent",
						"successful reconnection",
						{ retry: "10s" },
					);
				}

				while (isAbort() === false) {
					await send(
						"message",
						{ value: "super Value" },
						{ id: D.now().toString() },
					);

					await sleep(1000);
				}
			},
		),
	);

Gestion du flux côté client

Il suffit d'appeler une route qui renvoie un flux SSE, et le client se chargera de créer une réponse adaptée pour le recevoir.

import { createHttpClient } from "@duplojs/http/client";
import { type Routes } from "./types";

const client = createHttpClient<Routes>({
	baseUrl: "http://localhost:1506",
});

const response = await client.get(
	"/some-route",
	{ headers: { superToken: "valid-token" } },
).iWantInformationOrThrow("SSE");

response.onReceiveEvent("message", (event) => {









});

response.onReceiveEvent("otherEvent", (event) => {
	// ...
});

// start consume SSE
for await (const event of response) {
	// ...
}
// or
void response.consumeEventStream();

Lorsque le client détecte un flux SSE, il ajoute des méthodes permettant de manipuler et de consommer les événements reçus. Pour consommer le flux, il suffit soit d'itérer sur la réponse, soit d'appeler la méthode consumeEventStream.