@webda/grpc 4.0.0-beta.6 → 4.0.0-beta.8

package/src/grpcservice.service.ts

@@ -1,22 +1,26 @@
 import {
+  AsyncQueue,
+  BuildCommand,
+  HttpContext,
+  OperationDefinition,
   OperationsTransport,
   OperationsTransportParameters,
-  OperationDefinition,
+  WebdaError,
   callOperation,
-  OperationContext,
-  SimpleOperationContext,
-  WebContext,
+  emitCoreEvent,
+  getOperationStreaming,
+  runWithContext,
+  runWithInstanceStorage,
   useApplication,
   useCore,
-  BuildCommand,
-  ServiceParameters,
-  runWithInstanceStorage,
-  useInstanceStorage
+  useInstanceStorage,
+  useRouter
 } from "@webda/core";
 import { useLog } from "@webda/workout";
 import * as protoLoader from "@grpc/proto-loader";
 import { existsSync, writeFileSync, mkdirSync } from "node:fs";
 import { join, dirname } from "node:path";
+import { GrpcOperationContext, toGrpcMessage } from "./grpc-context.js";
 import { GrpcStream, GrpcStatus } from "./grpc-stream.js";
 import { generateProto } from "./proto-generator.js";
 import type { IncomingMessage, ServerResponse } from "node:http";
