starpc 0.4.8 → 0.5.1

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()
 		}

package/dist/echo/sever.js

@@ -1 +0,0 @@
-"use strict";

package/dist/srpc/observable-source.d.ts

@@ -1,9 +0,0 @@
-import { Source } from 'it-stream-types';
-import { Observable } from 'rxjs';
-export declare class ObservableSource<T> {
-    readonly source: Source<T>;
-    private readonly _source;
-    private readonly subscription;
-    constructor(observable: Observable<T>);
-    close(err?: Error): void;
-}

package/dist/srpc/observable-source.js

@@ -1,25 +0,0 @@
-import { pushable } from 'it-pushable';
-// ObservableSource wraps an Observable into a Source.
-export class ObservableSource {
-    constructor(observable) {
-        const source = pushable({ objectMode: true });
-        this.source = source;
-        this._source = source;
-        this.subscription = observable.subscribe({
-            next: (value) => {
-                this._source.push(value);
-            },
-            error: (err) => {
-                this._source.end(err);
-            },
-            complete: () => {
-                this._source.end();
-            },
-        });
-    }
-    // close closes the subscription.
-    close(err) {
-        this._source.end(err);
-        this.subscription.unsubscribe();
-    }
-}

package/srpc/observable-source.ts

@@ -1,40 +0,0 @@
-import { Source } from 'it-stream-types'
-import { pushable, Pushable } from 'it-pushable'
-import { Observable, Subscription } from 'rxjs'
-
-// ObservableSource wraps an Observable into a Source.
-export class ObservableSource<T> {
-  // source is the source for observable objects.
-  public readonly source: Source<T>
-  // _source emits incoming data to the source.
-  private readonly _source: {
-    push: (val: T) => void
-    end: (err?: Error) => void
-  }
-  // subscription is the observable subscription
-  private readonly subscription: Subscription
-
-  constructor(observable: Observable<T>) {
-    const source: Pushable<T> = pushable({ objectMode: true })
-    this.source = source
-    this._source = source
-
-    this.subscription = observable.subscribe({
-      next: (value: T) => {
-        this._source.push(value)
-      },
-      error: (err) => {
-        this._source.end(err)
-      },
-      complete: () => {
-        this._source.end()
-      },
-    })
-  }
-
-  // close closes the subscription.
-  public close(err?: Error) {
-    this._source.end(err)
-    this.subscription.unsubscribe()
-  }
-}