starpc 0.3.6 → 0.4.2

package/Makefile

@@ -1,13 +1,18 @@
+# https://github.com/aperturerobotics/protobuf-project
+
 PROTOWRAP=hack/bin/protowrap
 PROTOC_GEN_GO=hack/bin/protoc-gen-go
+PROTOC_GEN_GO_STARPC=hack/bin/protoc-gen-go-starpc
 PROTOC_GEN_VTPROTO=hack/bin/protoc-gen-go-vtproto
-PROTOC_GEN_STARPC=hack/bin/protoc-gen-go-starpc
 GOIMPORTS=hack/bin/goimports
 GOLANGCI_LINT=hack/bin/golangci-lint
 GO_MOD_OUTDATED=hack/bin/go-mod-outdated
-export GO111MODULE=on
 GOLIST=go list -f "{{ .Dir }}" -m
 
+export GO111MODULE=on
+undefine GOARCH
+undefine GOOS
+
 all:
 
 vendor:
@@ -17,19 +22,19 @@ $(PROTOC_GEN_GO):
 	cd ./hack; \
 	go build -v \
 		-o ./bin/protoc-gen-go \
-		github.com/golang/protobuf/protoc-gen-go
+		google.golang.org/protobuf/cmd/protoc-gen-go
 
-$(PROTOC_GEN_VTPROTO):
+$(PROTOC_GEN_GO_STARPC):
 	cd ./hack; \
 	go build -v \
-		-o ./bin/protoc-gen-go-vtproto \
-		github.com/planetscale/vtprotobuf/cmd/protoc-gen-go-vtproto
+		-o ./bin/protoc-gen-go-starpc \
+		github.com/aperturerobotics/starpc/cmd/protoc-gen-go-starpc
 
-$(PROTOC_GEN_STARPC):
+$(PROTOC_GEN_VTPROTO):
 	cd ./hack; \
 	go build -v \
-		-o ./bin/protoc-gen-go-starpc \
-		github.com/aperturerobotics/starpc/cmd/protoc-gen-go-starpc
+		-o ./bin/protoc-gen-go-vtproto \
+		github.com/planetscale/vtprotobuf/cmd/protoc-gen-go-vtproto
 
 $(GOIMPORTS):
 	cd ./hack; \
@@ -56,7 +61,7 @@ $(GO_MOD_OUTDATED):
 		github.com/psampaz/go-mod-outdated
 
 .PHONY: gengo
-gengo: $(GOIMPORTS) $(PROTOWRAP) $(PROTOC_GEN_GO) $(PROTOC_GEN_VTPROTO) $(PROTOC_GEN_STARPC)
+gengo: $(GOIMPORTS) $(PROTOWRAP) $(PROTOC_GEN_GO) $(PROTOC_GEN_GO_STARPC) $(PROTOC_GEN_VTPROTO)
 	go mod vendor
 	shopt -s globstar; \
 	set -eo pipefail; \
@@ -99,9 +104,10 @@ gents: $(PROTOWRAP) node_modules
 		-I $$(pwd)/vendor \
 		--plugin=./node_modules/.bin/protoc-gen-ts_proto \
 		--ts_proto_out=$$(pwd)/vendor \
+		--ts_proto_opt=esModuleInterop=true \
+		--ts_proto_opt=fileSuffix=.pb \
 		--ts_proto_opt=forceLong=long \
 		--ts_proto_opt=oneof=unions \
-		--ts_proto_opt=esModuleInterop=true \
 		--ts_proto_opt=outputServices=default,outputServices=generic-definitions \
 		--proto_path $$(pwd)/vendor \
 		--print_structure \
@@ -119,15 +125,19 @@ genproto: gengo gents
 .PHONY: gen
 gen: genproto
 
+.PHONY: outdated
 outdated: $(GO_MOD_OUTDATED)
 	go list -mod=mod -u -m -json all | $(GO_MOD_OUTDATED) -update -direct
 
+.PHONY: list
 list: $(GO_MOD_OUTDATED)
 	go list -mod=mod -u -m -json all | $(GO_MOD_OUTDATED)
 
+.PHONY: lint
 lint: $(GOLANGCI_LINT)
 	$(GOLANGCI_LINT) run
 
+.PHONY: fix
 fix: $(GOLANGCI_LINT)
 	$(GOLANGCI_LINT) run --fix
 
@@ -137,5 +147,4 @@ test:
 
 .PHONY: integration
 integration: node_modules vendor
-	cd ./integration && \
-		bash ./integration.bash
+	cd ./integration && bash ./integration.bash

package/README.md

@@ -13,6 +13,10 @@ Can use any Stream multiplexer: defaults to [libp2p-mplex] over a WebSocket.
 
 [libp2p-mplex]: https://github.com/libp2p/js-libp2p-mplex
 
+[rpcstream] supports sub-streams for per-component sub-services.
+
+[rpcstream]: ./rpcstream
+
 # Usage
 
 Starting with the [protobuf-project] repository on the "starpc" branch.

package/dist/echo/client-test.js

