starpc 0.18.2 → 0.19.0

package/dist/e2e/mock/mock.pb.js

@@ -13,19 +13,23 @@ export const MockMsg = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseMockMsg();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.body = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
             }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
         }
         return message;
     },
@@ -83,7 +87,7 @@ export class MockClientImpl {
     MockRequest(request, abortSignal) {
         const data = MockMsg.encode(request).finish();
         const promise = this.rpc.request(this.service, 'MockRequest', data, abortSignal || undefined);
-        return promise.then((data) => MockMsg.decode(new _m0.Reader(data)));
+        return promise.then((data) => MockMsg.decode(_m0.Reader.create(data)));
     }
 }
 export const MockDefinition = {

package/dist/echo/echo.pb.js

@@ -14,19 +14,23 @@ export const EchoMsg = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseEchoMsg();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.body = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
             }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
         }
         return message;
     },
@@ -88,7 +92,7 @@ export class EchoerClientImpl {
     Echo(request, abortSignal) {
         const data = EchoMsg.encode(request).finish();
         const promise = this.rpc.request(this.service, 'Echo', data, abortSignal || undefined);
-        return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
+        return promise.then((data) => EchoMsg.decode(_m0.Reader.create(data)));
     }
     EchoServerStream(request, abortSignal) {
         const data = EchoMsg.encode(request).finish();
@@ -98,7 +102,7 @@ export class EchoerClientImpl {
     EchoClientStream(request, abortSignal) {
         const data = EchoMsg.encodeTransform(request);
         const promise = this.rpc.clientStreamingRequest(this.service, 'EchoClientStream', data, abortSignal || undefined);
-        return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
+        return promise.then((data) => EchoMsg.decode(_m0.Reader.create(data)));
     }
     EchoBidiStream(request, abortSignal) {
         const data = EchoMsg.encodeTransform(request);

package/dist/rpcstream/pushable-sink.js

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

package/dist/rpcstream/rpcstream.js

@@ -31,7 +31,7 @@ export async function openRpcStream(componentId, caller, waitAck) {
         }
     }
     // build & return the data stream
-    return new RpcStream(packetSink, packetIt); // packetSource)
+    return new RpcStream(packetSink, packetIt);
 }
 // buildRpcStreamOpenStream builds a OpenStream func with a RpcStream.
 export function buildRpcStreamOpenStream(componentId, caller) {

package/dist/rpcstream/rpcstream.pb.js

@@ -7,43 +7,55 @@ function createBaseRpcStreamPacket() {
 }
 export const RpcStreamPacket = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === 'init') {
-            RpcStreamInit.encode(message.body.init, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.body?.$case === 'ack') {
-            RpcAck.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
-        }
-        if (message.body?.$case === 'data') {
-            writer.uint32(26).bytes(message.body.data);
+        switch (message.body?.$case) {
+            case 'init':
+                RpcStreamInit.encode(message.body.init, writer.uint32(10).fork()).ldelim();
+                break;
+            case 'ack':
+                RpcAck.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
+                break;
+            case 'data':
+                writer.uint32(26).bytes(message.body.data);
+                break;
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseRpcStreamPacket();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.body = {
                         $case: 'init',
                         init: RpcStreamInit.decode(reader, reader.uint32()),
                     };
-                    break;
+                    continue;
                 case 2:
+                    if (tag != 18) {
+                        break;
+                    }
                     message.body = {
                         $case: 'ack',
                         ack: RpcAck.decode(reader, reader.uint32()),
                     };
-                    break;
+                    continue;
                 case 3:
+                    if (tag != 26) {
+                        break;
+                    }
                     message.body = { $case: 'data', data: reader.bytes() };
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
+            }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
             }
+            reader.skipType(tag & 7);
         }
         return message;
     },
@@ -140,19 +152,23 @@ export const RpcStreamInit = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseRpcStreamInit();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.componentId = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
             }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
         }
         return message;
     },
@@ -214,19 +230,23 @@ export const RpcAck = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseRpcAck();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.error = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
+            }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
             }
+            reader.skipType(tag & 7);
         }
         return message;
     },

package/dist/srpc/client.js

