starpc 0.14.0 → 0.14.1

package/dist/srpc/client.d.ts

@@ -1,11 +1,9 @@
 import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
-    private openStreamFn;
-    private _openStreamFn?;
+    private openStreamCtr;
     constructor(openStreamFn?: OpenStreamFunc);
-    setOpenStreamFn(openStreamFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
-    private initOpenStreamFn;
+    setOpenStreamFn(openStreamFn?: OpenStreamFunc): void;
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
     clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
     serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;

package/dist/srpc/client.js

@@ -4,43 +4,15 @@ import { ClientRPC } from './client-rpc.js';
 import { writeToPushable } from './pushable.js';
 import { decodePacketSource, encodePacketSource, parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
+import { OpenStreamCtr } from './open-stream-ctr.js';
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
     constructor(openStreamFn) {
-        this.openStreamFn = this.setOpenStreamFn(openStreamFn);
+        this.openStreamCtr = new OpenStreamCtr(openStreamFn || undefined);
     }
     // setOpenStreamFn updates the openStreamFn for the Client.
     setOpenStreamFn(openStreamFn) {
-        if (this._openStreamFn) {
-            if (openStreamFn) {
-                this._openStreamFn(openStreamFn);
-                this._openStreamFn = undefined;
-            }
-        }
-        else {
-            if (openStreamFn) {
-                this.openStreamFn = Promise.resolve(openStreamFn);
-            }
-            else {
-                this.initOpenStreamFn();
-            }
-        }
-        return this.openStreamFn;
-    }
-    // initOpenStreamFn creates the empty Promise for openStreamFn.
-    initOpenStreamFn() {
-        const openPromise = new Promise((resolve, reject) => {
-            this._openStreamFn = (conn, err) => {
-                if (err) {
-                    reject(err);
-                }
-                else if (conn) {
-                    resolve(conn);
-                }
-            };
-        });
-        this.openStreamFn = openPromise;
-        return this.openStreamFn;
+        this.openStreamCtr.set(openStreamFn || undefined);
     }
     // request starts a non-streaming request.
     async request(service, method, data) {
@@ -98,7 +70,7 @@ 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 openStreamFn = await this.openStreamFn;
+        const openStreamFn = await this.openStreamCtr.wait();
         const conn = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         pipe(conn, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);

package/dist/srpc/index.d.ts

@@ -7,4 +7,6 @@ export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { Mux, StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
+export { ValueCtr } from './value-ctr.js';
+export { OpenStreamCtr } from './open-stream-ctr.js';
 export { writeToPushable } from './pushable';

package/dist/srpc/index.js

@@ -6,4 +6,6 @@ export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
+export { ValueCtr } from './value-ctr.js';
+export { OpenStreamCtr } from './open-stream-ctr.js';
 export { writeToPushable } from './pushable';

package/dist/srpc/open-stream-ctr.d.ts

@@ -0,0 +1,6 @@
+import { OpenStreamFunc } from './stream.js';
+import { ValueCtr } from './value-ctr.js';
+export declare class OpenStreamCtr extends ValueCtr<OpenStreamFunc> {
+    constructor(openStreamFn?: OpenStreamFunc);
+    get openStreamFunc(): OpenStreamFunc;
+}

package/dist/srpc/open-stream-ctr.js

@@ -0,0 +1,17 @@
+import { ValueCtr } from './value-ctr.js';
+// OpenStreamCtr contains an OpenStream func which can be awaited.
+export class OpenStreamCtr extends ValueCtr {
+    constructor(openStreamFn) {
+        super(openStreamFn);
+    }
+    // openStreamFunc returns an OpenStreamFunc which waits for the underlying OpenStreamFunc.
+    get openStreamFunc() {
+        return async () => {
+            let openFn = this.value;
+            if (!openFn) {
+                openFn = await this.wait();
+            }
+            return openFn();
+        };
+    }
+}

package/dist/srpc/value-ctr.d.ts

@@ -0,0 +1,9 @@
+export declare class ValueCtr<T> {
+    private _value;
+    private _waiters;
+    constructor(initialValue?: T);
+    get value(): T | undefined;
+    wait(): Promise<T>;
+    waitWithCb(cb: (val: T) => void): void;
+    set(val: T | undefined): void;
+}

package/dist/srpc/value-ctr.js

@@ -0,0 +1,44 @@
+// ValueCtr contains a value that can be set asynchronously.
+export class ValueCtr {
+    constructor(initialValue) {
+        this._value = initialValue || undefined;
+        this._waiters = [];
+    }
+    // value returns the current value.
+    get value() {
+        return this._value;
+    }
+    // wait waits for the value to not be undefined.
+    async wait() {
+        const currVal = this._value;
+        if (currVal !== undefined) {
+            return currVal;
+        }
+        return new Promise((resolve) => {
+            this.waitWithCb((val) => {
+                resolve(val);
+            });
+        });
+    }
+    // waitWithCb adds a callback to be called when the value is not undefined.
+    waitWithCb(cb) {
+        if (cb) {
+            this._waiters.push(cb);
+        }
+    }
+    // set sets the value and calls the callbacks.
+    set(val) {
+        this._value = val;
+        if (val === undefined) {
+            return;
+        }
+        const waiters = this._waiters;
+        if (waiters.length === 0) {
+            return;
+        }
+        this._waiters = [];
+        for (const waiter of waiters) {
+            waiter(val);
+        }
+    }
+}

package/package.json

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

package/srpc/client.ts

@@ -12,50 +12,20 @@ import {
   prependLengthPrefixTransform,
 } from './packet.js'
 import { combineUint8ArrayListTransform } from './array-list.js'
+import { OpenStreamCtr } from './open-stream-ctr.js'
 
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client implements TsProtoRpc {
-  // openStreamFn is a promise which contains the OpenStreamFunc.
-  private openStreamFn: Promise<OpenStreamFunc>
-  // _openStreamFn resolves openStreamFn.
-  private _openStreamFn?: (conn?: OpenStreamFunc, err?: Error) => void
+  // openStreamCtr contains the OpenStreamFunc.
+  private openStreamCtr: OpenStreamCtr
 
   constructor(openStreamFn?: OpenStreamFunc) {
-    this.openStreamFn = this.setOpenStreamFn(openStreamFn)
+    this.openStreamCtr = new OpenStreamCtr(openStreamFn || 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 (openStreamFn) {
-        this.openStreamFn = Promise.resolve(openStreamFn)
-      } else {
-        this.initOpenStreamFn()
-      }
-    }
-    return this.openStreamFn
-  }
-
-  // initOpenStreamFn creates the empty Promise for openStreamFn.
-  private initOpenStreamFn(): Promise<OpenStreamFunc> {
-    const openPromise = new Promise<OpenStreamFunc>((resolve, reject) => {
-      this._openStreamFn = (conn?: OpenStreamFunc, err?: Error) => {
-        if (err) {
-          reject(err)
-        } else if (conn) {
-          resolve(conn)
-        }
-      }
-    })
-    this.openStreamFn = openPromise
-    return this.openStreamFn
+  public setOpenStreamFn(openStreamFn?: OpenStreamFunc) {
+    this.openStreamCtr.set(openStreamFn || undefined)
   }
 
   // request starts a non-streaming request.
@@ -137,7 +107,7 @@ export class Client implements TsProtoRpc {
     rpcMethod: string,
     data: Uint8Array | null
   ): Promise<ClientRPC> {
-    const openStreamFn = await this.openStreamFn
+    const openStreamFn = await this.openStreamCtr.wait()
     const conn = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     pipe(

package/srpc/index.ts

@@ -15,4 +15,6 @@ export {
   newMessagePortIterable,
   MessagePortConn,
 } from './message-port.js'
+export { ValueCtr } from './value-ctr.js'
+export { OpenStreamCtr } from './open-stream-ctr.js'
 export { writeToPushable } from './pushable'

package/srpc/muxed-conn.go

@@ -15,6 +15,7 @@ func NewYamuxConfig() *yamux.Config {
 	// Configuration options from go-libp2p-yamux:
 	config := *ymuxer.DefaultTransport.Config()
 	config.AcceptBacklog = 512
+	config.EnableKeepAlive = false
 	return &config
 }
 

package/srpc/open-stream-ctr.ts

@@ -0,0 +1,20 @@
+import { OpenStreamFunc, Stream } from './stream.js'
+import { ValueCtr } from './value-ctr.js'
+
+// OpenStreamCtr contains an OpenStream func which can be awaited.
+export class OpenStreamCtr extends ValueCtr<OpenStreamFunc> {
+  constructor(openStreamFn?: OpenStreamFunc) {
+    super(openStreamFn)
+  }
+
+  // openStreamFunc returns an OpenStreamFunc which waits for the underlying OpenStreamFunc.
+  get openStreamFunc(): OpenStreamFunc {
+    return async (): Promise<Stream> => {
+      let openFn = this.value
+      if (!openFn) {
+        openFn = await this.wait()
+      }
+      return openFn()
+    }
+  }
+}

package/srpc/packet-rw.go

@@ -94,7 +94,7 @@ func (r *PacketReaderWriter) ReadToHandler(cb PacketHandler) error {
 
 		// parse the length prefix if not done already
 		if currLen == 0 {
-			currLen = r.readLengthPrefix(r.buf.Bytes())
+			currLen = r.readLengthPrefix(r.buf.Bytes()[:4])
 			if currLen == 0 {
 				return errors.New("unexpected zero len prefix")
 			}

package/srpc/value-ctr.ts

@@ -0,0 +1,54 @@
+// ValueCtr contains a value that can be set asynchronously.
+export class ValueCtr<T> {
+  // _value contains the current value.
+  private _value: T | undefined
+  // _waiters contains the list of waiters.
+  // called when the value is set to any value other than undefined.
+  private _waiters: ((fn: T) => void)[]
+
+  constructor(initialValue?: T) {
+    this._value = initialValue || undefined
+    this._waiters = []
+  }
+
+  // value returns the current value.
+  get value(): T | undefined {
+    return this._value
+  }
+
+  // wait waits for the value to not be undefined.
+  public async wait(): Promise<T> {
+    const currVal = this._value
+    if (currVal !== undefined) {
+      return currVal
+    }
+    return new Promise<T>((resolve) => {
+      this.waitWithCb((val: T) => {
+        resolve(val)
+      })
+    })
+  }
+
+  // waitWithCb adds a callback to be called when the value is not undefined.
+  public waitWithCb(cb: (val: T) => void) {
+    if (cb) {
+      this._waiters.push(cb)
+    }
+  }
+
+  // set sets the value and calls the callbacks.
+  public set(val: T | undefined) {
+    this._value = val
+    if (val === undefined) {
+      return
+    }
+    const waiters = this._waiters
+    if (waiters.length === 0) {
+      return
+    }
+    this._waiters = []
+    for (const waiter of waiters) {
+      waiter(val)
+    }
+  }
+}

package/srpc/websocket.go

@@ -2,65 +2,20 @@ package srpc
 
 import (
 	"context"
-	"io"
 
 	"github.com/libp2p/go-libp2p/core/network"
 	"github.com/libp2p/go-yamux/v4"
 	"nhooyr.io/websocket"
 )
 
-// WebSocketConn implements the p2p multiplexer over a WebSocket.
-type WebSocketConn struct {
-	// conn is the websocket conn
-	conn *websocket.Conn
-	// mconn is the muxed conn
-	mconn network.MuxedConn
-}
-
-// NewWebSocketConn constructs a new WebSocket connection.
-//
+// NewWebSocketConn wraps a websocket into a MuxedConn.
 // if yamuxConf is unset, uses the defaults.
-func NewWebSocketConn(ctx context.Context, conn *websocket.Conn, isServer bool, yamuxConf *yamux.Config) (*WebSocketConn, error) {
+func NewWebSocketConn(
+	ctx context.Context,
+	conn *websocket.Conn,
+	isServer bool,
+	yamuxConf *yamux.Config,
+) (network.MuxedConn, error) {
 	nc := websocket.NetConn(ctx, conn, websocket.MessageBinary)
-	muxedConn, err := NewMuxedConn(nc, !isServer, yamuxConf)
-	if err != nil {
-		return nil, err
-	}
-	return &WebSocketConn{conn: conn, mconn: muxedConn}, nil
-}
-
-// GetWebSocket returns the web socket conn.
-func (w *WebSocketConn) GetWebSocket() *websocket.Conn {
-	return w.conn
-}
-
-// GetOpenStreamFunc returns the OpenStream func.
-func (w *WebSocketConn) GetOpenStreamFunc() OpenStreamFunc {
-	return w.OpenStream
-}
-
-// AcceptStream accepts an incoming stream.
-func (w *WebSocketConn) AcceptStream() (io.ReadWriteCloser, error) {
-	strm, err := w.mconn.AcceptStream()
-	if err != nil {
-		return nil, err
-	}
-	return strm, nil
-}
-
-// OpenStream tries to open a stream with the remote.
-func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler PacketHandler, closeHandler CloseHandler) (Writer, error) {
-	muxedStream, err := w.mconn.OpenStream(ctx)
-	if err != nil {
-		return nil, err
-	}
-
-	rw := NewPacketReadWriter(muxedStream)
-	go rw.ReadPump(msgHandler, closeHandler)
-	return rw, nil
-}
-
-// Close closes the writer.
-func (w *WebSocketConn) Close() error {
-	return w.conn.Close(websocket.StatusGoingAway, "conn closed")
+	return NewMuxedConn(nc, !isServer, yamuxConf)
 }