@@ -29,13 +33,29 @@ export class GrpcServiceParameters extends OperationsTransportParameters {
    * Path to the generated .proto file
    * @default ".webda/app.proto"
    */
-  protoFile?: string;
+  protoFile: string;
 
   /**
    * Protobuf package name
    * @default "webda"
    */
-  packageName?: string;
+  packageName: string;
+
+  /**
+   * Most unconsumed messages a client or bidirectional operation may have queued; above it the call fails with
+   * RESOURCE_EXHAUSTED
+   *
+   * @default 1000
+   */
+  maxQueuedMessages: number;
+
+  /**
+   * Most bytes of unconsumed messages a client or bidirectional operation may have queued; above it the call fails
+   * with RESOURCE_EXHAUSTED
+   *
+   * @default 16777216
+   */
+  maxQueuedBytes: number;
 
   /**
    * Load and apply default parameter values.
@@ -46,6 +66,8 @@ export class GrpcServiceParameters extends OperationsTransportParameters {
     super.load(params);
     this.protoFile ??= ".webda/app.proto";
     this.packageName ??= "webda";
+    this.maxQueuedMessages ??= 1000;
+    this.maxQueuedBytes ??= 16 * 1024 * 1024;
     return this;
   }
 }
@@ -61,9 +83,7 @@ export class GrpcServiceParameters extends OperationsTransportParameters {
  *
  * @WebdaModda
  */
-export class GrpcService<
-  T extends GrpcServiceParameters = GrpcServiceParameters
-> extends OperationsTransport<T> {
+export class GrpcService<T extends GrpcServiceParameters = GrpcServiceParameters> extends OperationsTransport<T> {
   /** Loaded protobuf definitions */
   private definitions: protoLoader.PackageDefinition;
   /** Map of gRPC path → operation ID */
@@ -71,6 +91,14 @@ export class GrpcService<
   /** Map of gRPC path → method definition */
   private rpcMethods: Map<string, protoLoader.MethodDefinition<any, any>> = new Map();
 
+  /**
+   * @param params - raw service parameters
+   * @returns the loaded parameters (with the operations include/exclude filter)
+   */
+  static createConfiguration(params: any = {}): GrpcServiceParameters {
+    return new GrpcServiceParameters().load(params);
+  }
+
   /**
    * Generate a .proto file from the current operation registry.
    *
@@ -124,6 +152,35 @@ export class GrpcService<
     return prefixes.size;
   }
 
+  /**
+   * Load the .proto file and map its RPC methods to operations (also callable after registering operations late)
+   */
+  loadDefinitions(): void {
+    const protoFile = this.parameters.protoFile;
+    if (!existsSync(protoFile)) {
+      useLog("WARN", `Proto file not found: ${this.parameters.protoFile}. Run 'webdac build' to generate it.`);
+      return;
+    }
+    try {
+      this.definitions = protoLoader.loadSync(protoFile, {
+        keepCase: true,
+        longs: String,
+        enums: String,
+        defaults: true,
+        oneofs: true
+      });
+      this.rpcToOperation.clear();
+      this.rpcMethods.clear();
+      this.buildRpcMap();
+      useLog(
+        "INFO",
+        `Loaded gRPC definitions from ${this.parameters.protoFile} — ${this.rpcToOperation.size} RPC methods mapped`
+      );
+    } catch (err: any) {
+      useLog("WARN", `Failed to load proto file: ${err.message}`);
+    }
+  }
+
   /**
    * Initialize the gRPC transport: load proto, build RPC map, hook into HTTP/2.
    * @returns a promise resolving to this service instance once initialization is complete
@@ -131,30 +188,7 @@ export class GrpcService<
   async init(): Promise<this> {
     await super.init();
 
-    // Load proto file if it exists
-    if (existsSync(this.parameters.protoFile)) {
-      try {
-        this.definitions = protoLoader.loadSync(this.parameters.protoFile, {
-          keepCase: true,
-          longs: String,
-          enums: String,
-          defaults: true,
-          oneofs: true
-        });
-        this.buildRpcMap();
-        useLog(
-          "INFO",
-          `Loaded gRPC definitions from ${this.parameters.protoFile} — ${this.rpcToOperation.size} RPC methods mapped`
-        );
-      } catch (err: any) {
-        useLog("WARN", `Failed to load proto file: ${err.message}`);
-      }
-    } else {
-      useLog(
-        "WARN",
-        `Proto file not found: ${this.parameters.protoFile}. Run 'webdac build' to generate it.`
-      );
-    }
+    this.loadDefinitions();
 
     // Plug the gRPC dispatcher into every HttpServer instance in the app.
     // Serving both REST (HTTP/1.1 or TLS+ALPN) and plaintext gRPC (h2c) means
@@ -226,7 +260,21 @@ export class GrpcService<
   }
 
   /**
-   * Handle an incoming gRPC request.
+   * The request line and metadata of a gRPC call as an HttpContext (HTTP/2 pseudo-headers removed)
+   * @param req - the HTTP/2 request
+   * @returns the http context
+   */
+  private httpContextOf(req: IncomingMessage): HttpContext {
+    const raw = req.headers as Record<string, string | string[]>;
+    const authority = (raw[":authority"] as string) || (raw.host as string) || "localhost";
+    const [hostname, port] = authority.split(":");
+    const headers = Object.fromEntries(Object.entries(raw).filter(([key]) => !key.startsWith(":")));
+    return new HttpContext(hostname, "POST", req.url || "/", "http", port || "80", headers as any);
+  }
+
+  /**
+   * Handle an incoming gRPC request: one path for the four modes. Incoming messages feed the operation (as its
+   * input, or as the stream in `operationInputStream`), streamed output is sent as it is produced.
    *
    * Called by the HttpServer when content-type is application/grpc.
    *
@@ -235,7 +283,7 @@ export class GrpcService<
    * @returns a promise that resolves when the response has been fully sent
    */
   async handleGrpcRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
-    const grpcPath = req.url;
+    const grpcPath = req.url ?? "";
     const opId = this.rpcToOperation.get(grpcPath);
     const methodDef = this.rpcMethods.get(grpcPath);
 
@@ -250,179 +298,101 @@ export class GrpcService<
     }
 
     const stream = new GrpcStream(req, res, methodDef);
-    const operation = this.getOperations()[opId];
-    const grpc = operation?.grpc;
-    const streaming = (typeof grpc === "object" && grpc ? grpc.streaming : undefined) || "none";
+    const streaming = getOperationStreaming(this.getOperations()[opId]);
+    const ctx = new GrpcOperationContext(this.httpContextOf(req), stream, res);
+    const input = new AsyncQueue<unknown>();
+    // Handlers first: data may arrive while the session loads
+    stream.onMessage((message, size) => {
+      input.push(this.cleanMessage(message), size);
+      const bytes = input.pendingBytes > this.parameters.maxQueuedBytes;
+      if ((bytes || input.pending > this.parameters.maxQueuedMessages) && !finished()) {
+        // The operation does not keep up: stop it rather than buffering without limit
+        stream.sendError(GrpcStatus.RESOURCE_EXHAUSTED, bytes ? "Too many queued bytes" : "Too many queued messages");
+        ctx.cancel();
+        input.end(true);
+      }
+    });
+    stream.onEnd(() => input.end());
+    stream.onCancel(() => {
+      ctx.cancel();
+      input.end();
+    });
+    // Whatever ends the response (client gone, or the stream failing on a bad frame): stop the operation
+    res.on("close", () => {
+      ctx.cancel();
+      input.end();
+    });
+    // The stream may fail itself (bad frame, ...): it then ends the response, nothing more must be written
+    const finished = () => ctx.isCancelled || (res as any).writableEnded;
 
     try {
-      if (streaming === "bidi" || streaming === "client") {
-        // Client/bidi streaming — collect messages and process
-        await this.handleStreamingRequest(stream, opId, streaming);
-      } else if (streaming === "server") {
-        // Server streaming — single request, stream responses
-        await this.handleServerStreaming(stream, opId, methodDef);
+      await ctx.init();
+      const allowed = await runWithContext(ctx, async () => {
+        try {
+          emitCoreEvent("Webda.Request", { context: ctx });
+        } catch {
+          // listener error
+        }
+        return useRouter().checkRequest(ctx);
+      });
+      if (!allowed) {
+        if (!finished()) stream.sendError(GrpcStatus.PERMISSION_DENIED, "Forbidden");
+        return;
+      }
+      if (streaming === "client" || streaming === "bidi") {
+        ctx.setExtension("operationInputStream", input);
+      } else {
+        const first = await input.next();
+        if (finished()) return;
+        ctx.setMessage(first.done ? {} : first.value);
+      }
+      if (finished()) return;
+      await callOperation(ctx, opId);
+      if (finished()) return;
+      if (ctx.getExtension("operationStreaming")) {
+        stream.end(GrpcStatus.OK);
       } else {
-        // Unary — single request, single response
-        await this.handleUnary(stream, opId, methodDef);
+        stream.sendUnary(this.unaryResponse(ctx.getOutput()));
       }
-    } catch (err) {
-      const status = this.errorToGrpcStatus(err);
-      stream.sendError(status, err.message || "Internal error");
+    } catch (err: any) {
+      if (finished()) return;
+      if (err instanceof WebdaError.OperationCancelledError) {
+        // Raised by the operation itself while the client is still there
+        stream.sendError(GrpcStatus.CANCELLED, err.message || "Operation cancelled");
+        return;
+      }
+      if (!(err?.getResponseCode?.() < 500)) useLog("ERROR", `[gRPC ${opId}] handler threw:`, err);
+      // Only client errors (4xx) carry their message: anything else may leak internals
+      const code = err?.getResponseCode?.();
+      const visible = typeof code === "number" && code >= 400 && code < 500;
+      stream.sendError(this.errorToGrpcStatus(err), visible ? err.message || "Bad request" : "Internal server error");
     }
   }
 
   /**
-   * Handle a unary gRPC call (single request → single response).
-   * @param stream - the active GrpcStream for this request
-   * @param opId - the Webda operation ID to invoke
-   * @param methodDef - the protobuf method definition with serializer functions
-   * @returns a promise that resolves when the unary response has been sent
-   */
-  private handleUnary(
-    stream: GrpcStream,
-    opId: string,
-    methodDef: protoLoader.MethodDefinition<any, any>
-  ): Promise<void> {
-    // AsyncLocalStorage doesn't always propagate through the HTTP/2 'data'
-    // event that drives GrpcStream.onMessage, so capture the storage here and
-    // re-enter it inside the callback.
-    const instanceStorage = useInstanceStorage();
-    return new Promise<void>((resolve, reject) => {
-      stream.onMessage(message => {
-        runWithInstanceStorage(instanceStorage, async () => {
-          try {
-            const ctx = new SimpleOperationContext();
-            await ctx.init();
-            // Proto3 `optional` fields deserialize with an extra `_field: "field"`
-            // marker (synthetic oneof tracking). Drop those so the payload matches
-            // the backing JSON schema which forbids additional properties.
-            const cleaned =
-              typeof message === "object" && message !== null && !Array.isArray(message)
-                ? Object.fromEntries(Object.entries(message).filter(([k]) => !k.startsWith("_")))
-                : message;
-            ctx.setInput(Buffer.from(JSON.stringify(cleaned)));
-            await callOperation(ctx, opId);
-            const output = ctx.getOutput();
-            // Operation return values may be plain strings/numbers (e.g. version
-            // strings, publish ids). Wrap them in a `{value: ...}` object so the
-            // proto response is always a valid message shape.
-            let response: any = {};
-            if (output !== undefined && output !== null && output !== "") {
-              try {
-                response = JSON.parse(output);
-                if (typeof response !== "object" || response === null) {
-                  response = { value: response };
-                }
-              } catch {
-                response = { value: output };
-              }
-            }
-            stream.sendUnary(response);
-            resolve();
-          } catch (err: any) {
-            useLog("ERROR", `[gRPC ${opId}] handler threw:`, err);
-            const status = this.errorToGrpcStatus(err);
-            stream.sendError(status, err.message);
-            resolve(); // Don't reject — error was sent via gRPC status
-          }
-        });
-      });
-    });
-  }
-
-  /**
-   * Handle server streaming (single request → stream of responses).
-   * Maps to AsyncGenerator operations.
-   * @param stream - the active GrpcStream for this request
-   * @param opId - the Webda operation ID to invoke
-   * @param methodDef - the protobuf method definition with serializer functions
-   * @returns a promise that resolves when all response frames have been sent
+   * Proto3 `optional` fields deserialize with an extra `_field: "field"` marker (synthetic oneof tracking): drop
+   * those so the payload matches the backing JSON schema
+   * @param message - decoded message
+   * @returns the message without markers
    */
-  private handleServerStreaming(
-    stream: GrpcStream,
-    opId: string,
-    methodDef: protoLoader.MethodDefinition<any, any>
-  ): Promise<void> {
-    return new Promise<void>((resolve, reject) => {
-      stream.onMessage(async message => {
-        try {
-          const ctx = new SimpleOperationContext();
-          await ctx.init();
-          ctx.setInput(Buffer.from(JSON.stringify(message)));
-          await callOperation(ctx, opId);
-          // callOperation writes chunks to ctx for AsyncGenerators
-          // For now, send the full output as a single response
-          const output = ctx.getOutput();
-          if (output) {
-            // Try to parse as NDJSON (multiple JSON objects)
-            const lines = output.split("\n").filter(Boolean);
-            for (const line of lines) {
-              try {
-                stream.send(JSON.parse(line));
-              } catch {
-                stream.send({ data: line });
-              }
-            }
-          }
-          stream.end(GrpcStatus.OK);
-          resolve();
-        } catch (err: any) {
-          const status = this.errorToGrpcStatus(err);
-          stream.sendError(status, err.message);
-          resolve();
-        }
-      });
-    });
+  private cleanMessage(message: unknown): unknown {
+    return typeof message === "object" && message !== null && !Array.isArray(message)
+      ? Object.fromEntries(Object.entries(message).filter(([key]) => !key.startsWith("_")))
+      : message;
   }
 
   /**
-   * Handle client or bidirectional streaming.
-   * @param stream - the active GrpcStream for this request
-   * @param opId - the Webda operation ID to invoke
-   * @param streaming - streaming mode, either "client" or "bidi"
-   * @returns a promise that resolves when the operation completes and the response is sent
+   * The unary response for an operation output (a plain string/number is wrapped as `{ value }`)
+   * @param output - the context output
+   * @returns the response message
    */
-  private handleStreamingRequest(
-    stream: GrpcStream,
-    opId: string,
-    streaming: string
-  ): Promise<void> {
-    return new Promise<void>((resolve) => {
-      const messages: any[] = [];
-
-      stream.onMessage(message => {
-        messages.push(message);
-      });
-
-      stream.onEnd(async () => {
-        try {
-          // For client streaming: process all collected messages
-          const ctx = new SimpleOperationContext();
-          await ctx.init();
-          ctx.setInput(Buffer.from(JSON.stringify(messages)));
-          await callOperation(ctx, opId);
-          const output = ctx.getOutput();
-          const response = output ? JSON.parse(output) : {};
-
-          if (streaming === "bidi") {
-            // Bidi: send response for each input message
-            stream.send(response);
-          } else {
-            // Client streaming: single response
-            stream.sendUnary(response);
-          }
-          resolve();
-        } catch (err: any) {
-          const status = this.errorToGrpcStatus(err);
-          stream.sendError(status, err.message);
-          resolve();
-        }
-      });
-
-      stream.onCancel(() => {
-        resolve();
-      });
-    });
+  private unaryResponse(output: string | undefined): Record<string, unknown> {
+    if (output === undefined || output === null || output === "") return {};
+    try {
+      return toGrpcMessage(JSON.parse(output));
+    } catch {
+      return { value: output };
+    }
   }
 
   /**