starpc 0.3.1 → 0.3.4

package/dist/srpc/client.d.ts

@@ -3,7 +3,10 @@ import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
     private openConnFn;
-    constructor(openConnFn: OpenStreamFunc);
+    private _openConnFn?;
+    constructor(openConnFn?: OpenStreamFunc);
+    setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
+    private initOpenConnFn;
     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,11 +19,45 @@ function writeClientStream(call, data) {
 }
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
-    // openConnFn is the open connection function.
-    // called when starting RPC.
+    // openConnFn is a promise which contains the OpenStreamFunc.
     openConnFn;
+    // _openConnFn resolves openConnFn.
+    _openConnFn;
     constructor(openConnFn) {
-        this.openConnFn = openConnFn;
+        this.openConnFn = this.setOpenConnFn(openConnFn);
+    }
+    // setOpenConnFn updates the openConnFn for the Client.
+    setOpenConnFn(openConnFn) {
+        if (this._openConnFn) {
+            if (openConnFn) {
+                this._openConnFn(openConnFn);
+                this._openConnFn = undefined;
+            }
+        }
+        else {
+            if (openConnFn) {
+                this.openConnFn = Promise.resolve(openConnFn);
+            }
+            else {
+                this.initOpenConnFn();
+            }
+        }
+        return this.openConnFn;
+    }
+    // initOpenConnFn creates the empty Promise for openConnFn.
+    initOpenConnFn() {
+        const openPromise = new Promise((resolve, reject) => {
+            this._openConnFn = (conn, err) => {
+                if (err) {
+                    reject(err);
+                }
+                else if (conn) {
+                    resolve(conn);
+                }
+            };
+        });
+        this.openConnFn = openPromise;
+        return this.openConnFn;
     }
     // request starts a non-streaming request.
     async request(service, method, data) {
@@ -101,7 +135,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 conn = await this.openConnFn();
+        const openConnFn = await this.openConnFn;
+        const conn = await openConnFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         pipe(conn, parseLengthPrefixTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);
         await call.writeCallStart(data || undefined);

package/dist/srpc/index.d.ts

@@ -4,6 +4,5 @@ export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';
 export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js';
 export { Mux, createMux } from './mux.js';
-export { WebSocketConn } from './websocket.js';
 export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';

package/dist/srpc/index.js

@@ -3,6 +3,5 @@ export { Server } from './server.js';
 export { Conn } from './conn.js';
 export { createHandler, createInvokeFn } from './handler.js';
 export { createMux } from './mux.js';
-export { WebSocketConn } from './websocket.js';
 export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';

package/integration/integration.bash

@@ -1,6 +1,9 @@
 #!/bin/bash
 set -eo pipefail
 
+unset GOOS
+unset GOARCH
+
 echo "Compiling ts..."
 # ../node_modules/.bin/tsc --out integration.js --project tsconfig.json
 ../node_modules/.bin/esbuild integration.ts --bundle --platform=node --outfile=integration.js

package/integration/integration.ts

@@ -1,4 +1,4 @@
-import { WebSocketConn } from '../srpc'
+import { WebSocketConn } from '../srpc/websocket'
 import { runClientTest } from '../echo'
 import WebSocket from 'isomorphic-ws'
 

package/package.json

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

package/srpc/client.ts

@@ -29,12 +29,45 @@ 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 the open connection function.
-  // called when starting RPC.
-  private openConnFn: OpenStreamFunc
+  // openConnFn is a promise which contains the OpenStreamFunc.
+  private openConnFn: Promise<OpenStreamFunc>
+  // _openConnFn resolves openConnFn.
+  private _openConnFn?: (conn?: OpenStreamFunc, err?: Error) => void
 
-  constructor(openConnFn: OpenStreamFunc) {
-    this.openConnFn = openConnFn
+  constructor(openConnFn?: OpenStreamFunc) {
+    this.openConnFn = this.setOpenConnFn(openConnFn)
+  }
+
+  // setOpenConnFn updates the openConnFn for the Client.
+  public setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc> {
+    if (this._openConnFn) {
+      if (openConnFn) {
+        this._openConnFn(openConnFn)
+        this._openConnFn = undefined
+      }
+    } else {
+      if (openConnFn) {
+        this.openConnFn = Promise.resolve(openConnFn)
+      } else {
+        this.initOpenConnFn()
+      }
+    }
+    return this.openConnFn
+  }
+
+  // initOpenConnFn creates the empty Promise for openConnFn.
+  private initOpenConnFn(): Promise<OpenStreamFunc> {
+    const openPromise = new Promise<OpenStreamFunc>((resolve, reject) => {
+      this._openConnFn = (conn?: OpenStreamFunc, err?: Error) => {
+        if (err) {
+          reject(err)
+        } else if (conn) {
+          resolve(conn)
+        }
+      }
+    })
+    this.openConnFn = openPromise
+    return this.openConnFn
   }
 
   // request starts a non-streaming request.
@@ -135,7 +168,8 @@ export class Client implements TsProtoRpc {
     rpcMethod: string,
     data: Uint8Array | null
   ): Promise<ClientRPC> {
-    const conn = await this.openConnFn()
+    const openConnFn = await this.openConnFn
+    const conn = await openConnFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     pipe(
       conn,

package/srpc/index.ts

@@ -4,7 +4,6 @@ export { Server } from './server.js'
 export { Conn, ConnParams } from './conn.js'
 export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js'
 export { Mux, createMux } from './mux.js'
-export { WebSocketConn } from './websocket.js'
 export {
   BroadcastChannelIterable,
   newBroadcastChannelIterable,