starpc 0.4.9 → 0.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.4.9",
+  "version": "0.5.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -35,14 +35,16 @@
   "scripts": {
     "build": "rimraf ./dist && tsc --project tsconfig.build.json --outDir ./dist/",
     "check": "tsc",
-    "deps": "depcheck",
+    "deps": "depcheck --ignores 'bufferutil,utf-8-validate'",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
     "format": "prettier --write './{srpc,echo,e2e,integration,rpcstream}/**/(*.ts|*.tsx|*.html|*.css)'",
     "gen": "make genproto",
     "test": "npm run test:js && npm run test:go",
     "test:go": "make test",
-    "test:js": "npm run build && cd e2e && esbuild e2e.ts --sourcemap --outfile=e2e.js --bundle --platform=node && node ./e2e.js",
+    "build:e2e": "npm run build && cd e2e && esbuild e2e.ts --sourcemap --outfile=e2e.js --bundle --platform=node",
+    "test:js": "npm run build:e2e && cd e2e && node ./e2e.js",
+    "debug:js": "npm run build:e2e && cd e2e && node --inspect --inspect-brk ./e2e.js",
     "test:integration": "make integration",
     "integration": "npm run test:integration",
     "lint": "npm run lint:go && npm run lint:js",
@@ -56,16 +58,18 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.30.0",
-    "@typescript-eslint/parser": "^5.30.0",
+    "@typescript-eslint/eslint-plugin": "^5.30.3",
+    "@typescript-eslint/parser": "^5.30.3",
+    "bufferutil": "^4.0.6",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.14.47",
+    "esbuild": "^0.14.48",
     "eslint": "^8.18.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.115.5",
-    "typescript": "^4.7.4"
+    "ts-proto": "^1.116.0",
+    "typescript": "^4.7.4",
+    "utf-8-validate": "^5.0.9"
   },
   "dependencies": {
     "@libp2p/interface-connection": "^2.1.1",
@@ -73,6 +77,7 @@
     "@libp2p/mplex": "^4.0.0",
     "event-iterator": "^2.0.0",
     "isomorphic-ws": "^5.0.0",
+    "it-first": "^1.0.7",
     "it-length-prefixed": "^7.0.1",
     "it-pipe": "^2.0.3",
     "it-pushable": "^3.0.0",
@@ -81,7 +86,6 @@
     "long": "^5.2.0",
     "patch-package": "^6.4.7",
     "protobufjs": "^6.11.3",
-    "rxjs": "^7.5.5",
     "ws": "^8.8.0"
   }
 }

package/patches/{ts-poet+4.14.0.patch → ts-poet+4.15.0.patch}

@@ -1,5 +1,5 @@
 diff --git a/node_modules/ts-poet/build/Import.js b/node_modules/ts-poet/build/Import.js