@@ -3,8 +3,7 @@ import { pushable } from 'it-pushable';
 import { ERR_RPC_ABORT } from './errors.js';
 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 { decodePacketSource, encodePacketSource, } from './packet.js';
 import { OpenStreamCtr } from './open-stream-ctr.js';
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
@@ -75,12 +74,12 @@ export class Client {
             throw new Error(ERR_RPC_ABORT);
         }
         const openStreamFn = await this.openStreamCtr.wait();
-        const conn = await openStreamFn();
+        const stream = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         abortSignal?.addEventListener('abort', () => {
             call.close(new Error(ERR_RPC_ABORT));
         });
-        pipe(conn, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);
+        pipe(stream, decodePacketSource, call, encodePacketSource, stream);
         await call.writeCallStart(data || undefined);
         return call;
     }

package/dist/srpc/common-rpc.js

@@ -77,7 +77,7 @@ export class CommonRPC {
                 asError = new Error('error handling packet');
             }
             this.close(asError);
-            throw asError;
+            // throw asError
         }
     }
     // handleCallStart handles a CallStart packet.

package/dist/srpc/conn.d.ts

@@ -9,7 +9,7 @@ export interface ConnParams {
     direction?: Direction;
 }
 export interface StreamHandler {
-    handleStream(strm: SRPCStream): void;
+    handlePacketStream(strm: SRPCStream): void;
 }
 export declare function streamToSRPCStream(stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): SRPCStream;
 export declare class Conn implements Duplex<Uint8Array> {

package/dist/srpc/conn.js

@@ -1,13 +1,19 @@
 import { pipe } from 'it-pipe';
 import { yamux } from '@chainsafe/libp2p-yamux';
 import isPromise from 'is-promise';
+import { pushable } from 'it-pushable';
 import { Client } from './client.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
+import { parseLengthPrefixTransform, prependLengthPrefixTransform } from './packet.js';
+import { buildPushableSink } from './pushable.js';
 // streamToSRPCStream converts a Stream to a SRPCStream.
+// uses length-prefix for packet framing
 export function streamToSRPCStream(stream) {
+    const pushSink = pushable({ objectMode: true });
+    pipe(pushSink, prependLengthPrefixTransform(), stream.sink);
     return {
-        source: pipe(stream, combineUint8ArrayListTransform()),
-        sink: stream.sink,
+        source: pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform()),
+        sink: buildPushableSink(pushSink),
     };
 }
 // Conn implements a generic connection with a two-way stream.
@@ -46,9 +52,13 @@ export class Conn {
     }
     // openStream implements the client open stream function.
     async openStream() {
-        const stream = this.muxer.newStream();
-        if (isPromise(stream)) {
-            return streamToSRPCStream(await stream);
+        const streamPromise = this.muxer.newStream();
+        let stream;
+        if (isPromise(streamPromise)) {
+            stream = await streamPromise;
+        }
+        else {
+            stream = streamPromise;
         }
         return streamToSRPCStream(stream);
     }
@@ -62,6 +72,6 @@ export class Conn {
         if (!server) {
             return strm.abort(new Error('server not implemented'));
         }
-        server.handleStream(streamToSRPCStream(strm));
+        server.handlePacketStream(streamToSRPCStream(strm));
     }
 }

package/dist/srpc/errors.d.ts

@@ -1,2 +1,3 @@
 export declare const ERR_RPC_ABORT = "ERR_RPC_ABORT";
 export declare function isAbortError(err: unknown): boolean;
+export declare function castToError(err: any, defaultMsg?: string): Error;

package/dist/srpc/errors.js

@@ -8,3 +8,26 @@ export function isAbortError(err) {
     const message = err.message;
     return message === ERR_RPC_ABORT;
 }
+// castToError casts an object to an Error.
+// if err is a string, uses it as the message.
+// if err is undefined, returns new Error(defaultMsg)
+export function castToError(err, defaultMsg) {
+    defaultMsg = defaultMsg || 'error';
+    if (!err) {
+        return new Error(defaultMsg);
+    }
+    if (typeof err === 'string') {
+        return new Error(err);
+    }
+    const asError = err;
+    if (asError.message) {
+        return asError;
+    }
+    if (err.toString) {
+        const errString = err.toString();
+        if (errString) {
+            return new Error(errString);
+        }
+    }
+    return new Error(defaultMsg);
+}

