ts-proto 2.18.2 → 2.18.3

package/build/src/generate-grpc-web.js

@@ -300,6 +300,9 @@ function createObservableUnaryMethod(ctx) {
 function createInvokeMethod(ctx) {
     const { options } = ctx;
     const { useAbortSignal } = options;
+    if (options.useAsyncIterable) {
+        return createAsyncIterableInvokeMethod(ctx);
+    }
     return (0, ts_poet_1.code) `
     invoke<T extends UnaryMethodDefinitionish>(
       methodDesc: T,
@@ -363,3 +366,121 @@ function createInvokeMethod(ctx) {
     }
   `;
 }
+/** Creates the streaming `invoke` method for `useAsyncIterable=true`, which returns an async generator. */
+function createAsyncIterableInvokeMethod(ctx) {
+    const { useAbortSignal } = ctx.options;
+    return (0, ts_poet_1.code) `
+    invoke<T extends UnaryMethodDefinitionish>(
+      methodDesc: T,
+      _request: any,
+      metadata: grpc.Metadata | undefined,
+      ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
+    ): AsyncIterable<any> {
+      const upStreamCodes = this.options.upStreamRetryCodes ?? [];
+      const DEFAULT_TIMEOUT_TIME: number = 3_000;
+      const request = { ..._request, ...methodDesc.requestType };
+      const transport = this.options.streamingTransport ?? this.options.transport;
+      const maybeCombinedMetadata = metadata && this.options.metadata
+        ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
+        : metadata ?? this.options.metadata;
+      const host = this.host;
+      const debug = this.options.debug ?? false;
+      return (async function* () {
+        ${useAbortSignal
+        ? `
+        // A listener added after the abort would never run.
+        if (abortSignal?.aborted) {
+          throw abortSignal.reason;
+        }
+        `
+        : ""}
+        const queue: any[] = [];
+        let done = false;
+        let error: unknown = undefined;
+        ${useAbortSignal ? "let aborted = false;" : ""}
+        let wake: (() => void) | undefined;
+        const notify = () => {
+          const resolve = wake;
+          wake = undefined;
+          resolve?.();
+        };
+        let client: { close(): void } | undefined;
+        let retryTimer: ReturnType<typeof setTimeout> | undefined;
+        let closed = false;
+        // Stops the retry timer and closes the active call, at most once.
+        const close = () => {
+          closed = true;
+          clearTimeout(retryTimer);
+          retryTimer = undefined;
+          const active = client;
+          client = undefined;
+          active?.close();
+        };
+        const upStream = () => {
+          retryTimer = undefined;
+          if (closed) {
+            return;
+          }
+          client = ${grpc}.invoke(methodDesc, {
+            host,
+            request,
+            ...(transport !== undefined ? {transport} : {}),
+            metadata: maybeCombinedMetadata ?? {},
+            debug,
+            onMessage: (next) => {
+              queue.push(next);
+              notify();
+            },
+            onEnd: (code: ${grpc}.Code, message: string, trailers: ${grpc}.Metadata) => {
+              if (code === 0) {
+                done = true;
+              } else if (upStreamCodes.includes(code)) {
+                retryTimer = setTimeout(upStream, DEFAULT_TIMEOUT_TIME);
+                return;
+              } else {
+                const err = new Error(message) as any;
+                err.code = code;
+                err.metadata = trailers;
+                error = err;
+                done = true;
+              }
+              notify();
+            },
+          });
+        };
+        ${useAbortSignal
+        ? `
+        const abort = () => {
+          aborted = true;
+          error = abortSignal!.reason;
+          done = true;
+          close();
+          notify();
+        };
+        abortSignal?.addEventListener("abort", abort);
+        `
+        : ""}
+        upStream();
+        try {
+          while (true) {
+            if (${useAbortSignal ? "!aborted && " : ""}queue.length > 0) {
+              yield queue.shift();
+            } else if (done) {
+              break;
+            } else {
+              await new Promise<void>((resolve) => {
+                wake = resolve;
+              });
+            }
+          }
+          if (error !== undefined) {
+            throw error;
+          }
+        } finally {
+          ${useAbortSignal ? `abortSignal?.removeEventListener("abort", abort);` : ""}
+          close();
+        }
+      })();
+    }
+  `;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "2.18.2",
+  "version": "2.18.3",
   "description": "",
   "main": "build/src/plugin.js",
   "repository": "github:stephenh/ts-proto",