@@ -1,4 +1,4 @@
-import { EchoerClientImpl } from './echo.js';
+import { EchoerClientImpl } from './echo.pb.js';
 import { Observable } from 'rxjs';
 export async function runClientTest(client) {
     const demoServiceClient = new EchoerClientImpl(client);

package/dist/echo/index.d.ts

@@ -1,3 +1,3 @@
-export * from './echo.js';
+export * from './echo.pb.js';
 export * from './server.js';
 export { runClientTest } from './client-test.js';

package/dist/echo/index.js

@@ -1,3 +1,3 @@
-export * from './echo.js';
+export * from './echo.pb.js';
 export * from './server.js';
 export { runClientTest } from './client-test.js';

package/dist/echo/server.d.ts

@@ -1,5 +1,5 @@
 import { Observable } from 'rxjs';
-import { Echoer, EchoMsg } from './echo';
+import { Echoer, EchoMsg } from './echo.pb.js';
 export declare class EchoerServer implements Echoer {
     Echo(request: EchoMsg): Promise<EchoMsg>;
     EchoServerStream(request: EchoMsg): Observable<EchoMsg>;

package/dist/rpcstream/rpcstream.d.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+import { Packet } 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<Packet>) => Observable<Packet>;
+export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
+export declare type RpcStreamGetter = (componentId: string) => Promise<Server>;
+export declare function handleRpcStream(stream: Observable<Packet>, getter: RpcStreamGetter): AsyncIterable<Packet>;
+export declare class RpcStream implements Stream {
+    readonly source: Source<Uint8Array>;
+    readonly sink: Sink<Uint8Array>;
+    private readonly _packetSink;
+    private readonly _source;
+    constructor(packetSink: Pushable<Packet>, packetSource: Observable<Packet>);
+    private _createSink;
+    private _subscribePacketSource;
+}

package/dist/rpcstream/rpcstream.js

@@ -0,0 +1,94 @@
+import { from as obsFrom } from 'rxjs';
+import { pushable } from 'it-pushable';
+// 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);
+    };
+}
+// handleRpcStream handles an incoming RPC stream (remote is the initiator).
+export async function* handleRpcStream(stream, 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 initPacket = await initPromise;
+    if (initPacket?.body?.$case !== 'init') {
+        throw new Error('expected init packet');
+    }
+    // lookup the server for the component id.
+    const server = await getter(initPacket.body.init.componentId);
+    // build the outgoing packet sink & the packet source
+    const packetSink = pushable({ objectMode: true });
+    // handle the stream
+    const rpcStream = new RpcStream(packetSink, stream);
+    server.handleDuplex(rpcStream);
+    // return the outgoing packet sink
+    return packetSink;
+}
+// RpcStream implements the Stream on top of a RPC call.
+export class RpcStream {
+    constructor(packetSink, packetSource) {
+        this._packetSink = packetSink;
+        this.sink = this._createSink();
+        const source = pushable({ objectMode: true });
+        this.source = source;
+        this._source = source;
+        this._subscribePacketSource(packetSource);
+    }
+    // _createSink initializes the sink field.
+    _createSink() {
+        return async (source) => {
+            try {
+                for await (const msg of source) {
+                    this._packetSink.push({
+                        body: { $case: 'data', data: msg }
+                    });
+                }
+                this._packetSink.end();
+            }
+            catch (err) {
+                this._packetSink.end(err);
+            }
+        };
+    }
+    // _subscribePacketSource starts the subscription to the response data.
+    _subscribePacketSource(packetSource) {
+        packetSource.subscribe({
+            next: (value) => {
+                if (value?.body?.$case === 'data') {
+                    this._source.push(value.body.data);
+                }
+            },
+            error: (err) => {
+                this._source.end(err);
+            },
+            complete: () => {
+                this._source.end();
+            },
+        });
+    }
+}

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

@@ -0,0 +1,85 @@
+import Long from 'long';
+import * as _m0 from 'protobufjs/minimal';
+export declare const protobufPackage = "rpcstream";
+/** Packet is a packet encapsulating data for a RPC stream. */
+export interface Packet {
+    body?: {
+        $case: 'init';
+        init: RpcStreamInit;
+    } | {
+        $case: 'data';
+        data: Uint8Array;
+    };
+}
+/** RpcStreamInit is the first message in a RPC stream. */
+export interface RpcStreamInit {
+    /** ComponentId is the identifier of the component making the request. */
+    componentId: string;
+}
+export declare const Packet: {
+    encode(message: Packet, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): Packet;
+    fromJSON(object: any): Packet;
+    toJSON(message: Packet): unknown;
+    fromPartial<I extends {
+        body?: ({
+            init?: {
+                componentId?: string | undefined;
+            } | undefined;
+        } & {
+            $case: "init";
+        }) | ({
+            data?: Uint8Array | undefined;
+        } & {
+            $case: "data";
+        }) | undefined;
+    } & {
+        body?: ({
+            init?: {
+                componentId?: string | undefined;
+            } | undefined;
+        } & {
+            $case: "init";
+        } & {
+            init?: ({
+                componentId?: string | undefined;
+            } & {
+                componentId?: string | undefined;
+            } & Record<Exclude<keyof I["body"]["init"], "componentId">, never>) | undefined;
+            $case: "init";
+        } & Record<Exclude<keyof I["body"], "$case" | "init">, never>) | ({
+            data?: Uint8Array | undefined;
+        } & {
+            $case: "data";
+        } & {
+            data?: Uint8Array | undefined;
+            $case: "data";
+        } & Record<Exclude<keyof I["body"], "$case" | "data">, never>) | undefined;
+    } & Record<Exclude<keyof I, "body">, never>>(object: I): Packet;
+};
+export declare const RpcStreamInit: {
+    encode(message: RpcStreamInit, writer?: _m0.Writer): _m0.Writer;
+    decode(input: _m0.Reader | Uint8Array, length?: number): RpcStreamInit;
+    fromJSON(object: any): RpcStreamInit;
+    toJSON(message: RpcStreamInit): unknown;
+    fromPartial<I extends {
+        componentId?: string | undefined;
+    } & {
+        componentId?: string | undefined;
+    } & Record<Exclude<keyof I, "componentId">, never>>(object: I): RpcStreamInit;
+};
+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;
+} ? {
+    [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]>;
+} & {
+    $case: T['$case'];
+} : T extends {} ? {
+    [K in keyof T]?: DeepPartial<T[K]>;
+} : Partial<T>;
+declare type KeysOfUnion<T> = T extends T ? keyof T : never;
+export declare type Exact<P, I extends P> = P extends Builtin ? P : P & {
+    [K in keyof P]: Exact<P[K], I[K]>;
+} & Record<Exclude<keyof I, KeysOfUnion<P>>, never>;
+export {};

