starpc 0.4.8 → 0.5.1

package/integration/integration.ts

@@ -1,5 +1,5 @@
 import { WebSocketConn } from '../srpc/websocket.js'
-import { runClientTest } from '../echo/client-test.js'
+import { runClientTest, runRpcStreamTest } from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {
@@ -9,7 +9,11 @@ async function runRPC() {
   const channel = new WebSocketConn(ws)
   const client = channel.buildClient()
 
+  console.log('Running client test via WebSocket..')
   await runClientTest(client)
+
+  console.log('Running RpcStream test via WebSocket..')
+  await runRpcStreamTest(client)
 }
 
 runRPC()

package/integration/integration_srpc.pb.go

@@ -0,0 +1,139 @@
+// Code generated by protoc-gen-srpc. DO NOT EDIT.
+// protoc-gen-srpc version: v0.0.0-20220611014014-aa9dc5523865
+// source: github.com/aperturerobotics/starpc/integration/integration.proto
+
+package main
+
+import (
+	context "context"
+
+	rpcstream "github.com/aperturerobotics/starpc/rpcstream"
+	srpc "github.com/aperturerobotics/starpc/srpc"
+)
+
+type SRPCIntegrationServiceClient interface {
+	SRPCClient() srpc.Client
+
+	RpcStream(ctx context.Context) (SRPCIntegrationService_RpcStreamClient, error)
+}
+
+type srpcIntegrationServiceClient struct {
+	cc srpc.Client
+}
+
+func NewSRPCIntegrationServiceClient(cc srpc.Client) SRPCIntegrationServiceClient {
+	return &srpcIntegrationServiceClient{cc}
+}
+
+func (c *srpcIntegrationServiceClient) SRPCClient() srpc.Client { return c.cc }
+
+func (c *srpcIntegrationServiceClient) RpcStream(ctx context.Context) (SRPCIntegrationService_RpcStreamClient, error) {
+	stream, err := c.cc.NewStream(ctx, "main.IntegrationService", "RpcStream", nil)
+	if err != nil {
+		return nil, err
+	}
+	strm := &srpcIntegrationService_RpcStreamClient{stream}
+	return strm, nil
+}
+
+type SRPCIntegrationService_RpcStreamClient interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+	RecvTo(*rpcstream.RpcStreamPacket) error
+}
+
+type srpcIntegrationService_RpcStreamClient struct {
+	srpc.Stream
+}
+
+func (x *srpcIntegrationService_RpcStreamClient) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcIntegrationService_RpcStreamClient) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcIntegrationService_RpcStreamClient) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}
+
+type SRPCIntegrationServiceServer interface {
+	RpcStream(SRPCIntegrationService_RpcStreamStream) error
+}
+
+type SRPCIntegrationServiceUnimplementedServer struct{}
+
+func (s *SRPCIntegrationServiceUnimplementedServer) RpcStream(SRPCIntegrationService_RpcStreamStream) error {
+	return srpc.ErrUnimplemented
+}
+
+const SRPCIntegrationServiceServiceID = "main.IntegrationService"
+
+type SRPCIntegrationServiceHandler struct {
+	impl SRPCIntegrationServiceServer
+}
+
+func (SRPCIntegrationServiceHandler) GetServiceID() string { return SRPCIntegrationServiceServiceID }
+
+func (SRPCIntegrationServiceHandler) GetMethodIDs() []string {
+	return []string{
+		"RpcStream",
+	}
+}
+
+func (d *SRPCIntegrationServiceHandler) InvokeMethod(
+	serviceID, methodID string,
+	strm srpc.Stream,
+) (bool, error) {
+	if serviceID != "" && serviceID != d.GetServiceID() {
+		return false, nil
+	}
+
+	switch methodID {
+	case "RpcStream":
+		return true, d.InvokeMethod_RpcStream(d.impl, strm)
+	default:
+		return false, nil
+	}
+}
+
+func (SRPCIntegrationServiceHandler) InvokeMethod_RpcStream(impl SRPCIntegrationServiceServer, strm srpc.Stream) error {
+	clientStrm := &srpcIntegrationService_RpcStreamStream{strm}
+	return impl.RpcStream(clientStrm)
+}
+
+func SRPCRegisterIntegrationService(mux srpc.Mux, impl SRPCIntegrationServiceServer) error {
+	return mux.Register(&SRPCIntegrationServiceHandler{impl: impl})
+}
+
+type SRPCIntegrationService_RpcStreamStream interface {
+	srpc.Stream
+	Send(*rpcstream.RpcStreamPacket) error
+	Recv() (*rpcstream.RpcStreamPacket, error)
+}
+
+type srpcIntegrationService_RpcStreamStream struct {
+	srpc.Stream
+}
+
+func (x *srpcIntegrationService_RpcStreamStream) Send(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgSend(m)
+}
+
+func (x *srpcIntegrationService_RpcStreamStream) Recv() (*rpcstream.RpcStreamPacket, error) {
+	m := new(rpcstream.RpcStreamPacket)
+	if err := x.MsgRecv(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (x *srpcIntegrationService_RpcStreamStream) RecvTo(m *rpcstream.RpcStreamPacket) error {
+	return x.MsgRecv(m)
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.4.8",
+  "version": "0.5.1",
   "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-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/broadcast-channel.ts

@@ -5,8 +5,8 @@ import { ConnParams } from './conn.js'
 import { Server } from './server.js'
 import { DuplexConn } from './conn-duplex.js'
 
-// BroadcastChannelIterable is a AsyncIterable wrapper for BroadcastChannel.
-export class BroadcastChannelIterable<T> implements Duplex<T> {
+// BroadcastChannelDuplex is a AsyncIterable wrapper for BroadcastChannel.
+export class BroadcastChannelDuplex<T> implements Duplex<T> {
   // readChannel is the incoming broadcast channel
   public readonly readChannel: BroadcastChannel
   // writeChannel is the outgoing broadcast channel
@@ -55,12 +55,12 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
   }
 }
 
-// newBroadcastChannelIterable constructs a BroadcastChannelIterable with a channel name.
-export function newBroadcastChannelIterable<T>(
+// newBroadcastChannelDuplex constructs a BroadcastChannelDuplex with a channel name.
+export function newBroadcastChannelDuplex<T>(
   readName: string,
   writeName: string
-): BroadcastChannelIterable<T> {
-  return new BroadcastChannelIterable<T>(
+): BroadcastChannelDuplex<T> {
+  return new BroadcastChannelDuplex<T>(
     new BroadcastChannel(readName),
     new BroadcastChannel(writeName)
   )
@@ -71,7 +71,7 @@ export function newBroadcastChannelIterable<T>(
 // expects Uint8Array objects over the BroadcastChannel.
 export class BroadcastChannelConn extends DuplexConn {
   // broadcastChannel is the broadcast channel iterable
-  private broadcastChannel: BroadcastChannelIterable<Uint8Array>
+  private broadcastChannel: BroadcastChannelDuplex<Uint8Array>
 
   constructor(
     readChannel: BroadcastChannel,
@@ -79,7 +79,7 @@ export class BroadcastChannelConn extends DuplexConn {
     server?: Server,
     connParams?: ConnParams
   ) {
-    const broadcastChannel = new BroadcastChannelIterable<Uint8Array>(
+    const broadcastChannel = new BroadcastChannelDuplex<Uint8Array>(
       readChannel,
       writeChannel
     )

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

@@ -6,8 +6,8 @@ export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js'
 export { Packet, CallStart, CallData } from './rpcproto.pb.js'
 export { Mux, createMux } from './mux.js'
 export {
-  BroadcastChannelIterable,
-  newBroadcastChannelIterable,
+  BroadcastChannelDuplex,
+  newBroadcastChannelDuplex,
   BroadcastChannelConn,
 } from './broadcast-channel.js'
 export {
@@ -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
+  }
+}