package/dist/srpc/index.d.ts

@@ -1,5 +1,5 @@
 export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js';
-export { ERR_RPC_ABORT, isAbortError } from './errors.js';
+export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';
@@ -9,6 +9,8 @@ export { Mux, StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
 export { MessageDefinition, DecodeMessageTransform, buildDecodeMessageTransform, EncodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
+export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, } from './packet.js';
+export { combineUint8ArrayListTransform } from './array-list.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';
-export { writeToPushable } from './pushable';
+export { writeToPushable, buildPushableSink } from './pushable.js';

package/dist/srpc/index.js

@@ -1,4 +1,4 @@
-export { ERR_RPC_ABORT, isAbortError } from './errors.js';
+export { ERR_RPC_ABORT, isAbortError, castToError } from './errors.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn } from './conn.js';
@@ -8,6 +8,8 @@ export { StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
 export { buildDecodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
+export { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, } from './packet.js';
+export { combineUint8ArrayListTransform } from './array-list.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';
-export { writeToPushable } from './pushable';
+export { writeToPushable, buildPushableSink } from './pushable.js';

package/dist/srpc/pushable.d.ts

@@ -1,2 +1,4 @@
 import { Pushable } from 'it-pushable';
+import { Sink } from 'it-stream-types';
 export declare function writeToPushable<T>(dataSource: AsyncIterable<T>, out: Pushable<T>): Promise<void>;
+export declare function buildPushableSink<T>(target: Pushable<T>): Sink<T>;

package/dist/srpc/pushable.js

@@ -1,3 +1,4 @@
+import { castToError } from './errors.js';
 // writeToPushable writes the incoming server data to the pushable.
 export async function writeToPushable(dataSource, out) {
     try {
@@ -11,3 +12,25 @@ export async function writeToPushable(dataSource, out) {
         throw err;
     }
 }
+// buildPushableSink builds a Sink from a Pushable.
+export function buildPushableSink(target) {
+    return async function pushableSink(source) {
+        try {
+            for await (const pkt of source) {
+                if (Array.isArray(pkt)) {
+                    for (const p of pkt) {
+                        target.push(p);
+                    }
+                }
+                else {
+                    target.push(pkt);
+                }
+            }
+            target.end();
+        }
+        catch (err) {
+            const error = castToError(err);
+            target.end(error);
+        }
+    };
+}

package/dist/srpc/rpcproto.pb.js

@@ -7,43 +7,55 @@ function createBasePacket() {
 }
 export const Packet = {
     encode(message, writer = _m0.Writer.create()) {
-        if (message.body?.$case === 'callStart') {
-            CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
-        }
-        if (message.body?.$case === 'callData') {
-            CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
-        }
-        if (message.body?.$case === 'callCancel') {
-            writer.uint32(24).bool(message.body.callCancel);
+        switch (message.body?.$case) {
+            case 'callStart':
+                CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
+                break;
+            case 'callData':
+                CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
+                break;
+            case 'callCancel':
+                writer.uint32(24).bool(message.body.callCancel);
+                break;
         }
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBasePacket();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.body = {
                         $case: 'callStart',
                         callStart: CallStart.decode(reader, reader.uint32()),
                     };
-                    break;
+                    continue;
                 case 2:
+                    if (tag != 18) {
+                        break;
+                    }
                     message.body = {
                         $case: 'callData',
                         callData: CallData.decode(reader, reader.uint32()),
                     };
-                    break;
+                    continue;
                 case 3:
+                    if (tag != 24) {
+                        break;
+                    }
                     message.body = { $case: 'callCancel', callCancel: reader.bool() };
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
+            }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
             }
+            reader.skipType(tag & 7);
         }
         return message;
     },
@@ -157,28 +169,41 @@ export const CallStart = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseCallStart();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.rpcService = reader.string();
-                    break;
+                    continue;
                 case 2:
+                    if (tag != 18) {
+                        break;
+                    }
                     message.rpcMethod = reader.string();
-                    break;
+                    continue;
                 case 3:
+                    if (tag != 26) {
+                        break;
+                    }
                     message.data = reader.bytes();
-                    break;
+                    continue;
                 case 4:
+                    if (tag != 32) {
+                        break;
+                    }
                     message.dataIsZero = reader.bool();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
             }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
+            }
+            reader.skipType(tag & 7);
         }
         return message;
     },