package/dist/rpcstream/rpcstream.pb.js

@@ -0,0 +1,160 @@
+/* eslint-disable */
+import Long from 'long';
+import * as _m0 from 'protobufjs/minimal';
+export const protobufPackage = 'rpcstream';
+function createBasePacket() {
+    return { body: undefined };
+}
+export const Packet = {
+    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 === 'data') {
+            writer.uint32(18).bytes(message.body.data);
+        }
+        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 = createBasePacket();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.body = {
+                        $case: 'init',
+                        init: RpcStreamInit.decode(reader, reader.uint32()),
+                    };
+                    break;
+                case 2:
+                    message.body = { $case: 'data', data: reader.bytes() };
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            body: isSet(object.init)
+                ? { $case: 'init', init: RpcStreamInit.fromJSON(object.init) }
+                : 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)
+                : undefined);
+        message.body?.$case === 'data' &&
+            (obj.data =
+                message.body?.data !== undefined
+                    ? base64FromBytes(message.body?.data)
+                    : undefined);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBasePacket();
+        if (object.body?.$case === 'init' &&
+            object.body?.init !== undefined &&
+            object.body?.init !== null) {
+            message.body = {
+                $case: 'init',
+                init: RpcStreamInit.fromPartial(object.body.init),
+            };
+        }
+        if (object.body?.$case === 'data' &&
+            object.body?.data !== undefined &&
+            object.body?.data !== null) {
+            message.body = { $case: 'data', data: object.body.data };
+        }
+        return message;
+    },
+};
+function createBaseRpcStreamInit() {
+    return { componentId: '' };
+}
+export const RpcStreamInit = {
+    encode(message, writer = _m0.Writer.create()) {
+        if (message.componentId !== '') {
+            writer.uint32(10).string(message.componentId);
+        }
+        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 = createBaseRpcStreamInit();
+        while (reader.pos < end) {
+            const tag = reader.uint32();
+            switch (tag >>> 3) {
+                case 1:
+                    message.componentId = reader.string();
+                    break;
+                default:
+                    reader.skipType(tag & 7);
+                    break;
+            }
+        }
+        return message;
+    },
+    fromJSON(object) {
+        return {
+            componentId: isSet(object.componentId) ? String(object.componentId) : '',
+        };
+    },
+    toJSON(message) {
+        const obj = {};
+        message.componentId !== undefined && (obj.componentId = message.componentId);
+        return obj;
+    },
+    fromPartial(object) {
+        const message = createBaseRpcStreamInit();
+        message.componentId = object.componentId ?? '';
+        return message;
+    },
+};
+var globalThis = (() => {
+    if (typeof globalThis !== 'undefined')
+        return globalThis;
+    if (typeof self !== 'undefined')
+        return self;
+    if (typeof window !== 'undefined')
+        return window;
+    if (typeof global !== 'undefined')
+        return global;
+    throw 'Unable to locate global object';
+})();
+const atob = globalThis.atob ||
+    ((b64) => globalThis.Buffer.from(b64, 'base64').toString('binary'));
+function bytesFromBase64(b64) {
+    const bin = atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+        arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+}
+const btoa = globalThis.btoa ||
+    ((bin) => globalThis.Buffer.from(bin, 'binary').toString('base64'));
+function base64FromBytes(arr) {
+    const bin = [];
+    arr.forEach((byte) => {
+        bin.push(String.fromCharCode(byte));
+    });
+    return btoa(bin.join(''));
+}
+if (_m0.util.Long !== Long) {
+    _m0.util.Long = Long;
+    _m0.configure();
+}
+function isSet(value) {
+    return value !== null && value !== undefined;
+}

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