-index fe1f6d2..280df8f 100644
+index b92bea3..608add9 100644
 --- a/node_modules/ts-poet/build/Import.js
 +++ b/node_modules/ts-poet/build/Import.js
 @@ -293,6 +293,14 @@ function emitImports(imports, ourModulePath, importMappings) {

package/patches/ts-proto+1.116.0.patch

@@ -0,0 +1,14 @@
+diff --git a/node_modules/ts-proto/build/utils.js b/node_modules/ts-proto/build/utils.js
+index 2148e97..e19b35f 100644
+--- a/node_modules/ts-proto/build/utils.js
++++ b/node_modules/ts-proto/build/utils.js
+@@ -170,7 +170,8 @@ function getPropertyAccessor(objectName, propertyName, optional = false) {
+ }
+ exports.getPropertyAccessor = getPropertyAccessor;
+ function impProto(options, module, type) {
+-    const importString = `${type}@./${module}${options.fileSuffix}`;
++    // NOTE: TypeScript resolves importing foo.js to importing foo.ts.
++    const importString = `${type}@./${module}${options.fileSuffix}.js`;
+     if (options.onlyTypes) {
+         return (0, ts_poet_1.imp)('t:' + importString);
+     }

package/srpc/client.ts

@@ -1,10 +1,10 @@
 import { pipe } from 'it-pipe'
 import { pushable, Pushable } from 'it-pushable'
-import { Observable, from as observableFrom } from 'rxjs'
 
 import type { TsProtoRpc } from './ts-proto-rpc.js'
 import type { OpenStreamFunc } from './stream.js'
 import { ClientRPC } from './client-rpc.js'
+import { writeToPushable } from './pushable.js'
 import {
   decodePacketSource,
   encodePacketSource,
@@ -12,21 +12,6 @@ import {
   prependLengthPrefixTransform,
 } from './packet.js'
 
-// writeClientStream registers the subscriber to write the client data stream.
-function writeClientStream(call: ClientRPC, data: Observable<Uint8Array>) {
-  data.subscribe({
-    next(value) {
-      call.writeCallData(value)
-    },
-    error(err) {
-      call.close(err)
-    },
-    complete() {
-      call.writeCallData(undefined, true)
-    },
-  })
-}
-
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client implements TsProtoRpc {
   // openStreamFn is a promise which contains the OpenStreamFunc.
@@ -92,10 +77,10 @@ export class Client implements TsProtoRpc {
   public async clientStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
   ): Promise<Uint8Array> {
     const call = await this.startRpc(service, method, null)
-    writeClientStream(call, data)
+    call.writeCallDataFromSource(data)
     for await (const data of call.rpcDataSource) {
       call.close()
       return data
@@ -110,21 +95,13 @@ export class Client implements TsProtoRpc {
     service: string,
     method: string,
     data: Uint8Array
-  ): Observable<Uint8Array> {
-    const pushServerData: Pushable<Uint8Array> = pushable({ objectMode: true })
-    const serverData = observableFrom(pushServerData)
+  ): AsyncIterable<Uint8Array> {
+    const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
     this.startRpc(service, method, data)
       .then(async (call) => {
-        try {
-          for await (const data of call.rpcDataSource) {
-            pushServerData.push(data)
-          }
-        } catch (err) {
-          pushServerData.throw(err as Error)
-        }
-        pushServerData.end()
+        return writeToPushable(call.rpcDataSource, serverData)
       })
-      .catch(pushServerData.throw.bind(pushServerData))
+      .catch(serverData.throw.bind(serverData))
     return serverData
   }
 
@@ -132,33 +109,22 @@ export class Client implements TsProtoRpc {
   public bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
-  ): Observable<Uint8Array> {
-    const pushServerData: Pushable<Uint8Array> = pushable({ objectMode: true })
-    const serverData = observableFrom(pushServerData)
+    data: AsyncIterable<Uint8Array>
+  ): AsyncIterable<Uint8Array> {
+    const serverData: Pushable<Uint8Array> = pushable({ objectMode: true })
     this.startRpc(service, method, null)
       .then(async (call) => {
+        call.writeCallDataFromSource(data)
         try {
-          data.subscribe({
-            next(value) {
-              call.writeCallData(value)
-            },
-            error(err) {
-              call.close(err)
-            },
-            complete() {
-              call.close()
-            },
-          })
-          for await (const data of call.rpcDataSource) {
-            pushServerData.push(data)
+          for await (const message of call.rpcDataSource) {
+            serverData.push(message)
           }
         } catch (err) {
-          pushServerData.throw(err as Error)
+          serverData.throw(err as Error)
         }
-        pushServerData.end()
+        serverData.end()
       })
-      .catch(pushServerData.throw.bind(pushServerData))
+      .catch(serverData.throw.bind(serverData))
     return serverData
   }
 

package/srpc/common-rpc.ts

@@ -1,4 +1,4 @@
-import type { Source, Sink } from 'it-stream-types'
+import type { Sink } from 'it-stream-types'
 import { pushable } from 'it-pushable'
 
 import type { CallData, CallStart } from './rpcproto.pb.js'
@@ -16,7 +16,7 @@ export class CommonRPC {
     end: (err?: Error) => void
   }
   // rpcDataSource emits incoming client RPC messages to the caller.
-  public readonly rpcDataSource: Source<Uint8Array>
+  public readonly rpcDataSource: AsyncIterable<Uint8Array>
   // _rpcDataSource is used to write to the rpc message source.
   private readonly _rpcDataSource: {
     push: (val: Uint8Array) => void
@@ -60,6 +60,18 @@ export class CommonRPC {
     })
   }
 
+  // writeCallDataFromSource writes all call data from the iterable.
+  public async writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>) {
+    try {
+      for await (const data of dataSource) {
+        this.writeCallData(data)
+      }
+      this.writeCallData(undefined, true)
+    } catch (err) {
+      this.close(err as Error)
+    }
+  }
+
   // writePacket writes a packet to the stream.
   protected async writePacket(packet: Packet) {
     this._source.push(packet)

package/srpc/definition.ts

@@ -15,16 +15,16 @@ export interface Definition {
 
 // MethodDefinition describes the method definitions generated by ts-proto.
 // use --ts_proto_opt=outputServices=default,outputServices=generic-definitions
-export interface MethodDefinition<RequestType, ResponseType> {
+export interface MethodDefinition<RequestT, ResponseT> {
   // name is the name and function name of the method.
   // e.x.: Echo
   name: string
   // requestType is the object used for the request.
-  requestType: MessageDefinition<RequestType>
+  requestType: MessageDefinition<RequestT>
   // requestStream indicates the request is a stream.
   requestStream: boolean
   // responseType is the object used for the response.
-  responseType: MessageDefinition<ResponseType>
+  responseType: MessageDefinition<ResponseT>
   // responseStream indicates the response is a stream.
   responseStream: boolean
 }

package/srpc/handler.ts

@@ -1,13 +1,13 @@
 import type { Sink, Source } from 'it-stream-types'
 import { pipe } from 'it-pipe'
 import { pushable } from 'it-pushable'
-import { Observable, from as observableFrom } from 'rxjs'
 
 import { Definition, MethodDefinition } from './definition.js'
 import {
   buildDecodeMessageTransform,
   buildEncodeMessageTransform,
 } from './message.js'
+import { writeToPushable } from './pushable.js'
 
 // InvokeFn describes an SRPC call method invoke function.
 export type InvokeFn = (
@@ -65,21 +65,21 @@ export class StaticHandler implements Handler {
 }
 
 // MethodProto is a function which matches one of the RPC signatures.
-type MethodProto =
-  | ((request: unknown) => Promise<unknown>)
-  | ((request: unknown) => Observable<unknown>)
-  | ((request: Observable<unknown>) => Promise<unknown>)
-  | ((request: Observable<unknown>) => Observable<unknown>)
+type MethodProto<R, O> =
+  | ((request: R) => Promise<O>)
+  | ((request: R) => AsyncIterable<O>)
+  | ((request: AsyncIterable<R>) => Promise<O>)
+  | ((request: AsyncIterable<R>) => AsyncIterable<O>)
 
 // createInvokeFn builds an InvokeFn from a method definition and a function prototype.
-export function createInvokeFn(
-  methodInfo: MethodDefinition<unknown, unknown>,
-  methodProto: MethodProto
+export function createInvokeFn<R, O>(
+  methodInfo: MethodDefinition<R, O>,
+  methodProto: MethodProto<R, O>
 ): InvokeFn {
-  const requestDecode = buildDecodeMessageTransform(methodInfo.requestType)
+  const requestDecode = buildDecodeMessageTransform<R>(methodInfo.requestType)
   return async (dataSource: Source<Uint8Array>, dataSink: Sink<Uint8Array>) => {
     // responseSink is a Sink for response messages.
-    const responseSink = pushable<unknown>({
+    const responseSink = pushable<O>({
       objectMode: true,
     })
 
@@ -96,8 +96,8 @@ export function createInvokeFn(
     // build the request argument.
     let requestArg: any
     if (methodInfo.requestStream) {
-      // convert the request data source into an Observable<T>
-      requestArg = observableFrom(requestSource)
+      // use the request source as the argument.
+      requestArg = requestSource
     } else {
       // receive a single message for the argument.
       for await (const msg of requestSource) {
@@ -119,27 +119,10 @@ export function createInvokeFn(
         throw new Error('return value was undefined')
       }
       if (methodInfo.responseStream) {
-        const responseObs = responseObj as Observable<unknown>
-        if (!responseObs.subscribe) {
-          throw new Error('expected return value to be an Observable')
-        }
-        return new Promise<void>((resolve, reject) => {
-          responseObs.subscribe({
-            next(value) {
-              responseSink.push(value)
-            },
-            error: (err: any) => {
-              responseSink.throw(err)
-              reject(err)
-            },
-            complete: () => {
-              responseSink.end()
-              resolve()
-            },
-          })
-        })
+        const response = responseObj as AsyncIterable<O>
+        return writeToPushable(response, responseSink)
       } else {
-        const responsePromise = responseObj as Promise<unknown>
+        const responsePromise = responseObj as Promise<O>
         if (!responsePromise.then) {
           throw new Error('expected return value to be a Promise')
         }
@@ -166,7 +149,7 @@ export function createHandler(definition: Definition, impl: any): Handler {
   const methodMap: MethodMap = {}
   for (const methodInfo of Object.values(definition.methods)) {
     const methodName = methodInfo.name
-    let methodProto: MethodProto = impl[methodName]
+    let methodProto: MethodProto<unknown, unknown> = impl[methodName]
     if (!methodProto) {
       continue
     }

package/srpc/index.ts

@@ -4,7 +4,7 @@ export { Server } from './server.js'
 export { Conn, ConnParams } from './conn.js'
 export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js'
 export { Packet, CallStart, CallData } from './rpcproto.pb.js'
-export { Mux, createMux } from './mux.js'
+export { Mux, StaticMux, createMux } from './mux.js'
 export {
   BroadcastChannelDuplex,
   newBroadcastChannelDuplex,
@@ -15,4 +15,4 @@ export {
   newMessagePortIterable,
   MessagePortConn,
 } from './message-port.js'
-export { ObservableSource } from './observable-source.js'
+export { writeToPushable } from './pushable'

package/srpc/muxed-conn.go

@@ -19,9 +19,9 @@ func NewOpenStreamWithMuxedConn(conn network.MuxedConn) OpenStreamFunc {
 		if err != nil {
 			return nil, err
 		}
-		rw := NewPacketReadWriter(mstrm, msgHandler)
+		rw := NewPacketReadWriter(mstrm)
 		go func() {
-			err := rw.ReadPump()
+			err := rw.ReadPump(msgHandler)
 			if err != nil {
 				_ = rw.Close()
 			}

package/srpc/packet-rw.go

@@ -16,15 +16,13 @@ var maxMessageSize = 1e7
 type PacketReaderWriter struct {
 	// rw is the io.ReadWriterCloser
 	rw io.ReadWriteCloser
-	// cb is the callback
-	cb PacketHandler
 	// buf is the buffered data
 	buf bytes.Buffer
 }
 
 // NewPacketReadWriter constructs a new read/writer.
-func NewPacketReadWriter(rw io.ReadWriteCloser, cb PacketHandler) *PacketReaderWriter {
-	return &PacketReaderWriter{rw: rw, cb: cb}
+func NewPacketReadWriter(rw io.ReadWriteCloser) *PacketReaderWriter {
+	return &PacketReaderWriter{rw: rw}
 }
 
 // WritePacket writes a packet to the writer.
@@ -41,7 +39,7 @@ func (r *PacketReaderWriter) WritePacket(p *Packet) error {
 }
 
 // ReadPump executes the read pump in a goroutine.
-func (r *PacketReaderWriter) ReadPump() error {
+func (r *PacketReaderWriter) ReadPump(cb PacketHandler) error {
 	var currLen uint32
 	buf := make([]byte, 2048)
 	for {
@@ -78,7 +76,7 @@ func (r *PacketReaderWriter) ReadPump() error {
 			if err := npkt.UnmarshalVT(pkt); err != nil {
 				return err
 			}
-			if err := r.cb(npkt); err != nil {
+			if err := cb(npkt); err != nil {
 				return err
 			}
 		}

package/srpc/packet.ts

@@ -88,36 +88,3 @@ export function prependPacketLen(msgData: Uint8Array): Uint8Array {
   merged.set(msgData, msgLenData.length)
   return merged
 }
-
-/*
-// buildCallDataPacket builds a CallData packet.
-function buildCallDataPacket(data: Uint8Array): Packet {
-  const callData: CallData = {
-    data: p,
-    complete: false,
-    error: '',
-  }
-  const pkt: Packet = {
-    body: {
-      $case: 'callData',
-      callData: callData,
-    }
-  }
-  return pkt
-}
-
-// wrapCallDataTransform is a transformer that wraps call data into a Packet.
-export async function* wrapCallDataTransform(
-  source: Source<Uint8Array | Uint8Array>
-): AsyncIterable<Packet> {
-  for await (const pkt of source) {
-    if (Array.isArray(pkt)) {
-      for (const p of pkt) {
-        yield* [buildCallDataPacket(p)]
-      }
-    } else {
-      yield* [buildCallDataPacket(pkt)]
-    }
-  }
-}
-*/

package/srpc/pushable.ts

@@ -0,0 +1,17 @@
+import { Pushable } from 'it-pushable'
+
+// writeToPushable writes the incoming server data to the pushable.
+export async function writeToPushable<T>(
+  dataSource: AsyncIterable<T>,
+  out: Pushable<T>
+) {
+  try {
+    for await (const data of dataSource) {
+      out.push(data)
+    }
+    out.end()
+  } catch (err) {
+    out.end(err as Error)
+    throw err
+  }
+}

package/srpc/rpcproto.pb.ts

@@ -95,6 +95,40 @@ export const Packet = {
     return message
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<Packet, Uint8Array>
+  async *encodeTransform(
+    source: AsyncIterable<Packet | Packet[]> | Iterable<Packet | Packet[]>
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [Packet.encode(p).finish()]
+        }
+      } else {
+        yield* [Packet.encode(pkt).finish()]
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, Packet>
+  async *decodeTransform(
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
+  ): AsyncIterable<Packet> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [Packet.decode(p)]
+        }
+      } else {
+        yield* [Packet.decode(pkt)]
+      }
+    }
+  },
+
   fromJSON(object: any): Packet {
     return {
       body: isSet(object.callStart)
@@ -203,6 +237,42 @@ export const CallStart = {
     return message
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<CallStart, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<CallStart | CallStart[]>
+      | Iterable<CallStart | CallStart[]>
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [CallStart.encode(p).finish()]
+        }
+      } else {
+        yield* [CallStart.encode(pkt).finish()]
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CallStart>
+  async *decodeTransform(
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
+  ): AsyncIterable<CallStart> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [CallStart.decode(p)]
+        }
+      } else {
+        yield* [CallStart.decode(pkt)]
+      }
+    }
+  },
+
   fromJSON(object: any): CallStart {
     return {
       rpcService: isSet(object.rpcService) ? String(object.rpcService) : '',
@@ -294,6 +364,42 @@ export const CallData = {
     return message
   },
 
+  // encodeTransform encodes a source of message objects.
+  // Transform<CallData, Uint8Array>
+  async *encodeTransform(
+    source:
+      | AsyncIterable<CallData | CallData[]>
+      | Iterable<CallData | CallData[]>
+  ): AsyncIterable<Uint8Array> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [CallData.encode(p).finish()]
+        }
+      } else {
+        yield* [CallData.encode(pkt).finish()]
+      }
+    }
+  },
+
+  // decodeTransform decodes a source of encoded messages.
+  // Transform<Uint8Array, CallData>
+  async *decodeTransform(
+    source:
+      | AsyncIterable<Uint8Array | Uint8Array[]>
+      | Iterable<Uint8Array | Uint8Array[]>
+  ): AsyncIterable<CallData> {
+    for await (const pkt of source) {
+      if (Array.isArray(pkt)) {
+        for (const p of pkt) {
+          yield* [CallData.decode(p)]
+        }
+      } else {
+        yield* [CallData.decode(pkt)]
+      }
+    }
+  },
+
   fromJSON(object: any): CallData {
     return {
       data: isSet(object.data)

package/srpc/server-pipe.go

@@ -14,9 +14,9 @@ func NewServerPipe(server *Server) OpenStreamFunc {
 		go func() {
 			_ = server.HandleStream(ctx, srvPipe)
 		}()
-		clientPrw := NewPacketReadWriter(clientPipe, msgHandler)
+		clientPrw := NewPacketReadWriter(clientPipe)
 		go func() {
-			err := clientPrw.ReadPump()
+			err := clientPrw.ReadPump(msgHandler)
 			if err != nil {
 				_ = clientPrw.Close()
 			}

package/srpc/server.go

@@ -30,9 +30,9 @@ func (s *Server) HandleStream(ctx context.Context, rwc io.ReadWriteCloser) error
 	subCtx, subCtxCancel := context.WithCancel(ctx)
 	defer subCtxCancel()
 	serverRPC := NewServerRPC(subCtx, s.mux)
-	prw := NewPacketReadWriter(rwc, serverRPC.HandlePacket)
+	prw := NewPacketReadWriter(rwc)
 	serverRPC.SetWriter(prw)
-	err := prw.ReadPump()
+	err := prw.ReadPump(serverRPC.HandlePacket)
 	_ = rwc.Close()
 	return err
 }

package/srpc/server.ts

@@ -48,6 +48,14 @@ export class Server implements StreamHandler {
     return rpc
   }
 
+  // handlePacketDuplex handles an incoming Uint8Array duplex.
+  // skips the packet length prefix transform.
+  public handlePacketDuplex(stream: Duplex<Uint8Array>): ServerRPC {
+    const rpc = this.startRpc()
+    pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
+    return rpc
+  }
+
   // handlePacketStream handles an incoming Packet duplex.
   public handlePacketStream(stream: Duplex<Packet>): ServerRPC {
     const rpc = this.startRpc()

package/srpc/ts-proto-rpc.ts

@@ -1,5 +1,3 @@
-import type { Observable } from 'rxjs'
-
 // TsProtoRpc matches the Rpc interface generated by ts-proto.
 export interface TsProtoRpc {
   // request fires a one-off unary RPC request.
@@ -12,18 +10,18 @@ export interface TsProtoRpc {
   clientStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
   ): Promise<Uint8Array>
   // serverStreamingRequest fires a one-way server->client streaming request.
   serverStreamingRequest(
     service: string,
     method: string,
     data: Uint8Array
-  ): Observable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
   // bidirectionalStreamingRequest implements a two-way streaming request.
   bidirectionalStreamingRequest(
     service: string,
     method: string,
-    data: Observable<Uint8Array>
-  ): Observable<Uint8Array>
+    data: AsyncIterable<Uint8Array>
+  ): AsyncIterable<Uint8Array>
 }