@@ -266,28 +291,41 @@ export const CallData = {
         return writer;
     },
     decode(input, length) {
-        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(input);
+        const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
         let end = length === undefined ? reader.len : reader.pos + length;
         const message = createBaseCallData();
         while (reader.pos < end) {
             const tag = reader.uint32();
             switch (tag >>> 3) {
                 case 1:
+                    if (tag != 10) {
+                        break;
+                    }
                     message.data = reader.bytes();
-                    break;
+                    continue;
                 case 2:
+                    if (tag != 16) {
+                        break;
+                    }
                     message.dataIsZero = reader.bool();
-                    break;
+                    continue;
                 case 3:
+                    if (tag != 24) {
+                        break;
+                    }
                     message.complete = reader.bool();
-                    break;
+                    continue;
                 case 4:
+                    if (tag != 34) {
+                        break;
+                    }
                     message.error = reader.string();
-                    break;
-                default:
-                    reader.skipType(tag & 7);
-                    break;
+                    continue;
+            }
+            if ((tag & 7) == 4 || tag == 0) {
+                break;
             }
+            reader.skipType(tag & 7);
         }
         return message;
     },

package/dist/srpc/server.d.ts

@@ -10,8 +10,7 @@ export declare class Server implements StreamHandler {
     constructor(lookupMethod: LookupMethod);
     get rpcStreamHandler(): RpcStreamHandler;
     startRpc(): ServerRPC;
-    handleStream(stream: Stream): ServerRPC;
-    handleDuplex(stream: Duplex<Uint8Array, Uint8Array>): ServerRPC;
-    handlePacketDuplex(stream: Duplex<Uint8Array>): ServerRPC;
-    handlePacketStream(stream: Duplex<Packet>): ServerRPC;
+    handleFragmentStream(stream: Stream): ServerRPC;
+    handlePacketStream(stream: Stream): ServerRPC;
+    handlePacketDuplex(stream: Duplex<Packet>): ServerRPC;
 }

package/dist/srpc/server.js

@@ -8,33 +8,32 @@ export class Server {
         this.lookupMethod = lookupMethod;
     }
     // rpcStreamHandler implements the RpcStreamHandler interface.
+    // uses handlePacketDuplex (expects 1 buf = 1 Packet)
     get rpcStreamHandler() {
-        return this.handleStream.bind(this);
+        return this.handlePacketStream.bind(this);
     }
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.
     startRpc() {
         return new ServerRPC(this.lookupMethod);
     }
-    // handleStream handles an incoming Uint8Array message duplex.
-    handleStream(stream) {
-        return this.handleDuplex(stream);
-    }
-    // handleDuplex handles an incoming message duplex.
-    handleDuplex(stream) {
+    // handleFragmentStream handles an incoming stream.
+    // assumes that stream does not maintain packet framing.
+    // uses length-prefixed packets for packet framing.
+    handleFragmentStream(stream) {
         const rpc = this.startRpc();
         pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), combineUint8ArrayListTransform(), stream);
         return rpc;
     }
-    // handlePacketDuplex handles an incoming Uint8Array duplex.
-    // skips the packet length prefix transform.
-    handlePacketDuplex(stream) {
+    // handlePacketStream handles an incoming Uint8Array duplex.
+    // the stream has one Uint8Array per packet w/o length prefix.
+    handlePacketStream(stream) {
         const rpc = this.startRpc();
         pipe(stream, decodePacketSource, rpc, encodePacketSource, stream);
         return rpc;
     }
-    // handlePacketStream handles an incoming Packet duplex.
-    handlePacketStream(stream) {
+    // handlePacketDuplex handles an incoming Packet duplex.
+    handlePacketDuplex(stream) {
         const rpc = this.startRpc();
         pipe(stream, rpc, stream);
         return rpc;