starpc 0.4.9 → 0.5.0

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

@@ -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

@@ -1,14 +1,18 @@
 /* eslint-disable */
 import Long from 'long'
 import * as _m0 from 'protobufjs/minimal'
+import {
+  CallStart as CallStart1,
+  CallData as CallData2,
+} from './rpcproto.pb.js'
 
 export const protobufPackage = 'srpc'
 
 /** Packet is a message sent over a srpc packet connection. */
 export interface Packet {
   body?:
-    | { $case: 'callStart'; callStart: CallStart }
-    | { $case: 'callData'; callData: CallData }
+    | { $case: 'callStart'; callStart: CallStart1 }
+    | { $case: 'callData'; callData: CallData2 }
 }
 
 /** CallStart requests starting a new RPC call. */
@@ -57,13 +61,13 @@ export const Packet = {
     writer: _m0.Writer = _m0.Writer.create()
   ): _m0.Writer {
     if (message.body?.$case === 'callStart') {
-      CallStart.encode(
+      CallStart1.encode(
         message.body.callStart,
         writer.uint32(10).fork()
       ).ldelim()
     }
     if (message.body?.$case === 'callData') {
-      CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim()
+      CallData2.encode(message.body.callData, writer.uint32(18).fork()).ldelim()
     }
     return writer
   },
@@ -78,13 +82,13 @@ export const Packet = {
         case 1:
           message.body = {
             $case: 'callStart',
-            callStart: CallStart.decode(reader, reader.uint32()),
+            callStart: CallStart1.decode(reader, reader.uint32()),
           }
           break
         case 2:
           message.body = {
             $case: 'callData',
-            callData: CallData.decode(reader, reader.uint32()),
+            callData: CallData2.decode(reader, reader.uint32()),
           }
           break
         default:
@@ -95,15 +99,49 @@ 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)
         ? {
             $case: 'callStart',
-            callStart: CallStart.fromJSON(object.callStart),
+            callStart: CallStart1.fromJSON(object.callStart),
           }
         : isSet(object.callData)
-        ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
+        ? { $case: 'callData', callData: CallData2.fromJSON(object.callData) }
         : undefined,
     }
   },
@@ -112,11 +150,11 @@ export const Packet = {
     const obj: any = {}
     message.body?.$case === 'callStart' &&
       (obj.callStart = message.body?.callStart
-        ? CallStart.toJSON(message.body?.callStart)
+        ? CallStart1.toJSON(message.body?.callStart)
         : undefined)
     message.body?.$case === 'callData' &&
       (obj.callData = message.body?.callData
-        ? CallData.toJSON(message.body?.callData)
+        ? CallData2.toJSON(message.body?.callData)
         : undefined)
     return obj
   },
@@ -130,7 +168,7 @@ export const Packet = {
     ) {
       message.body = {
         $case: 'callStart',
-        callStart: CallStart.fromPartial(object.body.callStart),
+        callStart: CallStart1.fromPartial(object.body.callStart),
       }
     }
     if (
@@ -140,7 +178,7 @@ export const Packet = {
     ) {
       message.body = {
         $case: 'callData',
-        callData: CallData.fromPartial(object.body.callData),
+        callData: CallData2.fromPartial(object.body.callData),
       }
     }
     return message
@@ -203,6 +241,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 +368,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>
 }

package/srpc/websocket.go

@@ -49,9 +49,9 @@ func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler PacketHandler
 		return nil, err
 	}
 
-	rw := NewPacketReadWriter(muxedStream, msgHandler)
+	rw := NewPacketReadWriter(muxedStream)
 	go func() {
-		err := rw.ReadPump()
+		err := rw.ReadPump(msgHandler)
 		if err != nil {
 			_ = rw.Close()
 		}