@nodefony/http 10.0.0-beta.6 → 10.0.0-beta.7

package/dist/nodefony/grpc/GrpcEndpoint.js

@@ -0,0 +1,528 @@
+import HttpError from "../src/errors/httpError.js";
+import { STREAM_STALL_TIMEOUT_MS, disarmResponseTimeout, openStreamLifecycle, resolveStreamTarget } from "../src/context/http/StreamLifecycle.js";
+import { GRPC_DEFAULT_MAX_MESSAGE_BYTES } from "../src/grpc/limits.js";
+import { applicationErrorCode } from "../src/grpc/refusal.js";
+import { RPC_EXPOSED_HEADERS } from "../src/grpc/cors.js";
+import DefaultErrorRenderer from "../service/error-renderer.js";
+import { GrpcCall } from "./GrpcCall.js";
+import { Code, ConnectError } from "@connectrpc/connect";
+import { connectNodeAdapter } from "@connectrpc/connect-node";
+import { createRegistry } from "@bufbuild/protobuf";
+// nodefony/grpc/GrpcEndpoint.ts
+/**
+* Levé par le repli de l'adaptateur (`fallback`), qui l'appelle de façon
+* SYNCHRONE quand aucune méthode ne correspond au chemin exact — casse
+* modifiée, le Router étant insensible à la casse. Une seule instance : le
+* repli ne paie aucune allocation, et `serve` le reconnaît par identité.
+*/
+const UNROUTED = /* @__PURE__ */ new Error("gRPC : aucune méthode à ce chemin");
+/**
+* Repli de l'adaptateur : rien n'est écrit ici. Le refus remonte au pipeline,
+* qui l'écrit au format du protocole comme tout chemin inconnu (ADR-0026 D13
+* point 2) — un seul écrivain des refus. Le repli par défaut de Connect, un
+* 404 nu terminé par une trame DATA, est lu `INTERNAL` par grpc-go
+* (connectrpc/connect-es#1882).
+*/
+function unrouted() {
+	throw UNROUTED;
+}
+/**
+* Défauts de la section `grpc`, quand le contexte n'a pas de noyau http (banc
+* hors serveur) : les trois protocoles (défaut de l'adaptateur,
+* `router.d.ts`) et les bornes de Nodefony — jamais celles de l'adaptateur,
+* qui n'en pose aucune.
+*/
+const DEFAULT_SETTINGS = Object.freeze({
+	grpc: true,
+	grpcWeb: true,
+	connect: true,
+	readMaxBytes: GRPC_DEFAULT_MAX_MESSAGE_BYTES,
+	writeMaxBytes: GRPC_DEFAULT_MAX_MESSAGE_BYTES,
+	requireConnectProtocolHeader: false
+});
+/**
+* Type retenu pour la politique d'en-têtes d'un appel sans `Content-Type` (GET
+* Connect, dont le codage passe en paramètre d'URL).
+*/
+const RPC_RESPONSE_TYPE = "application/proto";
+/**
+* Point d'entrée gRPC d'un service : possède l'adaptateur Connect
+* (`connectNodeAdapter`) et lui confie la requête et la réponse BRUTES de Node
+* d'un contexte déjà passé par le pipeline (pare-feu, gardes).
+*
+* L'adaptateur est construit au premier appel, depuis la section `grpc` de la
+* configuration http. Il reçoit la fiche d'appel ({@link GrpcCall}) par son
+* option `contextValues`, qu'il appelle de façon SYNCHRONE avant toute
+* attente (`connect-node-adapter.js#nodeRequestHandler`) : la cible passe par
+* une case lue à cet instant — ni ALS, ni promesse, ni écouteur de plus.
+*
+* Les méthodes s'inscrivent une à une par `router.rpc`, SANS options : des
+* options passées à l'inscription rallumeraient gRPC et gRPC-Web coupés par la
+* configuration (connectrpc/connect-es#1835). La restriction de protocoles
+* vit sur l'adaptateur seul.
+*
+* @experimental Surface gRPC, ADR-0026 D11.
+*/
+var GrpcEndpoint = class {
+	/** Le contrat servi (descripteur généré par `buf`). */
+	service;
+	/** Cible relue à chaque appel (`@Scope("request")`). */
+	perCall;
+	#handler = null;
+	/** Case synchrone : la cible de l'appel en cours de remise à l'adaptateur. */
+	#pendingTarget = null;
+	/** Case synchrone : le contexte de l'appel en cours de remise. */
+	#pendingContext = null;
+	/**
+	* Option `contextValues` : une fiche par appel, rien sur le chemin du 404.
+	* Accrochée au contexte (`HttpContext.rpc`, ADR-0026 D10) : à l'échéance du
+	* délai de réponse, le noyau la termine au lieu d'écrire un 503.
+	*/
+	#contextValues = () => {
+		const context = this.#pendingContext;
+		const call = new GrpcCall(this.#pendingTarget, context);
+		if (context !== null) context.rpc = call;
+		return call;
+	};
+	/**
+	* Chemins des méthodes en flux (serveur, client, bidirectionnel) : elles
+	* s'ouvrent par le cycle de vie d'un flux. Tout autre chemin — unaire, ou
+	* inconnu, que l'adaptateur refusera sans rien écrire — garde son délai de
+	* réponse.
+	*/
+	#streamingPaths;
+	constructor(service, options = {}) {
+		this.service = service;
+		this.perCall = options.perCall ?? false;
+		this.#streamingPaths = streamingPathsOf(service);
+	}
+	/**
+	* Remet la requête du contexte à l'adaptateur, qui écrit lui-même la
+	* réponse et ses trailers. Synchrone : rien n'est attendu ici.
+	*
+	* Avant de la remettre : le contexte est marqué répondu (`sended`), si bien
+	* que le pipeline n'attend aucune réponse de l'action.
+	*
+	* - Appel unaire : le délai de réponse de Nodefony reste armé, et termine
+	*   l'appel en 4 `DEADLINE_EXCEEDED` par sa fiche (`HttpContext.rpc`,
+	*   ADR-0026 D4 point 3).
+	* - Flux : aucune échéance. Il s'ouvre par le cycle de vie d'un flux
+	*   (`openStreamLifecycle`, D4 point 4) — délai de réponse désarmé (à
+	*   l'expiration il écrirait un 503 par-dessus l'adaptateur), place dans
+	*   le budget de connexions longues par IP, client qui ne lit plus coupé
+	*   par le balayage de blocage. Synchrone, sauf quand une session est à
+	*   sauver : l'appel n'est remis qu'après.
+	*
+	* @param context - le contexte HTTP de la requête, pas encore répondu.
+	* @param target - l'objet qui implémente le service pour cet appel.
+	* @returns rien, ou la promesse de la remise quand une session est à sauver.
+	* @throws HttpError 500 quand la réponse est déjà partie, ou que son
+	*   transport n'est pas reconnu.
+	* @throws HttpError 429 quand l'IP du client a déjà tous ses flux et sockets
+	*   (`wsMaxConnectionsPerIp`) — rendu par le pipeline en 14 `UNAVAILABLE`.
+	* @throws HttpError 400 quand l'adaptateur refuse la requête avant d'avoir
+	*   rien écrit (requête sans autorité `Host`) — la réponse revient alors au
+	*   pipeline.
+	* @throws HttpError 404 quand aucune méthode ne correspond au chemin exact
+	*   (casse modifiée) — rendu par le pipeline en 12 `UNIMPLEMENTED`.
+	*/
+	serve(context, target) {
+		if (context.sended || context.finished || context.response.isHeaderSent()) throw new HttpError("gRPC : la réponse est déjà partie", 500);
+		const nodeResponse = context.response.response;
+		const streamTarget = resolveStreamTarget(context);
+		if (nodeResponse === null || streamTarget === null) throw new HttpError("gRPC : transport de réponse inconnu", 500, context);
+		const handler = this.#handler ?? this.#build(context, target);
+		if (!this.#streamingPaths.has(context.request.url.pathname)) {
+			context.sended = true;
+			this.#hand(context, target, handler, nodeResponse);
+			return;
+		}
+		disarmResponseTimeout(streamTarget);
+		const opened = openStreamLifecycle(context, {
+			label: "gRPC",
+			stallTimeout: STREAM_STALL_TIMEOUT_MS,
+			maxDuration: false,
+			foreignWriter: true
+		});
+		if (opened instanceof Promise) return opened.then((lifecycle) => this.#handStream(lifecycle, target, handler, nodeResponse));
+		this.#handStream(opened, target, handler, nodeResponse);
+	}
+	/** Remet un flux à l'adaptateur — sauf si le client est déjà parti. */
+	#handStream(lifecycle, target, handler, nodeResponse) {
+		if (lifecycle.closed) return;
+		this.#hand(lifecycle.context, target, handler, nodeResponse);
+	}
+	/**
+	* Remet la requête à l'adaptateur. La fiche d'appel est créée par
+	* `contextValues`, appelée de façon SYNCHRONE dans l'appel : les cases
+	* `#pending*` ne vivent que le temps de celui-ci.
+	*
+	* L'adaptateur écrit sur la réponse Node : ce que le pipeline a posé dans la
+	* réserve — transport, CORS et `Vary`, corrélation (`X-Request-Id`,
+	* `traceparent`), politique de sécurité, cookie de session — y passe d'abord
+	* (ADR-0026 D6). Node fusionne au `writeHead` de l'adaptateur, qui garde la
+	* main sur ce qu'il écrit lui-même (`content-type`).
+	*/
+	#hand(context, target, handler, nodeResponse) {
+		if (context.response.hasHeader("access-control-allow-origin")) exposeRpcHeaders(context.response);
+		context.response.commitHeaders(context.request.request.headers["content-type"] ?? RPC_RESPONSE_TYPE);
+		this.#pendingTarget = target;
+		this.#pendingContext = context;
+		try {
+			handler(context.request.request, nodeResponse);
+		} catch (error) {
+			if (nodeResponse.headersSent) throw error;
+			context.sended = false;
+			context.rpc = null;
+			if (error === UNROUTED) throw HttpError.withoutStack("Not Found", 404, context);
+			context.log(error, "WARNING", "GRPC");
+			throw HttpError.withoutStack("gRPC : requête mal formée", 400, context);
+		} finally {
+			this.#pendingTarget = null;
+			this.#pendingContext = null;
+		}
+	}
+	/** Construit l'adaptateur, une fois, depuis la configuration http. */
+	#build(context, target) {
+		const settings = context.httpKernel?.options.grpc ?? DEFAULT_SETTINGS;
+		const shared = this.perCall ? null : target;
+		const handler = connectNodeAdapter({
+			grpc: settings.grpc,
+			grpcWeb: settings.grpcWeb,
+			connect: settings.connect,
+			readMaxBytes: settings.readMaxBytes,
+			writeMaxBytes: settings.writeMaxBytes,
+			requireConnectProtocolHeader: settings.requireConnectProtocolHeader,
+			contextValues: this.#contextValues,
+			requestGate: observeCall,
+			fallback: unrouted,
+			jsonOptions: { registry: contractRegistry(this.service) },
+			routes: (router) => registerMethods(router, this.service, shared)
+		});
+		this.#handler = handler;
+		return handler;
+	}
+};
+/** Les chemins `/<paquet.Service>/<Méthode>` des méthodes en flux du contrat. */
+function streamingPathsOf(service) {
+	const paths = /* @__PURE__ */ new Set();
+	for (const method of service.methods) if (!isUnary(method)) paths.add(`/${service.typeName}/${method.name}`);
+	return paths;
+}
+/**
+* Fin d'un appel à réponse unique — unaire (ADR-0026 D4, point 3), flux
+* client : l'appel se termine dès que le serveur l'interrompt — délai de
+* réponse échu (unaire), identité révoquée (D6) —, même si le gestionnaire ne
+* lit pas son signal.
+*
+* - L'adaptateur tient l'échéance DU CLIENT et abaisse `ctx.signal`, mais
+*   attend la promesse du gestionnaire
+*   (`invoke-implementation.js#invokeUnaryImplementation`) : un gestionnaire
+*   sourd tiendrait l'appel ouvert sans fin.
+* - Le délai du serveur est celui que Nodefony arme déjà sur toute requête,
+*   gardé sur une route unaire : à l'expiration, `HttpContext._onTimeout`
+*   appelle `GrpcCall.expire`, qui abaisse le signal et rejette la promesse
+*   rendue ici avec 4 `DEADLINE_EXCEEDED`. Aucun minuteur de plus.
+* - Ce délai n'est PAS écrit dans l'en-tête d'échéance : le gestionnaire
+*   verrait par `ctx.timeoutMs()` une échéance que le client n'a pas envoyée
+*   (suite de conformité de Connect : « server echoed back a timeout but none
+*   was expected »).
+* - Un résultat synchrone passe tel quel : ni promesse, ni suivi.
+*/
+function settleUnary(result, ctx) {
+	if (!(result instanceof Promise)) return result;
+	return settlePending(result, ctx);
+}
+/** {@link settleUnary} d'une réponse attendue : suivie par la fiche d'appel. */
+function settlePending(pending, ctx) {
+	const call = ctx.values;
+	if (!(call instanceof GrpcCall)) return pending;
+	return new Promise((resolve, reject) => {
+		call.attach(ctx, reject);
+		pending.then((value) => {
+			call.detach();
+			resolve(value);
+		}, (error) => {
+			call.detach();
+			reject(translateError(error, ctx));
+		});
+	});
+}
+/**
+* Registre des types du contrat : son fichier et tout ce qu'il importe, types
+* bien connus compris. Sans lui, un `google.protobuf.Any` ne se lit ni ne
+* s'écrit en JSON (Connect et gRPC-Web JSON répondent `INVALID_ARGUMENT`) :
+* le mappage JSON de proto3 exige de résoudre le type emballé. Construit une
+* fois ; Connect ne le consulte que pour `Any` en JSON. Un type emballé hors
+* du graphe d'imports du contrat reste non résolu en JSON — le binaire, lui,
+* le transporte toujours.
+*/
+function contractRegistry(service) {
+	const files = [];
+	const seen = /* @__PURE__ */ new Set();
+	const visit = (file) => {
+		if (seen.has(file)) return;
+		seen.add(file);
+		files.push(file);
+		for (const dependency of file.dependencies) visit(dependency);
+	};
+	visit(service.file);
+	return createRegistry(...files);
+}
+/**
+* Inscrit chaque méthode du contrat. `shared` non nul : ses méthodes, liées
+* une fois. `null` : une enveloppe par méthode, qui relit la cible dans la
+* fiche d'appel. Un garde par genre de méthode donne à chaque enveloppe le
+* type exact de sa méthode — aucune conversion.
+*/
+function registerMethods(router, service, shared) {
+	for (const method of service.methods) if (isUnary(method)) {
+		if (shared !== null) {
+			const impl = pick(method, shared);
+			router.rpc(method, (request, ctx) => settleUnary(invoke(impl, shared, request, ctx), ctx));
+		} else router.rpc(method, (request, ctx) => {
+			const target = callTarget(ctx);
+			return settleUnary(invoke(pick(method, target), target, request, ctx), ctx);
+		});
+	} else if (isServerStreaming(method)) {
+		if (shared !== null) {
+			const impl = pick(method, shared);
+			router.rpc(method, (request, ctx) => translateFirst(invoke(impl, shared, request, ctx), ctx));
+		} else router.rpc(method, (request, ctx) => {
+			const target = callTarget(ctx);
+			return translateFirst(invoke(pick(method, target), target, request, ctx), ctx);
+		});
+	} else if (isClientStreaming(method)) {
+		if (shared !== null) {
+			const impl = pick(method, shared);
+			router.rpc(method, (requests, ctx) => translateSettled(invoke(impl, shared, requests, ctx), ctx));
+		} else router.rpc(method, (requests, ctx) => {
+			const target = callTarget(ctx);
+			return translateSettled(invoke(pick(method, target), target, requests, ctx), ctx);
+		});
+	} else if (isBiDiStreaming(method)) {
+		if (shared !== null) {
+			const impl = pick(method, shared);
+			router.rpc(method, (requests, ctx) => translateFirst(invoke(impl, shared, requests, ctx), ctx));
+		} else router.rpc(method, (requests, ctx) => {
+			const target = callTarget(ctx);
+			return translateFirst(invoke(pick(method, target), target, requests, ctx), ctx);
+		});
+	}
+}
+/**
+* Lit les erreurs comme une route HTTP les lirait : statut et message client
+* (`DefaultErrorRenderer.describe`). Sans état, partagé par tous les appels.
+*/
+const ERRORS = new DefaultErrorRenderer();
+/**
+* Traduit une erreur levée par l'application en `ConnectError` (ADR-0026 D7) :
+* une `HttpError` d'un service partagé avec des routes HTTP, une validation, un
+* conflit, un code numérique, gardent leur sens — 404 → 5 `NOT_FOUND`, et non
+* 13. Le message suit la règle des routes HTTP (opaque pour un 5xx en
+* production) ; l'erreur d'origine reste la cause, côté serveur.
+*
+* Une exception que rien ne classe devient 13 avec la MÊME règle de message
+* qu'une route HTTP : son message en développement (« sinon on débogue à
+* l'aveugle »), opaque en production, où sa cause ne quitte jamais le serveur.
+*
+* Passent TELLES QUELLES : une `ConnectError` (son code est voulu) et une
+* valeur qui n'est pas une `Error` (l'adaptateur en fait 13 « internal error »).
+*
+* Chemin d'erreur seulement : rien n'est payé sur un appel qui réussit.
+*/
+function translateError(error, ctx) {
+	if (!(error instanceof Error) || error instanceof ConnectError) return error;
+	const { status, message } = ERRORS.describe(error);
+	const call = ctx.values;
+	const identified = call instanceof GrpcCall && call.context !== null && call.context.authenticatedUser() !== null;
+	return new ConnectError(message, CONNECT_CODES[applicationErrorCode(status, identified)] ?? Code.Unknown, void 0, void 0, error);
+}
+/**
+* Le `Code` de Connect de chaque code gRPC (index = numéro, 1 à 16). La table
+* D7 vit hors du sous-chemin gRPC, sans Connect (ADR-0026 D12) : elle rend
+* un nombre, que cette correspondance ramène au type attendu.
+*/
+const CONNECT_CODES = [
+	void 0,
+	Code.Canceled,
+	Code.Unknown,
+	Code.InvalidArgument,
+	Code.DeadlineExceeded,
+	Code.NotFound,
+	Code.AlreadyExists,
+	Code.PermissionDenied,
+	Code.ResourceExhausted,
+	Code.FailedPrecondition,
+	Code.Aborted,
+	Code.OutOfRange,
+	Code.Unimplemented,
+	Code.Internal,
+	Code.Unavailable,
+	Code.DataLoss,
+	Code.Unauthenticated
+];
+/**
+* Ajoute à `Access-Control-Expose-Headers` les en-têtes qu'un client RPC doit
+* lire (statut, message, détails, encodage) — à ce que la politique de
+* l'application expose déjà. Une chaîne composée au chargement ; un appel
+* d'une origine autorisée seulement.
+*/
+function exposeRpcHeaders(response) {
+	const current = response.getHeader("access-control-expose-headers");
+	const listed = Array.isArray(current) ? current.join(", ") : current;
+	response.setHeader("access-control-expose-headers", listed === void 0 || listed === "" ? RPC_EXPOSED_HEADERS : `${String(listed)}, ${RPC_EXPOSED_HEADERS}`);
+}
+/**
+* Option `requestGate` de l'adaptateur, en simple OBSERVATEUR : Connect
+* l'appelle avec le contexte d'appel AVANT de lire le corps, dans les trois
+* protocoles. La fiche le garde jusqu'au `close`, où son signal porte la cause
+* de la fin (ADR-0026 D10 point 2) — y compris d'un refus de Connect avant
+* le gestionnaire (bombe gzip → 8, encodage inconnu → 12), que le
+* gestionnaire ne voit jamais. Ne lève jamais.
+*/
+function observeCall(ctx) {
+	const call = ctx.values;
+	if (call instanceof GrpcCall) call.open(ctx);
+}
+/**
+* Appelle l'implémentation sur sa cible ; une erreur levée de façon SYNCHRONE
+* (validation avant toute attente) est traduite ({@link translateError}). Un
+* `try` ne coûte rien à l'appel qui réussit.
+*/
+function invoke(impl, target, arg, ctx) {
+	try {
+		return impl.call(target, arg, ctx);
+	} catch (error) {
+		throw translateError(error, ctx);
+	}
+}
+/**
+* Flux client (une seule réponse) : toute erreur est traduite (ADR-0026 D7,
+* point 3), et l'appel se termine dès que le serveur l'interrompt (identité
+* révoquée, D6) — le même règlement qu'un appel unaire. Une promesse par
+* appel, aucune par message reçu.
+*/
+function translateSettled(result, ctx) {
+	return settlePending(result, ctx);
+}
+/**
+* Flux serveur et bidirectionnel : traduit les erreurs levées AVANT le premier
+* message (validation, entité introuvable, droit refusé) — là où un service
+* partagé avec des routes HTTP lève (ADR-0026 D7, point 3). Après le premier
+* message, l'erreur passe telle quelle : 13, sauf une `ConnectError`, dont le
+* code est voulu.
+*/
+function translateFirst(source, ctx) {
+	return new FirstMessageTranslator(source, ctx);
+}
+/**
+* Itérateur d'un flux : l'erreur levée AVANT le premier message est traduite
+* (D7), et une source qui finit après une interruption du serveur (identité
+* révoquée, arrêt) part avec le statut de l'interruption — jamais `OK`.
+* `return` et `throw` vont à la source : un gestionnaire `async function*`
+* voit son `finally` s'exécuter quand le client part.
+*
+* Coût : un `.then` par message, sur des fonctions créées une fois par appel
+* (mesuré : +34 ns par message, médiane de 9) — le prix d'un flux tronqué qui
+* ne se fait pas passer pour complet.
+*/
+var FirstMessageTranslator = class {
+	#source;
+	#ctx;
+	/** La fiche de l'appel : son interruption arrête le flux (ADR-0026 D6). */
+	#call;
+	#started = false;
+	/**
+	* Une source qui ÉCOUTE son signal finit normalement après l'interruption :
+	* sa fin porte alors le statut de l'interruption, sinon Connect écrirait
+	* `OK` et le client prendrait un flux tronqué pour complet.
+	*/
+	#onResult = (result) => {
+		if (result.done === true) {
+			const interruption = this.#call?.interruption ?? null;
+			if (interruption !== null) throw interruption;
+		}
+		return result;
+	};
+	/** Erreur avant le premier message : traduite au format du protocole (D7). */
+	#onFirstError = (error) => {
+		throw translateError(error, this.#ctx);
+	};
+	constructor(source, ctx) {
+		this.#source = source[Symbol.asyncIterator]();
+		this.#ctx = ctx;
+		const call = ctx.values;
+		this.#call = call instanceof GrpcCall ? call : null;
+		this.#call?.follow(ctx);
+	}
+	[Symbol.asyncIterator]() {
+		return this;
+	}
+	next() {
+		const interruption = this.#call?.interruption ?? null;
+		if (interruption !== null) return this.#stop(interruption);
+		if (this.#started) return this.#source.next().then(this.#onResult);
+		this.#started = true;
+		return this.#source.next().then(this.#onResult, this.#onFirstError);
+	}
+	return(value) {
+		const source = this.#source;
+		return source.return === void 0 ? Promise.resolve({
+			done: true,
+			value: void 0
+		}) : source.return(value);
+	}
+	throw(error) {
+		const source = this.#source;
+		if (source.throw !== void 0) return source.throw(error);
+		return this.return().then(() => {
+			throw error;
+		});
+	}
+	/**
+	* Arrête un flux interrompu : la source est refermée (le `finally` d'un
+	* gestionnaire `async function*` s'exécute), sans attendre qu'elle finisse
+	* — le statut part tout de suite.
+	*/
+	#stop(reason) {
+		this.#source.return?.().catch(ignoreClosingError);
+		return Promise.reject(reason);
+	}
+};
+/** Une source qui lève en se refermant : l'appel est déjà terminé. */
+function ignoreClosingError() {}
+function isUnary(method) {
+	return method.methodKind === "unary";
+}
+function isServerStreaming(method) {
+	return method.methodKind === "server_streaming";
+}
+function isClientStreaming(method) {
+	return method.methodKind === "client_streaming";
+}
+function isBiDiStreaming(method) {
+	return method.methodKind === "bidi_streaming";
+}
+/** La cible de l'appel, posée par {@link GrpcEndpoint.serve} dans la fiche. */
+function callTarget(ctx) {
+	const call = ctx.values;
+	if (call instanceof GrpcCall && call.target !== null) return call.target;
+	throw new ConnectError("appel gRPC reçu hors de GrpcEndpoint.serve : aucune cible", Code.Internal);
+}
+/**
+* L'implémentation d'une méthode du contrat sur sa cible. La signature est
+* garantie à la compilation par `@GrpcService` et la présence vérifiée au
+* démarrage ; ici, le constat qu'il s'agit bien d'une fonction.
+*
+* @throws ConnectError `UNIMPLEMENTED` quand la cible ne la porte pas.
+*/
+function pick(method, target) {
+	const impl = Reflect.get(target, method.localName);
+	if (isImplOf(method, impl)) return impl;
+	throw new ConnectError(`${method.parent.typeName}.${method.name} n'est pas implémentée`, Code.Unimplemented);
+}
+function isImplOf(_method, value) {
+	return typeof value === "function";
+}
+export { GrpcEndpoint };