@@ -1,4 +1,4 @@
-import type { CallStart } from './rpcproto.js';
+import type { CallStart } from './rpcproto.pb.js';
 import { CommonRPC } from './common-rpc.js';
 export declare class ClientRPC extends CommonRPC {
     constructor(service: string, method: string);

package/dist/srpc/client.d.ts

@@ -2,11 +2,11 @@ import { Observable } from 'rxjs';
 import type { TsProtoRpc } from './ts-proto-rpc.js';
 import type { OpenStreamFunc } from './stream.js';
 export declare class Client implements TsProtoRpc {
-    private openConnFn;
-    private _openConnFn?;
-    constructor(openConnFn?: OpenStreamFunc);
-    setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc>;
-    private initOpenConnFn;
+    private openStreamFn;
+    private _openStreamFn?;
+    constructor(openStreamFn?: OpenStreamFunc);
+    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>;

package/dist/srpc/client.js

@@ -19,31 +19,31 @@ function writeClientStream(call, data) {
 }
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
 export class Client {
-    constructor(openConnFn) {
-        this.openConnFn = this.setOpenConnFn(openConnFn);
+    constructor(openStreamFn) {
+        this.openStreamFn = this.setOpenStreamFn(openStreamFn);
     }
-    // setOpenConnFn updates the openConnFn for the Client.
-    setOpenConnFn(openConnFn) {
-        if (this._openConnFn) {
-            if (openConnFn) {
-                this._openConnFn(openConnFn);
-                this._openConnFn = undefined;
+    // setOpenStreamFn updates the openStreamFn for the Client.
+    setOpenStreamFn(openStreamFn) {
+        if (this._openStreamFn) {
+            if (openStreamFn) {
+                this._openStreamFn(openStreamFn);
+                this._openStreamFn = undefined;
             }
         }
         else {
-            if (openConnFn) {
-                this.openConnFn = Promise.resolve(openConnFn);
+            if (openStreamFn) {
+                this.openStreamFn = Promise.resolve(openStreamFn);
             }
             else {
-                this.initOpenConnFn();
+                this.initOpenStreamFn();
             }
         }
-        return this.openConnFn;
+        return this.openStreamFn;
     }
-    // initOpenConnFn creates the empty Promise for openConnFn.
-    initOpenConnFn() {
+    // initOpenStreamFn creates the empty Promise for openStreamFn.
+    initOpenStreamFn() {
         const openPromise = new Promise((resolve, reject) => {
-            this._openConnFn = (conn, err) => {
+            this._openStreamFn = (conn, err) => {
                 if (err) {
                     reject(err);
                 }
@@ -52,8 +52,8 @@ export class Client {
                 }
             };
         });
-        this.openConnFn = openPromise;
-        return this.openConnFn;
+        this.openStreamFn = openPromise;
+        return this.openStreamFn;
     }
     // request starts a non-streaming request.
     async request(service, method, data) {
@@ -131,8 +131,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 openConnFn = await this.openConnFn;
-        const conn = await openConnFn();
+        const openStreamFn = await this.openStreamFn;
+        const conn = await openStreamFn();
         const call = new ClientRPC(rpcService, rpcMethod);
         pipe(conn, parseLengthPrefixTransform(), decodePacketSource, call, encodePacketSource, prependLengthPrefixTransform(), conn);
         await call.writeCallStart(data || undefined);

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

@@ -1,6 +1,6 @@
 import type { Source, Sink } from 'it-stream-types';
-import type { CallData, CallStart } from './rpcproto.js';
-import { Packet } from './rpcproto.js';
+import type { CallData, CallStart } from './rpcproto.pb.js';
+import { Packet } from './rpcproto.pb.js';
 export declare class CommonRPC {
     sink: Sink<Packet>;
     source: AsyncIterable<Packet>;

package/dist/srpc/common-rpc.js

@@ -1,5 +1,5 @@
 import { pushable } from 'it-pushable';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {
     constructor() {

package/dist/srpc/conn.d.ts

@@ -7,7 +7,7 @@ export interface ConnParams {
     muxerFactory?: StreamMuxerFactory;
 }
 export interface StreamHandler {
-    handleStream(strm: Duplex<Uint8Array>): Promise<void>;
+    handleStream(strm: Duplex<Uint8Array>): void;
 }
 export declare class Conn implements Duplex<Uint8Array> {
     private muxer;

package/dist/srpc/index.d.ts

@@ -1,4 +1,4 @@
-export type { OpenStreamFunc } from './stream.js';
+export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js';
 export { Client } from './client.js';
 export { Server } from './server.js';
 export { Conn, ConnParams } from './conn.js';
@@ -6,3 +6,4 @@ export { Handler, InvokeFn, createHandler, createInvokeFn } from './handler.js';
 export { Mux, createMux } from './mux.js';
 export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
+export { ObservableSource } from './observable-source.js';

package/dist/srpc/index.js

@@ -5,3 +5,4 @@ export { createHandler, createInvokeFn } from './handler.js';
 export { createMux } from './mux.js';
 export { BroadcastChannelIterable, newBroadcastChannelIterable, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
+export { ObservableSource } from './observable-source.js';

package/dist/srpc/observable-source.d.ts

@@ -0,0 +1,9 @@
+import { Source } from 'it-stream-types';
+import { Observable } from 'rxjs';
+export declare class ObservableSource<T> {
+    readonly source: Source<T>;
+    private readonly _source;
+    private readonly subscription;
+    constructor(observable: Observable<T>);
+    close(err?: Error): void;
+}

package/dist/srpc/observable-source.js

@@ -0,0 +1,25 @@
+import { pushable } from 'it-pushable';
+// ObservableSource wraps an Observable into a Source.
+export class ObservableSource {
+    constructor(observable) {
+        const source = pushable({ objectMode: true });
+        this.source = source;
+        this._source = source;
+        this.subscription = observable.subscribe({
+            next: (value) => {
+                this._source.push(value);
+            },
+            error: (err) => {
+                this._source.end(err);
+            },
+            complete: () => {
+                this._source.end();
+            },
+        });
+    }
+    // close closes the subscription.
+    close(err) {
+        this._source.end(err);
+        this.subscription.unsubscribe();
+    }
+}

package/dist/srpc/packet.d.ts

@@ -1,5 +1,5 @@
 import type { Transform } from 'it-stream-types';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 export declare const decodePacketSource: (source: import("it-stream-types").Source<Uint8Array | Uint8Array[]>) => AsyncIterable<Packet>;
 export declare const encodePacketSource: (source: import("it-stream-types").Source<Packet | Packet[]>) => AsyncIterable<Uint8Array>;
 export declare function prependLengthPrefixTransform(): Transform<Uint8Array>;

package/dist/srpc/packet.js

@@ -1,5 +1,5 @@
 import { encode as lengthPrefixEncode, decode as lengthPrefixDecode, } from 'it-length-prefixed';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
 // decodePacketSource decodes packets from a binary data stream.
 export const decodePacketSource = buildDecodeMessageTransform(Packet);

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

@@ -1,4 +1,4 @@
-import type { CallData, CallStart } from './rpcproto.js';
+import type { CallData, CallStart } from './rpcproto.pb.js';
 import { CommonRPC } from './common-rpc.js';
 import { Mux } from './mux.js';
 export declare class ServerRPC extends CommonRPC {

package/dist/srpc/server.d.ts

@@ -2,13 +2,13 @@ import { Stream } from '@libp2p/interface-connection';
 import { Duplex } from 'it-stream-types';
 import { Mux } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
-import { Packet } from './rpcproto.js';
+import { Packet } from './rpcproto.pb.js';
 import { StreamHandler } from './conn.js';
 export declare class Server implements StreamHandler {
     private mux;
     constructor(mux: Mux);
     startRpc(): ServerRPC;
-    handleStream(stream: Stream): Promise<void>;
-    handleDuplex(stream: Duplex<Uint8Array>): Promise<void>;
-    handlePacketStream(stream: Duplex<Packet>): Promise<void>;
+    handleStream(stream: Stream): ServerRPC;
+    handleDuplex(stream: Duplex<Uint8Array>): ServerRPC;
+    handlePacketStream(stream: Duplex<Packet>): ServerRPC;
 }

package/dist/srpc/server.js

@@ -12,18 +12,19 @@ export class Server {
         return new ServerRPC(this.mux);
     }
     // handleStream handles an incoming Uint8Array message duplex.
-    // closes the stream when the rpc completes.
     handleStream(stream) {
         return this.handleDuplex(stream);
     }
     // handleDuplex handles an incoming message duplex.
-    async handleDuplex(stream) {
+    handleDuplex(stream) {
         const rpc = this.startRpc();
-        await pipe(stream, parseLengthPrefixTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), stream);
+        pipe(stream, parseLengthPrefixTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), stream);
+        return rpc;
     }
     // handlePacketStream handles an incoming Packet duplex.
-    async handlePacketStream(stream) {
+    handlePacketStream(stream) {
         const rpc = this.startRpc();
-        await pipe(stream, rpc, stream);
+        pipe(stream, rpc, stream);
+        return rpc;
     }
 }

package/dist/srpc/stream.d.ts

@@ -1,4 +1,4 @@
-import type { Packet } from './rpcproto';
+import type { Packet } from './rpcproto.pb.js';
 import type { Duplex } from 'it-stream-types';
 export declare type PacketHandler = (packet: Packet) => Promise<void>;
 export declare type Stream = Duplex<Uint8Array>;

package/echo/client-test.ts

@@ -1,5 +1,5 @@
 import { Client } from '../srpc/index.js'
-import { EchoerClientImpl, EchoMsg } from './echo.js'
+import { EchoerClientImpl, EchoMsg } from './echo.pb.js'
 import { Observable } from 'rxjs'
 
 export async function runClientTest(client: Client) {

package/echo/index.ts

@@ -1,3 +1,3 @@
-export * from './echo.js'
+export * from './echo.pb.js'
 export * from './server.js'
 export { runClientTest } from './client-test.js'

package/echo/server.ts

@@ -1,5 +1,5 @@
 import { Observable, from as observableFrom } from 'rxjs'
-import { Echoer, EchoMsg } from './echo'
+import { Echoer, EchoMsg } from './echo.pb.js'
 import { pushable, Pushable } from 'it-pushable'
 
 // EchoServer implements the Echoer server.

package/integration/integration.ts

@@ -1,5 +1,5 @@
-import { WebSocketConn } from '../srpc/websocket'
-import { runClientTest } from '../echo'
+import { WebSocketConn } from '../srpc/websocket.js'
+import { runClientTest } from '../echo/client-test.js'
 import WebSocket from 'isomorphic-ws'
 
 async function runRPC() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.3.6",
+  "version": "0.4.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -22,6 +22,7 @@
     "Makefile",
     "dist/echo",
     "dist/srpc",
+    "dist/rpcstream",
     "e2e",
     "echo",
     "go.mod",
@@ -39,7 +40,7 @@
     "deps": "depcheck",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
-    "format": "prettier --write './{srpc,echo,e2e,integration}/**/(*.ts|*.tsx|*.html|*.css)'",
+    "format": "prettier --write './{srpc,echo,e2e,integration,rpcstream}/**/(*.ts|*.tsx|*.html|*.css)'",
     "gen": "make genproto",
     "test": "npm run test:js && npm run test:go",
     "test:go": "make test",
@@ -48,7 +49,7 @@
     "integration": "npm run test:integration",
     "lint": "npm run lint:go && npm run lint:js",
     "lint:go": "make lint",
-    "lint:js": "eslint -c .eslintrc.js --ext .ts ./{srpc,echo}/**/*.ts",
+    "lint:js": "eslint -c .eslintrc.js --ext .ts ./{srpc,echo,rpcstream}/**/*.ts",
     "prepare": "patch-package",
     "precommit": "npm run format"
   },

package/srpc/broadcast-channel.ts

@@ -46,8 +46,8 @@ export class BroadcastChannelIterable<T> implements Duplex<T> {
           queue.push(ev.data)
         }
       }
-      this.readChannel.addEventListener('message', messageListener)
 
+      this.readChannel.addEventListener('message', messageListener)
       return () => {
         this.readChannel.removeEventListener('message', messageListener)
       }

package/srpc/client-rpc.ts

@@ -1,4 +1,4 @@
-import type { CallStart } from './rpcproto.js'
+import type { CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 
 // ClientRPC is an ongoing RPC from the client side.

package/srpc/client.go

@@ -19,7 +19,7 @@ type Client interface {
 
 // OpenStreamFunc opens a stream with a remote.
 // msgHandler must not be called concurrently.
-type OpenStreamFunc = func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error)
+type OpenStreamFunc = func(ctx context.Context, msgHandler PacketHandler) (Writer, error)
 
 // client implements Client with a transport.
 type client struct {
@@ -89,7 +89,7 @@ func (c *client) NewStream(ctx context.Context, service, method string, firstMsg
 		return nil, err
 	}
 
-	return NewRPCStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
+	return NewMsgStream(ctx, clientRPC.writer, clientRPC.dataCh), nil
 }
 
 // _ is a type assertion

package/srpc/client.ts

@@ -29,36 +29,38 @@ 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 a promise which contains the OpenStreamFunc.
-  private openConnFn: Promise<OpenStreamFunc>
-  // _openConnFn resolves openConnFn.
-  private _openConnFn?: (conn?: OpenStreamFunc, err?: Error) => void
+  // openStreamFn is a promise which contains the OpenStreamFunc.
+  private openStreamFn: Promise<OpenStreamFunc>
+  // _openStreamFn resolves openStreamFn.
+  private _openStreamFn?: (conn?: OpenStreamFunc, err?: Error) => void
 
-  constructor(openConnFn?: OpenStreamFunc) {
-    this.openConnFn = this.setOpenConnFn(openConnFn)
+  constructor(openStreamFn?: OpenStreamFunc) {
+    this.openStreamFn = this.setOpenStreamFn(openStreamFn)
   }
 
-  // setOpenConnFn updates the openConnFn for the Client.
-  public setOpenConnFn(openConnFn?: OpenStreamFunc): Promise<OpenStreamFunc> {
-    if (this._openConnFn) {
-      if (openConnFn) {
-        this._openConnFn(openConnFn)
-        this._openConnFn = 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 (openConnFn) {
-        this.openConnFn = Promise.resolve(openConnFn)
+      if (openStreamFn) {
+        this.openStreamFn = Promise.resolve(openStreamFn)
       } else {
-        this.initOpenConnFn()
+        this.initOpenStreamFn()
       }
     }
-    return this.openConnFn
+    return this.openStreamFn
   }
 
-  // initOpenConnFn creates the empty Promise for openConnFn.
-  private initOpenConnFn(): Promise<OpenStreamFunc> {
+  // initOpenStreamFn creates the empty Promise for openStreamFn.
+  private initOpenStreamFn(): Promise<OpenStreamFunc> {
     const openPromise = new Promise<OpenStreamFunc>((resolve, reject) => {
-      this._openConnFn = (conn?: OpenStreamFunc, err?: Error) => {
+      this._openStreamFn = (conn?: OpenStreamFunc, err?: Error) => {
         if (err) {
           reject(err)
         } else if (conn) {
@@ -66,8 +68,8 @@ export class Client implements TsProtoRpc {
         }
       }
     })
-    this.openConnFn = openPromise
-    return this.openConnFn
+    this.openStreamFn = openPromise
+    return this.openStreamFn
   }
 
   // request starts a non-streaming request.
@@ -168,8 +170,8 @@ export class Client implements TsProtoRpc {
     rpcMethod: string,
     data: Uint8Array | null
   ): Promise<ClientRPC> {
-    const openConnFn = await this.openConnFn
-    const conn = await openConnFn()
+    const openStreamFn = await this.openStreamFn
+    const conn = await openStreamFn()
     const call = new ClientRPC(rpcService, rpcMethod)
     pipe(
       conn,

package/srpc/common-rpc.ts

@@ -1,8 +1,8 @@
 import type { Source, Sink } from 'it-stream-types'
 import { pushable } from 'it-pushable'
 
-import type { CallData, CallStart } from './rpcproto.js'
-import { Packet } from './rpcproto.js'
+import type { CallData, CallStart } from './rpcproto.pb.js'
+import { Packet } from './rpcproto.pb.js'
 
 // CommonRPC is common logic between server and client RPCs.
 export class CommonRPC {

package/srpc/conn.ts

@@ -19,7 +19,7 @@ export interface ConnParams {
 // Implemented by Server.
 export interface StreamHandler {
   // handleStream handles an incoming stream.
-  handleStream(strm: Duplex<Uint8Array>): Promise<void>
+  handleStream(strm: Duplex<Uint8Array>): void
 }
 
 // Conn implements a generic connection with a two-way stream.

package/srpc/index.ts

@@ -1,4 +1,4 @@
-export type { OpenStreamFunc } from './stream.js'
+export type { PacketHandler, Stream, OpenStreamFunc } from './stream.js'
 export { Client } from './client.js'
 export { Server } from './server.js'
 export { Conn, ConnParams } from './conn.js'
@@ -9,9 +9,9 @@ export {
   newBroadcastChannelIterable,
   BroadcastChannelConn,
 } from './broadcast-channel.js'
-
 export {
   MessagePortIterable,
   newMessagePortIterable,
   MessagePortConn,
 } from './message-port.js'
+export { ObservableSource } from './observable-source.js'

package/srpc/{rpc-stream.go → msg-stream.go}

@@ -5,8 +5,8 @@ import (
 	"io"
 )
 
-// RPCStream implements the stream interface passed to implementations.
-type RPCStream struct {
+// MsgStream implements the stream interface passed to implementations.
+type MsgStream struct {
 	// ctx is the stream context
 	ctx context.Context
 	// writer is the stream writer
@@ -15,10 +15,10 @@ type RPCStream struct {
 	dataCh chan []byte
 }
 
-// NewRPCStream constructs a new Stream with a ClientRPC.
+// NewMsgStream constructs a new Stream with a ClientRPC.
 // dataCh should be closed when no more messages will arrive.
-func NewRPCStream(ctx context.Context, writer Writer, dataCh chan []byte) *RPCStream {
-	return &RPCStream{
+func NewMsgStream(ctx context.Context, writer Writer, dataCh chan []byte) *MsgStream {
+	return &MsgStream{
 		ctx:    ctx,
 		writer: writer,
 		dataCh: dataCh,
@@ -26,12 +26,12 @@ func NewRPCStream(ctx context.Context, writer Writer, dataCh chan []byte) *RPCSt
 }
 
 // Context is canceled when the Stream is no longer valid.
-func (r *RPCStream) Context() context.Context {
+func (r *MsgStream) Context() context.Context {
 	return r.ctx
 }
 
 // MsgSend sends the message to the remote.
-func (r *RPCStream) MsgSend(msg Message) error {
+func (r *MsgStream) MsgSend(msg Message) error {
 	select {
 	case <-r.ctx.Done():
 		return context.Canceled
@@ -48,7 +48,7 @@ func (r *RPCStream) MsgSend(msg Message) error {
 
 // MsgRecv receives an incoming message from the remote.
 // Parses the message into the object at msg.
-func (r *RPCStream) MsgRecv(msg Message) error {
+func (r *MsgStream) MsgRecv(msg Message) error {
 	select {
 	case <-r.Context().Done():
 		return context.Canceled
@@ -61,16 +61,16 @@ func (r *RPCStream) MsgRecv(msg Message) error {
 }
 
 // CloseSend signals to the remote that we will no longer send any messages.
-func (r *RPCStream) CloseSend() error {
+func (r *MsgStream) CloseSend() error {
 	outPkt := NewCallDataPacket(nil, false, true, nil)
 	return r.writer.WritePacket(outPkt)
 }
 
 // Close closes the stream.
-func (r *RPCStream) Close() error {
+func (r *MsgStream) Close() error {
 	_ = r.writer.Close()
 	return nil
 }
 
 // _ is a type assertion
-var _ Stream = ((*RPCStream)(nil))
+var _ Stream = ((*MsgStream)(nil))

package/srpc/muxed-conn.go

@@ -14,7 +14,7 @@ func NewClientWithMuxedConn(conn network.MuxedConn) Client {
 
 // NewOpenStreamWithMuxedConn constructs a OpenStream func with a MuxedConn.
 func NewOpenStreamWithMuxedConn(conn network.MuxedConn) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 		mstrm, err := conn.OpenStream(ctx)
 		if err != nil {
 			return nil, err

package/srpc/observable-source.ts

@@ -0,0 +1,40 @@
+import { Source } from 'it-stream-types'
+import { pushable, Pushable } from 'it-pushable'
+import { Observable, Subscription } from 'rxjs'
+
+// ObservableSource wraps an Observable into a Source.
+export class ObservableSource<T> {
+  // source is the source for observable objects.
+  public readonly source: Source<T>
+  // _source emits incoming data to the source.
+  private readonly _source: {
+    push: (val: T) => void
+    end: (err?: Error) => void
+  }
+  // subscription is the observable subscription
+  private readonly subscription: Subscription
+
+  constructor(observable: Observable<T>) {
+    const source: Pushable<T> = pushable({ objectMode: true })
+    this.source = source
+    this._source = source
+
+    this.subscription = observable.subscribe({
+      next: (value: T) => {
+        this._source.push(value)
+      },
+      error: (err) => {
+        this._source.end(err)
+      },
+      complete: () => {
+        this._source.end()
+      },
+    })
+  }
+
+  // close closes the subscription.
+  public close(err?: Error) {
+    this._source.end(err)
+    this.subscription.unsubscribe()
+  }
+}

package/srpc/packet.ts

@@ -4,7 +4,7 @@ import {
   decode as lengthPrefixDecode,
 } from 'it-length-prefixed'
 
-import { Packet } from './rpcproto.js'
+import { Packet } from './rpcproto.pb.js'
 import {
   buildDecodeMessageTransform,
   buildEncodeMessageTransform,

package/srpc/server-pipe.go

@@ -9,7 +9,7 @@ import (
 // Stream with the given Server. Starts read pumps for both. Starts the
 // HandleStream function on the server in a separate goroutine.
 func NewServerPipe(server *Server) OpenStreamFunc {
-	return func(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+	return func(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 		srvPipe, clientPipe := net.Pipe()
 		go func() {
 			_ = server.HandleStream(ctx, srvPipe)

package/srpc/server-rpc.go

@@ -133,7 +133,7 @@ func (r *ServerRPC) HandleCallData(pkt *CallData) error {
 func (r *ServerRPC) invokeRPC() {
 	// ctx := r.ctx
 	serviceID, methodID := r.service, r.method
-	strm := NewRPCStream(r.ctx, r.writer, r.dataCh)
+	strm := NewMsgStream(r.ctx, r.writer, r.dataCh)
 	ok, err := r.mux.InvokeMethod(serviceID, methodID, strm)
 	if err == nil && !ok {
 		err = ErrUnimplemented

package/srpc/server-rpc.ts

@@ -1,6 +1,6 @@
 import type { Sink } from 'it-stream-types'
 
-import type { CallData, CallStart } from './rpcproto.js'
+import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.js'
 import { Mux } from './mux.js'

package/srpc/server.go

@@ -20,6 +20,11 @@ func NewServer(mux Mux) *Server {
 	}
 }
 
+// GetMux returns the mux.
+func (s *Server) GetMux() Mux {
+	return s.mux
+}
+
 // HandleStream handles an incoming ReadWriteCloser stream.
 func (s *Server) HandleStream(ctx context.Context, rwc io.ReadWriteCloser) error {
 	subCtx, subCtxCancel := context.WithCancel(ctx)

package/srpc/server.ts

@@ -4,7 +4,7 @@ import { pipe } from 'it-pipe'
 
 import { Mux } from './mux.js'
 import { ServerRPC } from './server-rpc.js'
-import { Packet } from './rpcproto.js'
+import { Packet } from './rpcproto.pb.js'
 import {
   parseLengthPrefixTransform,
   prependLengthPrefixTransform,
@@ -29,15 +29,14 @@ export class Server implements StreamHandler {
   }
 
   // handleStream handles an incoming Uint8Array message duplex.
-  // closes the stream when the rpc completes.
-  public handleStream(stream: Stream): Promise<void> {
+  public handleStream(stream: Stream): ServerRPC {
     return this.handleDuplex(stream)
   }
 
   // handleDuplex handles an incoming message duplex.
-  public async handleDuplex(stream: Duplex<Uint8Array>): Promise<void> {
+  public handleDuplex(stream: Duplex<Uint8Array>): ServerRPC {
     const rpc = this.startRpc()
-    await pipe(
+    pipe(
       stream,
       parseLengthPrefixTransform(),
       decodePacketSource,
@@ -46,11 +45,13 @@ export class Server implements StreamHandler {
       prependLengthPrefixTransform(),
       stream
     )
+    return rpc
   }
 
   // handlePacketStream handles an incoming Packet duplex.
-  public async handlePacketStream(stream: Duplex<Packet>): Promise<void> {
+  public handlePacketStream(stream: Duplex<Packet>): ServerRPC {
     const rpc = this.startRpc()
-    await pipe(stream, rpc, stream)
+    pipe(stream, rpc, stream)
+    return rpc
   }
 }

package/srpc/stream.ts

@@ -1,4 +1,4 @@
-import type { Packet } from './rpcproto'
+import type { Packet } from './rpcproto.pb.js'
 import type { Duplex } from 'it-stream-types'
 
 // PacketHandler handles incoming packets.

package/srpc/websocket.go

@@ -43,7 +43,7 @@ func (w *WebSocketConn) AcceptStream() (io.ReadWriteCloser, error) {
 }
 
 // OpenStream tries to open a stream with the remote.
-func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler func(pkt *Packet) error) (Writer, error) {
+func (w *WebSocketConn) OpenStream(ctx context.Context, msgHandler PacketHandler) (Writer, error) {
 	muxedStream, err := w.mconn.OpenStream(ctx)
 	if err != nil {
 		return nil, err