starpc 0.3.6 → 0.4.0

package/Makefile

@@ -99,9 +99,10 @@ gents: $(PROTOWRAP) node_modules
 		-I $$(pwd)/vendor \
 		--plugin=./node_modules/.bin/protoc-gen-ts_proto \
 		--ts_proto_out=$$(pwd)/vendor \
+		--ts_proto_opt=esModuleInterop=true \
+		--ts_proto_opt=fileSuffix=.pb \
 		--ts_proto_opt=forceLong=long \
 		--ts_proto_opt=oneof=unions \
-		--ts_proto_opt=esModuleInterop=true \
 		--ts_proto_opt=outputServices=default,outputServices=generic-definitions \
 		--proto_path $$(pwd)/vendor \
 		--print_structure \

package/dist/echo/client-test.js

@@ -1,4 +1,4 @@
-import { EchoerClientImpl } from './echo.js';
+import { EchoerClientImpl } from './echo.pb.js';
 import { Observable } from 'rxjs';
 export async function runClientTest(client) {
     const demoServiceClient = new EchoerClientImpl(client);

package/dist/echo/index.d.ts

@@ -1,3 +1,3 @@
-export * from './echo.js';
+export * from './echo.pb.js';
 export * from './server.js';
 export { runClientTest } from './client-test.js';

package/dist/echo/index.js

@@ -1,3 +1,3 @@
-export * from './echo.js';
+export * from './echo.pb.js';
 export * from './server.js';
 export { runClientTest } from './client-test.js';

package/dist/echo/server.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { Echoer, EchoMsg } from './echo';
+import { Echoer, EchoMsg } from './echo.pb.js';
 export declare class EchoerServer implements Echoer {
     Echo(request: EchoMsg): Promise<EchoMsg>;
     EchoServerStream(request: EchoMsg): Observable<EchoMsg>;

package/dist/srpc/client-rpc.d.ts

@@ -1,4 +1,4 @@
-import type { CallStart } from './rpcproto.js';
+import type { CallStart } from './rpcproto.pb.js';
 import { CommonRPC } from './common-rpc.js';
 export declare class ClientRPC extends CommonRPC {
     constructor(service: string, method: string);

package/dist/srpc/client.d.ts

@@ -2,11 +2,11 @@ import { Observable } from 'rxjs';
 import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
-    private openConnFn;
-    private _openConnFn?;
-    constructor(openConnFn?: OpenStreamFunc);
-    setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
-    private initOpenConnFn;
+    private openStreamFn;
+    private _openStreamFn?;
+    constructor(openStreamFn?: OpenStreamFunc);
+    setOpenStreamFn(openStreamFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
+    private initOpenStreamFn;
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
     clientStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Promise<Uint8Array>;
     serverStreamingRequest(service: string, method: string, data: Uint8Array): Observable<Uint8Array>;

package/dist/srpc/client.js

@@ -19,31 +19,31 @@ function writeClientStream(call, data) {
 }
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
-    constructor(openConnFn) {
-        this.openConnFn = this.setOpenConnFn(openConnFn);
+    constructor(openStreamFn) {
+        this.openStreamFn = this.setOpenStreamFn(openStreamFn);
     }
-    // setOpenConnFn updates the openConnFn for the Client.
-    setOpenConnFn(openConnFn) {
-        if (this._openConnFn) {
-            if (openConnFn) {
-                this._openConnFn(openConnFn);
-                this._openConnFn = undefined;
+    // setOpenStreamFn updates the openStreamFn for the Client.
+    setOpenStreamFn(openStreamFn) {
+        if (this._openStreamFn) {
+            if (openStreamFn) {
+                this._openStreamFn(openStreamFn);
+                this._openStreamFn = undefined;
             }
         }
         else {
-            if (openConnFn) {
-                this.openConnFn = Promise.resolve(openConnFn);
+            if (openStreamFn) {
+                this.openStreamFn = Promise.resolve(openStreamFn);
             }
             else {
-                this.initOpenConnFn();
+                this.initOpenStreamFn();
             }
         }
-        return this.openConnFn;
+        return this.openStreamFn;
     }
-    // initOpenConnFn creates the empty Promise for openConnFn.
-    initOpenConnFn() {
+    // initOpenStreamFn creates the empty Promise for openStreamFn.
+    initOpenStreamFn() {
         const openPromise = new Promise((resolve, reject) => {
-            this._openConnFn = (conn, err) => {
+            this._openStreamFn = (conn, err) => {
                 if (err) {
                     reject(err);
                 }
@@ -52,8 +52,8 @@ export class Client {
                 }
             };
         });
-        this.openConnFn = openPromise;
-        return this.openConnFn;
+        this.openStreamFn = openPromise;
+        return this.openStreamFn;
     }
     // request starts a non-streaming request.
     async request(service, method, data) {
@@ -131,8 +131,8 @@ export class Client {
     // throws any error starting the rpc call
     // if data == null and data.length == 0, sends a separate data packet.
     async startRpc(rpcService, rpcMethod, data) {
-        const openConnFn = await this.openConnFn;
-        const conn = await openConnFn();
+        const openStreamFn = await this.openStreamFn;
+        const conn = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         pipe(conn, parseLengthPrefixTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);
         await call.writeCallStart(data || undefined);

package/dist/srpc/common-rpc.d.ts

@@ -1,6 +1,6 @@
 import type { Source, Sink } from 'it-stream-types';
-import type { CallData, CallStart } from './rpcproto.js';
-import { Packet } from './rpcproto.js';
+import type { CallData, CallStart } from './rpcproto.pb.js';
+import { Packet } from './rpcproto.pb.js';
 export declare class CommonRPC {
     sink: Sink<Packet>;
     source: AsyncIterable<Packet>;

package/dist/srpc/common-rpc.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {
     constructor() {

package/dist/srpc/index.d.ts

@@ -1,4 +1,4 @@
-export type { OpenStreamFunc } from './stream.js';
+export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';

package/dist/srpc/packet.d.ts

@@ -1,5 +1,5 @@
 import type { Transform } from 'it-stream-types';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 export declare const decodePacketSource: (source: import("it-stream-types").Source<Uint8Array | Uint8Array[]>) => AsyncIterable<Packet>;
 export declare const encodePacketSource: (source: import("it-stream-types").Source<Packet | Packet[]>) => AsyncIterable<Uint8Array>;
 export declare function prependLengthPrefixTransform(): Transform<Uint8Array>;

package/dist/srpc/packet.js

@@ -1,5 +1,5 @@
 import { encode as lengthPrefixEncode, decode as lengthPrefixDecode, } from 'it-length-prefixed';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
 // decodePacketSource decodes packets from a binary data stream.
 export const decodePacketSource = buildDecodeMessageTransform(Packet);

package/dist/srpc/server-rpc.d.ts

@@ -1,4 +1,4 @@
-import type { CallData, CallStart } from './rpcproto.js';
+import type { CallData, CallStart } from './rpcproto.pb.js';
 import { CommonRPC } from './common-rpc.js';
 import { Mux } from './mux.js';
 export declare class ServerRPC extends CommonRPC {

package/dist/srpc/server.d.ts

@@ -2,7 +2,7 @@ import { Stream } from '@libp2p/interface-connection';
 import { Duplex } from 'it-stream-types';
 import { Mux } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 import { StreamHandler } from './conn.js';
 export declare class Server implements StreamHandler {
     private mux;

package/dist/srpc/stream.d.ts

@@ -1,4 +1,4 @@
-import type { Packet } from './rpcproto';
+import type { Packet } from './rpcproto.pb.js';
 import type { Duplex } from 'it-stream-types';
 export declare type PacketHandler = (packet: Packet) => Promise<void>;
 export declare type Stream = Duplex<Uint8Array>;

package/echo/client-test.ts

@@ -1,5 +1,5 @@
 import { Client } from '../srpc/index.js'
-import { EchoerClientImpl, EchoMsg } from './echo.js'
+import { EchoerClientImpl, EchoMsg } from './echo.pb.js'
 import { Observable } from 'rxjs'
 
 export async function runClientTest(client: Client) {

package/echo/index.ts

@@ -1,3 +1,3 @@
-export * from './echo.js'
+export * from './echo.pb.js'
 export * from './server.js'
 export { runClientTest } from './client-test.js'

package/echo/server.ts

@@ -1,5 +1,5 @@
 import { Observable, from as observableFrom } from 'rxjs'
-import { Echoer, EchoMsg } from './echo'
+import { Echoer, EchoMsg } from './echo.pb.js'
 import { pushable, Pushable } from 'it-pushable'
 
 // EchoServer implements the Echoer server.

package/integration/integration.ts

@@ -1,5 +1,5 @@
-import { WebSocketConn } from '../srpc/websocket'
-import { runClientTest } from '../echo'
+import { WebSocketConn } from '../srpc/websocket.js'
+import { runClientTest } from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.3.6",
+  "version": "0.4.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/broadcast-channel.ts

@@ -46,8 +46,8 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
           queue.push(ev.data)
         }
       }
-      this.readChannel.addEventListener('message', messageListener)
 
+      this.readChannel.addEventListener('message', messageListener)
       return () => {
         this.readChannel.removeEventListener('message', messageListener)
       }

package/srpc/client-rpc.ts

@@ -1,4 +1,4 @@
-import type { CallStart } from './rpcproto.js'
+import type { CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 
 // ClientRPC is an ongoing RPC from the client side.

package/srpc/client.go

@@ -19,7 +19,7 @@ type Client interface {
 
 // OpenStreamFunc opens a stream with a remote.
 // msgHandler must not be called concurrently.
-type OpenStreamFunc = func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error)
+type OpenStreamFunc = func(ctx context.Context, msgHandler PacketHandler) (Writer, error)
 
 // client implements Client with a transport.
 type client struct {
@@ -89,7 +89,7 @@ func (c *client) NewStream(ctx context.Context, service, method string, firstMsg
 		return nil, err
 	}
 
-	return NewRPCStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
+	return NewMsgStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
 }
 
 // _ is a type assertion

package/srpc/client.ts

@@ -29,36 +29,36 @@ function writeClientStream(call: ClientRPC, data: Observable<Uint8Array>) {
 
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client implements TsProtoRpc {
-  // openConnFn is a promise which contains the OpenStreamFunc.
-  private openConnFn: Promise<OpenStreamFunc>
-  // _openConnFn resolves openConnFn.
-  private _openConnFn?: (conn?: OpenStreamFunc, err?: Error) => void
+  // openStreamFn is a promise which contains the OpenStreamFunc.
+  private openStreamFn: Promise<OpenStreamFunc>
+  // _openStreamFn resolves openStreamFn.
+  private _openStreamFn?: (conn?: OpenStreamFunc, err?: Error) => void
 
-  constructor(openConnFn?: OpenStreamFunc) {
-    this.openConnFn = this.setOpenConnFn(openConnFn)
+  constructor(openStreamFn?: OpenStreamFunc) {
+    this.openStreamFn = this.setOpenStreamFn(openStreamFn)
   }
 
-  // setOpenConnFn updates the openConnFn for the Client.
-  public setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc> {
-    if (this._openConnFn) {
-      if (openConnFn) {
-        this._openConnFn(openConnFn)
-        this._openConnFn = undefined
+  // setOpenStreamFn updates the openStreamFn for the Client.
+  public setOpenStreamFn(openStreamFn?: OpenStreamFunc): Promise<OpenStreamFunc> {
+    if (this._openStreamFn) {
+      if (openStreamFn) {
+        this._openStreamFn(openStreamFn)
+        this._openStreamFn = undefined
       }
     } else {
-      if (openConnFn) {
-        this.openConnFn = Promise.resolve(openConnFn)
+      if (openStreamFn) {
+        this.openStreamFn = Promise.resolve(openStreamFn)
       } else {
-        this.initOpenConnFn()
+        this.initOpenStreamFn()
       }
     }
-    return this.openConnFn
+    return this.openStreamFn
   }
 
-  // initOpenConnFn creates the empty Promise for openConnFn.
-  private initOpenConnFn(): Promise<OpenStreamFunc> {
+  // initOpenStreamFn creates the empty Promise for openStreamFn.
+  private initOpenStreamFn(): Promise<OpenStreamFunc> {
     const openPromise = new Promise<OpenStreamFunc>((resolve, reject) => {
-      this._openConnFn = (conn?: OpenStreamFunc, err?: Error) => {
+      this._openStreamFn = (conn?: OpenStreamFunc, err?: Error) => {
         if (err) {
           reject(err)
         } else if (conn) {
@@ -66,8 +66,8 @@ export class Client implements TsProtoRpc {
         }
       }
     })
-    this.openConnFn = openPromise
-    return this.openConnFn
+    this.openStreamFn = openPromise
+    return this.openStreamFn
   }
 
   // request starts a non-streaming request.
@@ -168,8 +168,8 @@ export class Client implements TsProtoRpc {
     rpcMethod: string,
     data: Uint8Array | null
   ): Promise<ClientRPC> {
-    const openConnFn = await this.openConnFn
-    const conn = await openConnFn()
+    const openStreamFn = await this.openStreamFn
+    const conn = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     pipe(
       conn,

package/srpc/common-rpc.ts

@@ -1,8 +1,8 @@
 import type { Source, Sink } from 'it-stream-types'
 import { pushable } from 'it-pushable'
 
-import type { CallData, CallStart } from './rpcproto.js'
-import { Packet } from './rpcproto.js'
+import type { CallData, CallStart } from './rpcproto.pb.js'
+import { Packet } from './rpcproto.pb.js'
 
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {

package/srpc/index.ts

@@ -1,4 +1,4 @@
-export type { OpenStreamFunc } from './stream.js'
+export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js'
 export { Client } from './client.js'
 export { Server } from './server.js'
 export { Conn, ConnParams } from './conn.js'

package/srpc/{rpc-stream.go → msg-stream.go}

@@ -5,8 +5,8 @@ import (
 	"io"
 )
 
-// RPCStream implements the stream interface passed to implementations.
-type RPCStream struct {
+// MsgStream implements the stream interface passed to implementations.
+type MsgStream struct {
 	// ctx is the stream context
 	ctx context.Context
 	// writer is the stream writer
@@ -15,10 +15,10 @@ type RPCStream struct {
 	dataCh chan []byte
 }
 
-// NewRPCStream constructs a new Stream with a ClientRPC.
+// NewMsgStream constructs a new Stream with a ClientRPC.
 // dataCh should be closed when no more messages will arrive.
-func NewRPCStream(ctx context.Context, writer Writer, dataCh chan []byte) *RPCStream {
-	return &RPCStream{
+func NewMsgStream(ctx context.Context, writer Writer, dataCh chan []byte) *MsgStream {
+	return &MsgStream{
 		ctx:    ctx,
 		writer: writer,
 		dataCh: dataCh,
@@ -26,12 +26,12 @@ func NewRPCStream(ctx context.Context, writer Writer, dataCh chan []byte) *RPCSt
 }
 
 // Context is canceled when the Stream is no longer valid.
-func (r *RPCStream) Context() context.Context {
+func (r *MsgStream) Context() context.Context {
 	return r.ctx
 }
 
 // MsgSend sends the message to the remote.
-func (r *RPCStream) MsgSend(msg Message) error {
+func (r *MsgStream) MsgSend(msg Message) error {
 	select {
 	case <-r.ctx.Done():
 		return context.Canceled
@@ -48,7 +48,7 @@ func (r *RPCStream) MsgSend(msg Message) error {
 
 // MsgRecv receives an incoming message from the remote.
 // Parses the message into the object at msg.
-func (r *RPCStream) MsgRecv(msg Message) error {
+func (r *MsgStream) MsgRecv(msg Message) error {
 	select {
 	case <-r.Context().Done():
 		return context.Canceled
@@ -61,16 +61,16 @@ func (r *RPCStream) MsgRecv(msg Message) error {
 }
 
 // CloseSend signals to the remote that we will no longer send any messages.
-func (r *RPCStream) CloseSend() error {
+func (r *MsgStream) CloseSend() error {
 	outPkt := NewCallDataPacket(nil, false, true, nil)
 	return r.writer.WritePacket(outPkt)
 }
 
 // Close closes the stream.
-func (r *RPCStream) Close() error {
+func (r *MsgStream) Close() error {
 	_ = r.writer.Close()
 	return nil
 }
 
 // _ is a type assertion
-var _ Stream = ((*RPCStream)(nil))
+var _ Stream = ((*MsgStream)(nil))

package/srpc/muxed-conn.go

@@ -14,7 +14,7 @@ func NewClientWithMuxedConn(conn network.MuxedConn) Client {
 
 // NewOpenStreamWithMuxedConn constructs a OpenStream func with a MuxedConn.
 func NewOpenStreamWithMuxedConn(conn network.MuxedConn) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 		mstrm, err := conn.OpenStream(ctx)
 		if err != nil {
 			return nil, err

package/srpc/packet.ts

@@ -4,7 +4,7 @@ import {
   decode as lengthPrefixDecode,
 } from 'it-length-prefixed'
 
-import { Packet } from './rpcproto.js'
+import { Packet } from './rpcproto.pb.js'
 import {
   buildDecodeMessageTransform,
   buildEncodeMessageTransform,

package/srpc/server-pipe.go

@@ -9,7 +9,7 @@ import (
 // Stream with the given Server. Starts read pumps for both. Starts the
 // HandleStream function on the server in a separate goroutine.
 func NewServerPipe(server *Server) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 		srvPipe, clientPipe := net.Pipe()
 		go func() {
 			_ = server.HandleStream(ctx, srvPipe)

package/srpc/server-rpc.go

@@ -133,7 +133,7 @@ func (r *ServerRPC) HandleCallData(pkt *CallData) error {
 func (r *ServerRPC) invokeRPC() {
 	// ctx := r.ctx
 	serviceID, methodID := r.service, r.method
-	strm := NewRPCStream(r.ctx, r.writer, r.dataCh)
+	strm := NewMsgStream(r.ctx, r.writer, r.dataCh)
 	ok, err := r.mux.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented

package/srpc/server-rpc.ts

@@ -1,6 +1,6 @@
 import type { Sink } from 'it-stream-types'
 
-import type { CallData, CallStart } from './rpcproto.js'
+import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.js'
 import { Mux } from './mux.js'

package/srpc/server.go

@@ -20,6 +20,11 @@ func NewServer(mux Mux) *Server {
 	}
 }
 
+// GetMux returns the mux.
+func (s *Server) GetMux() Mux {
+	return s.mux
+}
+
 // HandleStream handles an incoming ReadWriteCloser stream.
 func (s *Server) HandleStream(ctx context.Context, rwc io.ReadWriteCloser) error {
 	subCtx, subCtxCancel := context.WithCancel(ctx)

package/srpc/server.ts

@@ -4,7 +4,7 @@ import { pipe } from 'it-pipe'
 
 import { Mux } from './mux.js'
 import { ServerRPC } from './server-rpc.js'
-import { Packet } from './rpcproto.js'
+import { Packet } from './rpcproto.pb.js'
 import {
   parseLengthPrefixTransform,
   prependLengthPrefixTransform,

package/srpc/stream.ts

@@ -1,4 +1,4 @@
-import type { Packet } from './rpcproto'
+import type { Packet } from './rpcproto.pb.js'
 import type { Duplex } from 'it-stream-types'
 
 // PacketHandler handles incoming packets.

package/srpc/websocket.go

@@ -43,7 +43,7 @@ func (w *WebSocketConn) AcceptStream() (io.ReadWriteCloser, error) {
 }
 
 // OpenStream tries to open a stream with the remote.
-func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 	muxedStream, err := w.mconn.OpenStream(ctx)
 	if err != nil {
 		return nil, err