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

package/test/fixture.ts

@@ -0,0 +1,166 @@
+import {
+  Service,
+  ServiceParameters,
+  WebContext,
+  WebdaError,
+  registerOperation,
+  registerSchema,
+  useApplication,
+  useContext
+} from "@webda/core";
+
+/** Observations of the fixture's generators. */
+export const fixtureState = {
+  connectClosed: false,
+  ticksClosed: false,
+  floodClosed: false,
+  echoCalls: 0,
+  release: undefined as undefined | (() => void),
+  /** Lets Fixture.Ticks yield past its first tick */
+  open() {
+    this.release?.();
+  }
+};
+
+/** Header of the current call, through the operation context */
+const authorization = () => useContext<WebContext>().getHttpContext()?.getUniqueHeader("authorization") ?? "none";
+
+/** Streaming operations for the transport tests. */
+export class GrpcFixtureService extends Service {
+  /**
+   * @param params - raw parameters
+   * @returns parameters
+   */
+  loadParameters(params: any): ServiceParameters {
+    return new ServiceParameters().load(params);
+  }
+
+  /**
+   * @param text - text to echo
+   * @returns the text
+   */
+  echo(text: string) {
+    fixtureState.echoCalls++;
+    if (text === "boom") throw new WebdaError.NotFound("Nothing to echo");
+    return { text, authorization: authorization() };
+  }
+
+  /**
+   * An operation failing with an internal error whose message must not leave the server
+   * @param _text - unused
+   * @returns never
+   */
+  leak(_text: string): { text: string } {
+    throw new Error("secret database password");
+  }
+
+  /**
+   * Bidirectional operation that never reads its input and keeps producing until it is cancelled
+   * @param _frames - incoming frames, ignored
+   * @returns outgoing frames
+   */
+  async *flood(_frames: AsyncIterable<{ frame: string }>) {
+    try {
+      for (;;) {
+        yield { frame: "tick" };
+        await new Promise(resolve => setTimeout(resolve, 20));
+      }
+    } finally {
+      fixtureState.floodClosed = true;
+    }
+  }
+
+  /**
+   * An operation that raises a cancellation itself, the client being still there
+   * @param _text - unused
+   * @returns never
+   */
+  abort(_text: string): { text: string } {
+    throw new WebdaError.OperationCancelledError();
+  }
+
+  /**
+   * Server stream gated after the first tick
+   * @param n - ticks
+   * @returns the ticks
+   */
+  async *ticks(n: number) {
+    try {
+      yield { index: 1 };
+      await new Promise<void>(resolve => (fixtureState.release = resolve));
+      for (let index = 2; index <= n; index++) yield { index };
+    } finally {
+      fixtureState.ticksClosed = true;
+    }
+  }
+
+  /**
+   * Client stream
+   * @param values - the values
+   * @returns their sum
+   */
+  async sum(values: AsyncIterable<{ value: number }>) {
+    let total = 0;
+    for await (const v of values) total += v.value;
+    return { total };
+  }
+
+  /**
+   * Bidirectional: greets with the caller's authorization header, then echoes every frame
+   * @param frames - incoming frames
+   * @returns outgoing frames
+   */
+  async *connect(frames: AsyncIterable<{ frame: string }>) {
+    try {
+      yield { frame: `hello ${authorization()}` };
+      for await (const f of frames) {
+        if (f.frame === "fail") throw new WebdaError.NotFound("No such frame");
+        if (f.frame === "bye") return;
+        yield { frame: `echo ${f.frame} ${authorization()}` };
+      }
+    } finally {
+      fixtureState.connectClosed = true;
+    }
+  }
+}
+
+const schema = (name: string, value: any) => {
+  useApplication().getSchemas()[name] = value;
+  try {
+    registerSchema(name, value);
+  } catch {
+    // registered by a previous test
+  }
+};
+
+/** Registers the fixture's schemas and operations (call once the app is up). */
+export function registerGrpcFixture(): void {
+  const envelope = { type: "object", properties: { frame: { type: "string" } }, required: ["frame"] };
+  schema("Fixture.Echo.input", { type: "object", properties: { text: { type: "string" } }, required: ["text"] });
+  schema("Fixture.Echo.output", {
+    type: "object",
+    properties: { text: { type: "string" }, authorization: { type: "string" } }
+  });
+  schema("Fixture.Ticks.input", { type: "object", properties: { n: { type: "number" } }, required: ["n"] });
+  schema("Fixture.Tick", { type: "object", properties: { index: { type: "number" } }, "x-webda-stream": true });
+  schema("Fixture.Value", {
+    type: "object",
+    properties: { value: { type: "number" } },
+    required: ["value"],
+    "x-webda-stream": true
+  });
+  schema("Fixture.Total", { type: "object", properties: { total: { type: "number" } } });
+  schema("Fixture.Frame", { ...envelope, "x-webda-stream": true });
+  schema("Fixture.FrameOut", { ...envelope, "x-webda-stream": true });
+  const op = (id: string, method: string, extra: any) =>
+    registerOperation(id, { service: "Fixture", method, ...extra });
+  op("Fixture.Echo", "echo", { input: "Fixture.Echo.input", output: "Fixture.Echo.output" });
+  op("Fixture.Leak", "leak", { input: "Fixture.Echo.input", output: "Fixture.Echo.output" });
+  op("Fixture.Flood", "flood", { input: "Fixture.Frame", output: "Fixture.FrameOut" });
+  op("Fixture.Abort", "abort", { input: "Fixture.Echo.input", output: "Fixture.Echo.output" });
+  op("Fixture.Ticks", "ticks", { input: "Fixture.Ticks.input", output: "Fixture.Tick" });
+  op("Fixture.Sum", "sum", { input: "Fixture.Value", output: "Fixture.Total" });
+  op("Fixture.Connect", "connect", { input: "Fixture.Frame", output: "Fixture.FrameOut" });
+}
+
+export const GRPC_FIXTURE_SERVICES = { Fixture: { type: "Webda/GrpcFixtureService" } };

package/webda.module.json

@@ -10,6 +10,16 @@
         "additionalProperties": false,
         "description": "Parameters for the gRPC service",
         "properties": {
+          "maxQueuedBytes": {
+            "default": 16777216,
+            "description": "Most bytes of unconsumed messages a client or bidirectional operation may have queued; above it the call fails\nwith RESOURCE_EXHAUSTED",
+            "type": "number"
+          },
+          "maxQueuedMessages": {
+            "default": 1000,
+            "description": "Most unconsumed messages a client or bidirectional operation may have queued; above it the call fails with\nRESOURCE_EXHAUSTED",
+            "type": "number"
+          },
           "operations": {
             "default": [
               "*"