starpc 0.3.2 → 0.3.3

package/dist/srpc/client.d.ts

@@ -3,8 +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);
-    setOpenConnFn(openConnFn: OpenStreamFunc): void;
+    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,15 +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) {
-        this.openConnFn = 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) {
@@ -105,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/package.json

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

package/srpc/client.ts

@@ -29,17 +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) {
-    this.openConnFn = openConnFn
+  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.
@@ -140,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,