starpc 0.4.9 → 0.5.0

package/dist/rpcstream/rpcstream.d.ts

@@ -1,19 +1,19 @@
-import { Observable } from 'rxjs';
 import { RpcStreamPacket } from './rpcstream.pb.js';
 import { Server } from '../srpc/server.js';
 import { OpenStreamFunc, Stream } from '../srpc/stream.js';
 import { Pushable } from 'it-pushable';
 import { Source, Sink } from 'it-stream-types';
-export declare type RpcStreamCaller = (request: Observable<RpcStreamPacket>) => Observable<RpcStreamPacket>;
+export declare type RpcStreamCaller = (request: AsyncIterable<RpcStreamPacket>) => AsyncIterable<RpcStreamPacket>;
+export declare function openRpcStream(componentId: string, caller: RpcStreamCaller): Promise<Stream>;
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
 export declare type RpcStreamGetter = (componentId: string) => Promise<Server>;
-export declare function handleRpcStream(stream: Observable<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
+export declare function handleRpcStream(packetStream: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
 export declare class RpcStream implements Stream {
     readonly source: Source<Uint8Array>;
     readonly sink: Sink<Uint8Array>;
+    private readonly _packetStream;
     private readonly _packetSink;
-    private readonly _source;
-    constructor(packetSink: Pushable<RpcStreamPacket>, packetSource: Observable<RpcStreamPacket>);
+    constructor(packetSink: Pushable<RpcStreamPacket>, packetStream: AsyncIterator<RpcStreamPacket>);
     private _createSink;
-    private _subscribeRpcStreamPacketSource;
+    private _createSource;
 }

package/dist/rpcstream/rpcstream.js

@@ -1,50 +1,88 @@
-import { from as obsFrom } from 'rxjs';
 import { pushable } from 'it-pushable';
+// openRpcStream attempts to open a stream over a RPC call.
+// waits for the remote to ack the stream before returning.
+export async function openRpcStream(componentId, caller) {
+    const packetSink = pushable({ objectMode: true });
+    const packetSource = caller(packetSink);
+    // write the component id
+    packetSink.push({
+        body: {
+            $case: 'init',
+            init: { componentId },
+        },
+    });
+    // wait for ack
+    const packetIt = packetSource[Symbol.asyncIterator]();
+    const ackPacketIt = await packetIt.next();
+    if (ackPacketIt.done) {
+        throw new Error(`rpcstream: closed before ack packet`);
+    }
+    const ackPacket = ackPacketIt.value;
+    const ackBody = ackPacket?.body;
+    if (!ackBody || ackBody.$case !== 'ack') {
+        const msgType = ackBody?.$case || 'none';
+        throw new Error(`rpcstream: expected ack packet but got ${msgType}`);
+    }
+    const errStr = ackBody.ack?.error;
+    if (errStr) {
+        throw new Error(`rpcstream: remote: ${errStr}`);
+    }
+    // build & return the data stream
+    return new RpcStream(packetSink, packetIt); // packetSource)
+}
 // buildRpcStreamOpenStream builds a OpenStream func with a RpcStream.
 export function buildRpcStreamOpenStream(componentId, caller) {
     return async () => {
-        const packetSink = pushable({ objectMode: true });
-        const packetObs = obsFrom(packetSink);
-        const packetSource = caller(packetObs);
-        // write the component id
-        packetSink.push({
-            body: {
-                $case: 'init',
-                init: { componentId },
-            },
-        });
-        // build & return the stream
-        return new RpcStream(packetSink, packetSource);
+        return openRpcStream(componentId, caller);
     };
 }
 // handleRpcStream handles an incoming RPC stream (remote is the initiator).
-export async function* handleRpcStream(stream, getter) {
+export async function* handleRpcStream(packetStream, getter) {
     // read the component id
-    const initPromise = new Promise((resolve, reject) => {
-        const subscription = stream.subscribe({
-            next(value) {
-                resolve(value);
-                subscription.unsubscribe();
-            },
-            error(err) {
-                reject(err);
-            },
-            complete() {
-                reject(new Error('no packet received'));
-            },
-        });
-    });
-    // read the init packet
-    const initRpcStreamPacket = await initPromise;
+    const initRpcStreamIt = await packetStream.next();
+    if (initRpcStreamIt.done) {
+        throw new Error('closed before init received');
+    }
+    const initRpcStreamPacket = initRpcStreamIt.value;
+    // ensure we received an init packet
     if (initRpcStreamPacket?.body?.$case !== 'init') {
         throw new Error('expected init packet');
     }
     // lookup the server for the component id.
-    const server = await getter(initRpcStreamPacket.body.init.componentId);
+    let server;
+    let err;
+    try {
+        server = await getter(initRpcStreamPacket.body.init.componentId);
+    }
+    catch (errAny) {
+        err = errAny;
+        if (!err) {
+            err = new Error(`rpc getter failed`);
+        }
+        else if (!err.message) {
+            err = new Error(`rpc getter failed: ${err}`);
+        }
+    }
+    if (!server && !err) {
+        err = new Error('not implemented');
+    }
+    yield* [
+        {
+            body: {
+                $case: 'ack',
+                ack: {
+                    error: err?.message || '',
+                },
+            },
+        },
+    ];
+    if (err) {
+        throw err;
+    }
     // build the outgoing packet sink & the packet source
     const packetSink = pushable({ objectMode: true });
     // handle the stream
-    const rpcStream = new RpcStream(packetSink, stream);
+    const rpcStream = new RpcStream(packetSink, packetStream);
     server.handleDuplex(rpcStream);
     // process packets
     for await (const packet of packetSink) {
@@ -52,14 +90,15 @@ export async function* handleRpcStream(stream, getter) {
     }
 }
 // RpcStream implements the Stream on top of a RPC call.
+// Note: expects the stream to already have been negotiated.
 export class RpcStream {
-    constructor(packetSink, packetSource) {
+    // packetSink writes packets to the remote.
+    // packetSource receives packets from the remote.
+    constructor(packetSink, packetStream) {
         this._packetSink = packetSink;
+        this._packetStream = packetStream;
         this.sink = this._createSink();
-        const source = pushable({ objectMode: true });
-        this.source = source;
-        this._source = source;
-        this._subscribeRpcStreamPacketSource(packetSource);
+        this.source = this._createSource();
     }
     // _createSink initializes the sink field.
     _createSink() {
@@ -77,20 +116,22 @@ export class RpcStream {
             }
         };
     }
-    // _subscribeRpcStreamPacketSource starts the subscription to the response data.
-    _subscribeRpcStreamPacketSource(packetSource) {
-        packetSource.subscribe({
-            next: (value) => {
-                if (value?.body?.$case === 'data') {
-                    this._source.push(value.body.data);
+    // _createSource initializes the source field.
+    _createSource() {
+        const packetSource = this._packetStream;
+        return (async function* packetDataSource() {
+            while (true) {
+                const msgIt = await packetSource.next();
+                if (msgIt.done) {
+                    return;
                 }
-            },
-            error: (err) => {
-                this._source.end(err);
-            },
-            complete: () => {
-                this._source.end();
-            },
-        });
+                const value = msgIt.value;
+                const body = value?.body;
+                if (!body || body.$case !== 'data') {
+                    continue;
+                }
+                yield* [body.data];
+            }
+        })();
     }
 }

package/dist/rpcstream/rpcstream.pb.d.ts

@@ -1,11 +1,15 @@
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
+import { RpcStreamInit as RpcStreamInit1, RpcAck as RpcAck2 } from './rpcstream.pb.js';
 export declare const protobufPackage = "rpcstream";
 /** RpcStreamPacket is a packet encapsulating data for a RPC stream. */
 export interface RpcStreamPacket {
     body?: {
         $case: 'init';
-        init: RpcStreamInit;
+        init: RpcStreamInit1;
+    } | {
+        $case: 'ack';
+        ack: RpcAck2;
     } | {
         $case: 'data';
         data: Uint8Array;
@@ -16,9 +20,16 @@ export interface RpcStreamInit {
     /** ComponentId is the identifier of the component making the request. */
     componentId: string;
 }
+/** RpcAck is the ack message in a RPC stream. */
+export interface RpcAck {
+    /** Error indicates there was some error setting up the stream. */
+    error: string;
+}
 export declare const RpcStreamPacket: {
     encode(message: RpcStreamPacket, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): RpcStreamPacket;
+    encodeTransform(source: AsyncIterable<RpcStreamPacket | RpcStreamPacket[]> | Iterable<RpcStreamPacket | RpcStreamPacket[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<RpcStreamPacket>;
     fromJSON(object: any): RpcStreamPacket;
     toJSON(message: RpcStreamPacket): unknown;
     fromPartial<I extends {
@@ -28,6 +39,12 @@ export declare const RpcStreamPacket: {
             } | undefined;
         } & {
             $case: "init";
+        }) | ({
+            ack?: {
+                error?: string | undefined;
+            } | undefined;
+        } & {
+            $case: "ack";
         }) | ({
             data?: Uint8Array | undefined;
         } & {
@@ -48,6 +65,19 @@ export declare const RpcStreamPacket: {
             } & Record<Exclude<keyof I["body"]["init"], "componentId">, never>) | undefined;
             $case: "init";
         } & Record<Exclude<keyof I["body"], "$case" | "init">, never>) | ({
+            ack?: {
+                error?: string | undefined;
+            } | undefined;
+        } & {
+            $case: "ack";
+        } & {
+            ack?: ({
+                error?: string | undefined;
+            } & {
+                error?: string | undefined;
+            } & Record<Exclude<keyof I["body"]["ack"], "error">, never>) | undefined;
+            $case: "ack";
+        } & Record<Exclude<keyof I["body"], "$case" | "ack">, never>) | ({
             data?: Uint8Array | undefined;
         } & {
             $case: "data";
@@ -60,6 +90,8 @@ export declare const RpcStreamPacket: {
 export declare const RpcStreamInit: {
     encode(message: RpcStreamInit, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): RpcStreamInit;
+    encodeTransform(source: AsyncIterable<RpcStreamInit | RpcStreamInit[]> | Iterable<RpcStreamInit | RpcStreamInit[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<RpcStreamInit>;
     fromJSON(object: any): RpcStreamInit;
     toJSON(message: RpcStreamInit): unknown;
     fromPartial<I extends {
@@ -68,6 +100,19 @@ export declare const RpcStreamInit: {
         componentId?: string | undefined;
     } & Record<Exclude<keyof I, "componentId">, never>>(object: I): RpcStreamInit;
 };
+export declare const RpcAck: {
+    encode(message: RpcAck, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): RpcAck;
+    encodeTransform(source: AsyncIterable<RpcAck | RpcAck[]> | Iterable<RpcAck | RpcAck[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<RpcAck>;
+    fromJSON(object: any): RpcAck;
+    toJSON(message: RpcAck): unknown;
+    fromPartial<I extends {
+        error?: string | undefined;
+    } & {
+        error?: string | undefined;
+    } & Record<Exclude<keyof I, "error">, never>>(object: I): RpcAck;
+};
 declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {
     $case: string;

package/dist/rpcstream/rpcstream.pb.js

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
+import { RpcStreamInit as RpcStreamInit1, RpcAck as RpcAck2, } from './rpcstream.pb.js';
 export const protobufPackage = 'rpcstream';
 function createBaseRpcStreamPacket() {
     return { body: undefined };
@@ -8,10 +9,13 @@ 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();
+            RpcStreamInit1.encode(message.body.init, writer.uint32(10).fork()).ldelim();
+        }
+        if (message.body?.$case === 'ack') {
+            RpcAck2.encode(message.body.ack, writer.uint32(18).fork()).ldelim();
         }
         if (message.body?.$case === 'data') {
-            writer.uint32(18).bytes(message.body.data);
+            writer.uint32(26).bytes(message.body.data);
         }
         return writer;
     },
@@ -25,10 +29,16 @@ export const RpcStreamPacket = {
                 case 1:
                     message.body = {
                         $case: 'init',
-                        init: RpcStreamInit.decode(reader, reader.uint32()),
+                        init: RpcStreamInit1.decode(reader, reader.uint32()),
                     };
                     break;
                 case 2:
+                    message.body = {
+                        $case: 'ack',
+                        ack: RpcAck2.decode(reader, reader.uint32()),
+                    };
+                    break;
+                case 3:
                     message.body = { $case: 'data', data: reader.bytes() };
                     break;
                 default:
@@ -38,20 +48,54 @@ export const RpcStreamPacket = {
         }
         return message;
     },
+    // encodeTransform encodes a source of message objects.
+    // Transform<RpcStreamPacket, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [RpcStreamPacket.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [RpcStreamPacket.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, RpcStreamPacket>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [RpcStreamPacket.decode(p)];
+                }
+            }
+            else {
+                yield* [RpcStreamPacket.decode(pkt)];
+            }
+        }
+    },
     fromJSON(object) {
         return {
             body: isSet(object.init)
-                ? { $case: 'init', init: RpcStreamInit.fromJSON(object.init) }
-                : isSet(object.data)
-                    ? { $case: 'data', data: bytesFromBase64(object.data) }
-                    : undefined,
+                ? { $case: 'init', init: RpcStreamInit1.fromJSON(object.init) }
+                : isSet(object.ack)
+                    ? { $case: 'ack', ack: RpcAck2.fromJSON(object.ack) }
+                    : isSet(object.data)
+                        ? { $case: 'data', data: bytesFromBase64(object.data) }
+                        : undefined,
         };
     },
     toJSON(message) {
         const obj = {};
         message.body?.$case === 'init' &&
             (obj.init = message.body?.init
-                ? RpcStreamInit.toJSON(message.body?.init)
+                ? RpcStreamInit1.toJSON(message.body?.init)
+                : undefined);
+        message.body?.$case === 'ack' &&
+            (obj.ack = message.body?.ack
+                ? RpcAck2.toJSON(message.body?.ack)
                 : undefined);
         message.body?.$case === 'data' &&
             (obj.data =
@@ -67,9 +111,14 @@ export const RpcStreamPacket = {
             object.body?.init !== null) {
             message.body = {
                 $case: 'init',
-                init: RpcStreamInit.fromPartial(object.body.init),
+                init: RpcStreamInit1.fromPartial(object.body.init),
             };
         }
+        if (object.body?.$case === 'ack' &&
+            object.body?.ack !== undefined &&
+            object.body?.ack !== null) {
+            message.body = { $case: 'ack', ack: RpcAck2.fromPartial(object.body.ack) };
+        }
         if (object.body?.$case === 'data' &&
             object.body?.data !== undefined &&
             object.body?.data !== null) {
@@ -105,6 +154,34 @@ export const RpcStreamInit = {
         }
         return message;
     },
+    // encodeTransform encodes a source of message objects.
+    // Transform<RpcStreamInit, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [RpcStreamInit.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [RpcStreamInit.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, RpcStreamInit>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [RpcStreamInit.decode(p)];
+                }
+            }
+            else {
+                yield* [RpcStreamInit.decode(pkt)];
+            }
+        }
+    },
     fromJSON(object) {
         return {
             componentId: isSet(object.componentId) ? String(object.componentId) : '',
@@ -121,6 +198,77 @@ export const RpcStreamInit = {
         return message;
     },
 };
+function createBaseRpcAck() {
+    return { error: '' };
+}
+export const RpcAck = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.error !== '') {
+            writer.uint32(10).string(message.error);
+        }
+        return writer;
+    },
+    decode(input, length) {
+        const reader = input instanceof _m0.Reader ? input : new _m0.Reader(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:
+                    message.error = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    // encodeTransform encodes a source of message objects.
+    // Transform<RpcAck, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [RpcAck.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [RpcAck.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, RpcAck>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [RpcAck.decode(p)];
+                }
+            }
+            else {
+                yield* [RpcAck.decode(pkt)];
+            }
+        }
+    },
+    fromJSON(object) {
+        return {
+            error: isSet(object.error) ? String(object.error) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.error !== undefined && (obj.error = message.error);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRpcAck();
+        message.error = object.error ?? '';
+        return message;
+    },
+};
 var globalThis = (() => {
     if (typeof globalThis !== 'undefined')
         return globalThis;

package/dist/srpc/client.d.ts

@@ -1,4 +1,3 @@
-import { Observable } from 'rxjs';
 import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
@@ -8,8 +7,8 @@ export declare class Client implements TsProtoRpc {
     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>;
-    bidirectionalStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Observable<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
     private startRpc;
 }

package/dist/srpc/client.js

@@ -1,22 +1,8 @@
 import { pipe } from 'it-pipe';
 import { pushable } from 'it-pushable';
-import { from as observableFrom } from 'rxjs';
 import { ClientRPC } from './client-rpc.js';
+import { writeToPushable } from './pushable.js';
 import { decodePacketSource, encodePacketSource, parseLengthPrefixTransform, prependLengthPrefixTransform, } from './packet.js';
-// writeClientStream registers the subscriber to write the client data stream.
-function writeClientStream(call, data) {
-    data.subscribe({
-        next(value) {
-            call.writeCallData(value);
-        },
-        error(err) {
-            call.close(err);
-        },
-        complete() {
-            call.writeCallData(undefined, true);
-        },
-    });
-}
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
     constructor(openStreamFn) {
@@ -69,7 +55,7 @@ export class Client {
     // clientStreamingRequest starts a client side streaming request.
     async clientStreamingRequest(service, method, data) {
         const call = await this.startRpc(service, method, null);
-        writeClientStream(call, data);
+        call.writeCallDataFromSource(data);
         for await (const data of call.rpcDataSource) {
             call.close();
             return data;
@@ -80,51 +66,31 @@ export class Client {
     }
     // serverStreamingRequest starts a server-side streaming request.
     serverStreamingRequest(service, method, data) {
-        const pushServerData = pushable({ objectMode: true });
-        const serverData = observableFrom(pushServerData);
+        const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, data)
             .then(async (call) => {
-            try {
-                for await (const data of call.rpcDataSource) {
-                    pushServerData.push(data);
-                }
-            }
-            catch (err) {
-                pushServerData.throw(err);
-            }
-            pushServerData.end();
+            return writeToPushable(call.rpcDataSource, serverData);
         })
-            .catch(pushServerData.throw.bind(pushServerData));
+            .catch(serverData.throw.bind(serverData));
         return serverData;
     }
     // bidirectionalStreamingRequest starts a two-way streaming request.
     bidirectionalStreamingRequest(service, method, data) {
-        const pushServerData = pushable({ objectMode: true });
-        const serverData = observableFrom(pushServerData);
+        const serverData = pushable({ objectMode: true });
         this.startRpc(service, method, null)
             .then(async (call) => {
+            call.writeCallDataFromSource(data);
             try {
-                data.subscribe({
-                    next(value) {
-                        call.writeCallData(value);
-                    },
-                    error(err) {
-                        call.close(err);
-                    },
-                    complete() {
-                        call.close();
-                    },
-                });
-                for await (const data of call.rpcDataSource) {
-                    pushServerData.push(data);
+                for await (const message of call.rpcDataSource) {
+                    serverData.push(message);
                 }
             }
             catch (err) {
-                pushServerData.throw(err);
+                serverData.throw(err);
             }
-            pushServerData.end();
+            serverData.end();
         })
-            .catch(pushServerData.throw.bind(pushServerData));
+            .catch(serverData.throw.bind(serverData));
         return serverData;
     }
     // startRpc is a common utility function to begin a rpc call.

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

@@ -1,16 +1,17 @@
-import type { Source, Sink } from 'it-stream-types';
+import type { Sink } from 'it-stream-types';
 import type { CallData, CallStart } from './rpcproto.pb.js';
 import { Packet } from './rpcproto.pb.js';
 export declare class CommonRPC {
     sink: Sink<Packet>;
     source: AsyncIterable<Packet>;
     private readonly _source;
-    readonly rpcDataSource: Source<Uint8Array>;
+    readonly rpcDataSource: AsyncIterable<Uint8Array>;
     private readonly _rpcDataSource;
     protected service?: string;
     protected method?: string;
     constructor();
     writeCallData(data?: Uint8Array, complete?: boolean, error?: string): Promise<void>;
+    writeCallDataFromSource(dataSource: AsyncIterable<Uint8Array>): Promise<void>;
     protected writePacket(packet: Packet): Promise<void>;
     handleMessage(message: Uint8Array): Promise<void>;
     handlePacket(packet: Partial<Packet>): Promise<void>;

package/dist/srpc/common-rpc.js

@@ -26,6 +26,18 @@ export class CommonRPC {
             },
         });
     }
+    // writeCallDataFromSource writes all call data from the iterable.
+    async writeCallDataFromSource(dataSource) {
+        try {
+            for await (const data of dataSource) {
+                this.writeCallData(data);
+            }
+            this.writeCallData(undefined, true);
+        }
+        catch (err) {
+            this.close(err);
+        }
+    }
     // writePacket writes a packet to the stream.
     async writePacket(packet) {
         this._source.push(packet);