package/dist/nodefony/grpc/index.js

@@ -0,0 +1,4 @@
+import { GrpcCall, hasAbort } from "./GrpcCall.js";
+import { GrpcEndpoint } from "./GrpcEndpoint.js";
+import { markGrpcRoute } from "../src/grpc/refusal.js";
+export { GrpcCall, GrpcEndpoint, hasAbort, markGrpcRoute };

package/dist/nodefony/interfaces/IRpcCall.js

@@ -0,0 +1 @@
+export {};

package/dist/nodefony/service/audit-logger.js

@@ -1,4 +1,5 @@
 import { handshakeRefusalStatus } from "../src/context/websocket/WebsocketContext.js";
+import { rpcOutcomeOf } from "../src/context/rpcOutcome.js";
 // nodefony/service/audit-logger.ts
 const statusOf = (context) => {
 	return context.response?.statusCode ?? null;
@@ -18,6 +19,46 @@ function severityFromStatus(status) {
 	return "INFO";
 }
 /**
+* Codes gRPC qu'un SERVEUR compte comme des erreurs, selon la convention
+* OpenTelemetry (`docs/rpc/grpc.md`, « SHOULD be considered errors ») :
+* 2 UNKNOWN, 4 DEADLINE_EXCEEDED, 12 UNIMPLEMENTED, 13 INTERNAL,
+* 14 UNAVAILABLE, 15 DATA_LOSS. Un masque : un décalage, aucune table.
+*/
+const RPC_SERVER_ERRORS = 61460;
+/**
+* Gravité d'un appel RPC selon son code (ADR-0026 D10 point 4) : 0 → INFO ;
+* une erreur du serveur ({@link RPC_SERVER_ERRORS}) → ERROR ; les autres —
+* refus, échecs métier ou client — → WARNING.
+*
+* @param code - le code de l'appel (gRPC : 0 à 16).
+* @returns la gravité de la ligne.
+*/
+function severityFromRpcCode(code) {
+	if (code === 0) return "INFO";
+	return code < 32 && (RPC_SERVER_ERRORS >>> code & 1) === 1 ? "ERROR" : "WARNING";
+}
+/**
+* Gravité de la ligne d'une requête HTTP : celle du code de son appel RPC
+* quand il est fixé — le statut HTTP d'un appel gRPC reste 200 quand l'appel
+* échoue —, sinon celle de son statut.
+*
+* @param context - le contexte de la requête.
+* @param status - son statut HTTP.
+* @returns la gravité de la ligne.
+*/
+function severityOfHttp(context, status) {
+	const code = context.rpc?.code ?? null;
+	return code === null ? severityFromStatus(status) : severityFromRpcCode(code);
+}
+/**
+* Un appel RPC en échec (code fixé, non nul) — sous un statut HTTP qui peut
+* rester 200 : jamais écarté par l'échantillonnage.
+*/
+function rpcFailed(context) {
+	const code = context.rpc?.code ?? null;
+	return code !== null && code !== 0;
+}
+/**
 * JSON audit logger — implements IRequestLogger so it slots into
 * `httpKernel.setRequestLogger(new JsonAuditLogger())`.
 *
@@ -43,8 +84,9 @@ var JsonAuditLogger = class {
 	/**
 	* Decide whether the current HTTP request must be logged (audit sampling).
 	*
-	* Always `true` when `sampleRate <= 1`, on errors, and for `status >= 400`
-	* (failures are never sampled out). Otherwise selects 1 in `sampleRate` of
+	* Always `true` when `sampleRate <= 1`, on errors, for `status >= 400` and
+	* for a failed RPC call — whose HTTP status may stay 200 (failures are
+	* never sampled out). Otherwise selects 1 in `sampleRate` of
 	* the 2xx/3xx requests with a deterministic counter.
 	*
 	* Called by `Context.logRequest()` **before** `renderHttp`, so a sampled-out
@@ -58,11 +100,13 @@ var JsonAuditLogger = class {
 		const ctx = context;
 		if (!this.nominalEnabled) {
 			if (error ?? ctx.error) return true;
+			if (rpcFailed(ctx)) return true;
 			const status = statusOf(ctx);
 			return status !== null && status >= 400;
 		}
 		if (this.sampleRate <= 1) return true;
 		if (error ?? ctx.error) return true;
+		if (rpcFailed(ctx)) return true;
 		const status = statusOf(ctx);
 		if (status !== null && status >= 400) return true;
 		this.sampleCounter = (this.sampleCounter + 1) % this.sampleRate;
@@ -92,11 +136,12 @@ var JsonAuditLogger = class {
 				name: p.name,
 				durationMs: p.durationMs ?? null
 			})) : void 0,
-			error: err ? this.serializeError(err, 0) : void 0
+			error: err ? this.serializeError(err, 0) : void 0,
+			rpc: rpcOutcomeOf(ctx.rpc ?? null)
 		};
 		return {
 			text: JSON.stringify(entry),
-			severity: severityFromStatus(status ?? (err ? 500 : null)),
+			severity: severityOfHttp(ctx, status ?? (err ? 500 : null)),
 			msgid: "audit"
 		};
 	}
@@ -125,7 +170,8 @@ var JsonAuditLogger = class {
 				durationMs: p.durationMs ?? null
 			})) : void 0,
 			protocol: acceptedProtocol ?? null,
-			error: error ? this.serializeError(error, 0) : void 0
+			error: error ? this.serializeError(error, 0) : void 0,
+			rpc: null
 		};
 		return {
 			text: JSON.stringify(entry),
@@ -151,4 +197,4 @@ var JsonAuditLogger = class {
 		return entry;
 	}
 };
-export { JsonAuditLogger as default, severityFromStatus, statusOf };
+export { JsonAuditLogger as default, severityFromRpcCode, severityFromStatus, severityOfHttp, statusOf };