starpc 0.10.9 → 0.11.2

package/dist/echo/echo.pb.d.ts

@@ -34,7 +34,8 @@ export interface Echoer {
 }
 export declare class EchoerClientImpl implements Echoer {
     private readonly rpc;
-    constructor(rpc: Rpc);
+    private readonly service;
+    constructor(rpc: Rpc, service?: string);
     Echo(request: EchoMsg): Promise<EchoMsg>;
     EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg>;
     EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg>;

package/dist/echo/echo.pb.js

@@ -73,7 +73,8 @@ export const EchoMsg = {
     },
 };
 export class EchoerClientImpl {
-    constructor(rpc) {
+    constructor(rpc, service) {
+        this.service = service || "echo.Echoer";
         this.rpc = rpc;
         this.Echo = this.Echo.bind(this);
         this.EchoServerStream = this.EchoServerStream.bind(this);
@@ -83,27 +84,27 @@ export class EchoerClientImpl {
     }
     Echo(request) {
         const data = EchoMsg.encode(request).finish();
-        const promise = this.rpc.request("echo.Echoer", "Echo", data);
+        const promise = this.rpc.request(this.service, "Echo", data);
         return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
     EchoServerStream(request) {
         const data = EchoMsg.encode(request).finish();
-        const result = this.rpc.serverStreamingRequest("echo.Echoer", "EchoServerStream", data);
+        const result = this.rpc.serverStreamingRequest(this.service, "EchoServerStream", data);
         return EchoMsg.decodeTransform(result);
     }
     EchoClientStream(request) {
         const data = EchoMsg.encodeTransform(request);
-        const promise = this.rpc.clientStreamingRequest("echo.Echoer", "EchoClientStream", data);
+        const promise = this.rpc.clientStreamingRequest(this.service, "EchoClientStream", data);
         return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
     }
     EchoBidiStream(request) {
         const data = EchoMsg.encodeTransform(request);
-        const result = this.rpc.bidirectionalStreamingRequest("echo.Echoer", "EchoBidiStream", data);
+        const result = this.rpc.bidirectionalStreamingRequest(this.service, "EchoBidiStream", data);
         return EchoMsg.decodeTransform(result);
     }
     RpcStream(request) {
         const data = RpcStreamPacket.encodeTransform(request);
-        const result = this.rpc.bidirectionalStreamingRequest("echo.Echoer", "RpcStream", data);
+        const result = this.rpc.bidirectionalStreamingRequest(this.service, "RpcStream", data);
         return RpcStreamPacket.decodeTransform(result);
     }
 }

package/dist/echo/server.js

@@ -32,7 +32,7 @@ export class EchoerServer {
         return result;
     }
     RpcStream(request) {
-        return handleRpcStream(request[Symbol.asyncIterator](), async (_componentId) => {
+        return handleRpcStream(request[Symbol.asyncIterator](), async () => {
             if (!this.proxyServer) {
                 throw new Error('rpc stream proxy server not set');
             }

package/dist/srpc/conn.js

@@ -1,5 +1,6 @@
 import { pipe } from 'it-pipe';
 import { Mplex } from '@libp2p/mplex';
+import isPromise from 'is-promise';
 import { Client } from './client.js';
 import { combineUint8ArrayListTransform } from './array-list.js';
 // streamToSRPCStream converts a Stream to a SRPCStream.
@@ -46,6 +47,9 @@ export class Conn {
     // openStream implements the client open stream function.
     async openStream() {
         const stream = this.muxer.newStream();
+        if (isPromise(stream)) {
+            return streamToSRPCStream(await stream);
+        }
         return streamToSRPCStream(stream);
     }
     // buildOpenStreamFunc returns openStream bound to this conn.

package/dist/srpc/handler.d.ts

@@ -19,5 +19,5 @@ export declare class StaticHandler implements Handler {
 }
 declare type MethodProto<R, O> = ((request: R) => Promise<O>) | ((request: R) => AsyncIterable<O>) | ((request: AsyncIterable<R>) => Promise<O>) | ((request: AsyncIterable<R>) => AsyncIterable<O>);
 export declare function createInvokeFn<R, O>(methodInfo: MethodDefinition<R, O>, methodProto: MethodProto<R, O>): InvokeFn;
-export declare function createHandler(definition: Definition, impl: any): Handler;
+export declare function createHandler(definition: Definition, impl: any, serviceID?: string): Handler;
 export {};

package/dist/srpc/handler.js

@@ -89,7 +89,11 @@ export function createInvokeFn(methodInfo, methodProto) {
     };
 }
 // createHandler creates a handler from a definition and an implementation.
-export function createHandler(definition, impl) {
+// if serviceID is not set, uses the fullName of the service as the identifier.
+export function createHandler(definition, impl, serviceID) {
+    // serviceID defaults to the full name of the service from Protobuf.
+    serviceID = serviceID || definition.fullName;
+    // build map of method ID -> method prototype.
     const methodMap = {};
     for (const methodInfo of Object.values(definition.methods)) {
         const methodName = methodInfo.name;
@@ -100,5 +104,5 @@ export function createHandler(definition, impl) {
         methodProto = methodProto.bind(impl);
         methodMap[methodName] = createInvokeFn(methodInfo, methodProto);
     }
-    return new StaticHandler(definition.fullName, methodMap);
+    return new StaticHandler(serviceID, methodMap);
 }

package/echo/echo.pb.ts

@@ -105,7 +105,9 @@ export interface Echoer {
 
 export class EchoerClientImpl implements Echoer {
   private readonly rpc: Rpc;
-  constructor(rpc: Rpc) {
+  private readonly service: string;
+  constructor(rpc: Rpc, service?: string) {
+    this.service = service || "echo.Echoer";
     this.rpc = rpc;
     this.Echo = this.Echo.bind(this);
     this.EchoServerStream = this.EchoServerStream.bind(this);
@@ -115,31 +117,31 @@ export class EchoerClientImpl implements Echoer {
   }
   Echo(request: EchoMsg): Promise<EchoMsg> {
     const data = EchoMsg.encode(request).finish();
-    const promise = this.rpc.request("echo.Echoer", "Echo", data);
+    const promise = this.rpc.request(this.service, "Echo", data);
     return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
   }
 
   EchoServerStream(request: EchoMsg): AsyncIterable<EchoMsg> {
     const data = EchoMsg.encode(request).finish();
-    const result = this.rpc.serverStreamingRequest("echo.Echoer", "EchoServerStream", data);
+    const result = this.rpc.serverStreamingRequest(this.service, "EchoServerStream", data);
     return EchoMsg.decodeTransform(result);
   }
 
   EchoClientStream(request: AsyncIterable<EchoMsg>): Promise<EchoMsg> {
     const data = EchoMsg.encodeTransform(request);
-    const promise = this.rpc.clientStreamingRequest("echo.Echoer", "EchoClientStream", data);
+    const promise = this.rpc.clientStreamingRequest(this.service, "EchoClientStream", data);
     return promise.then((data) => EchoMsg.decode(new _m0.Reader(data)));
   }
 
   EchoBidiStream(request: AsyncIterable<EchoMsg>): AsyncIterable<EchoMsg> {
     const data = EchoMsg.encodeTransform(request);
-    const result = this.rpc.bidirectionalStreamingRequest("echo.Echoer", "EchoBidiStream", data);
+    const result = this.rpc.bidirectionalStreamingRequest(this.service, "EchoBidiStream", data);
     return EchoMsg.decodeTransform(result);
   }
 
   RpcStream(request: AsyncIterable<RpcStreamPacket>): AsyncIterable<RpcStreamPacket> {
     const data = RpcStreamPacket.encodeTransform(request);
-    const result = this.rpc.bidirectionalStreamingRequest("echo.Echoer", "RpcStream", data);
+    const result = this.rpc.bidirectionalStreamingRequest(this.service, "RpcStream", data);
     return RpcStreamPacket.decodeTransform(result);
   }
 }

package/echo/echo_srpc.pb.go

@@ -22,18 +22,26 @@ type SRPCEchoerClient interface {
 }
 
 type srpcEchoerClient struct {
-	cc srpc.Client
+	cc        srpc.Client
+	serviceID string
 }
 
 func NewSRPCEchoerClient(cc srpc.Client) SRPCEchoerClient {
-	return &srpcEchoerClient{cc}
+	return &srpcEchoerClient{cc: cc, serviceID: SRPCEchoerServiceID}
+}
+
+func NewSRPCEchoerClientWithServiceID(cc srpc.Client, serviceID string) SRPCEchoerClient {
+	if serviceID == "" {
+		serviceID = SRPCEchoerServiceID
+	}
+	return &srpcEchoerClient{cc: cc, serviceID: serviceID}
 }
 
 func (c *srpcEchoerClient) SRPCClient() srpc.Client { return c.cc }
 
 func (c *srpcEchoerClient) Echo(ctx context.Context, in *EchoMsg) (*EchoMsg, error) {
 	out := new(EchoMsg)
-	err := c.cc.Invoke(ctx, "echo.Echoer", "Echo", in, out)
+	err := c.cc.Invoke(ctx, c.serviceID, "Echo", in, out)
 	if err != nil {
 		return nil, err
 	}
@@ -41,7 +49,7 @@ func (c *srpcEchoerClient) Echo(ctx context.Context, in *EchoMsg) (*EchoMsg, err
 }
 
 func (c *srpcEchoerClient) EchoServerStream(ctx context.Context, in *EchoMsg) (SRPCEchoer_EchoServerStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoServerStream", in)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "EchoServerStream", in)
 	if err != nil {
 		return nil, err
 	}
@@ -75,7 +83,7 @@ func (x *srpcEchoer_EchoServerStreamClient) RecvTo(m *EchoMsg) error {
 }
 
 func (c *srpcEchoerClient) EchoClientStream(ctx context.Context) (SRPCEchoer_EchoClientStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoClientStream", nil)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "EchoClientStream", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -116,7 +124,7 @@ func (x *srpcEchoer_EchoClientStreamClient) CloseAndMsgRecv(m *EchoMsg) error {
 }
 
 func (c *srpcEchoerClient) EchoBidiStream(ctx context.Context) (SRPCEchoer_EchoBidiStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "EchoBidiStream", nil)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "EchoBidiStream", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -152,7 +160,7 @@ func (x *srpcEchoer_EchoBidiStreamClient) RecvTo(m *EchoMsg) error {
 }
 
 func (c *srpcEchoerClient) RpcStream(ctx context.Context) (SRPCEchoer_RpcStreamClient, error) {
-	stream, err := c.cc.NewStream(ctx, "echo.Echoer", "RpcStream", nil)
+	stream, err := c.cc.NewStream(ctx, c.serviceID, "RpcStream", nil)
 	if err != nil {
 		return nil, err
 	}
@@ -220,10 +228,26 @@ func (s *SRPCEchoerUnimplementedServer) RpcStream(SRPCEchoer_RpcStreamStream) er
 const SRPCEchoerServiceID = "echo.Echoer"
 
 type SRPCEchoerHandler struct {
-	impl SRPCEchoerServer
+	serviceID string
+	impl      SRPCEchoerServer
+}
+
+// NewSRPCEchoerHandler constructs a new RPC handler.
+// serviceID: if empty, uses default: echo.Echoer
+func NewSRPCEchoerHandler(impl SRPCEchoerServer, serviceID string) srpc.Handler {
+	if serviceID == "" {
+		serviceID = SRPCEchoerServiceID
+	}
+	return &SRPCEchoerHandler{impl: impl, serviceID: serviceID}
+}
+
+// SRPCRegisterEchoer registers the implementation with the mux.
+// Uses the default serviceID: echo.Echoer
+func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
+	return mux.Register(NewSRPCEchoerHandler(impl, ""))
 }
 
-func (SRPCEchoerHandler) GetServiceID() string { return SRPCEchoerServiceID }
+func (d *SRPCEchoerHandler) GetServiceID() string { return d.serviceID }
 
 func (SRPCEchoerHandler) GetMethodIDs() []string {
 	return []string{
@@ -295,14 +319,6 @@ func (SRPCEchoerHandler) InvokeMethod_RpcStream(impl SRPCEchoerServer, strm srpc
 	return impl.RpcStream(clientStrm)
 }
 
-func NewSRPCEchoerHandler(impl SRPCEchoerServer) srpc.Handler {
-	return &SRPCEchoerHandler{impl: impl}
-}
-
-func SRPCRegisterEchoer(mux srpc.Mux, impl SRPCEchoerServer) error {
-	return mux.Register(&SRPCEchoerHandler{impl: impl})
-}
-
 type SRPCEchoer_EchoStream interface {
 	srpc.Stream
 	SendAndClose(*EchoMsg) error

package/echo/server.ts

@@ -52,7 +52,7 @@ export class EchoerServer implements Echoer {
   ): AsyncIterable<RpcStreamPacket> {
     return handleRpcStream(
       request[Symbol.asyncIterator](),
-      async (_componentId: string): Promise<RpcStreamHandler> => {
+      async (): Promise<RpcStreamHandler> => {
         if (!this.proxyServer) {
           throw new Error('rpc stream proxy server not set')
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.10.9",
+  "version": "0.11.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -59,24 +59,25 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.36.2",
-    "@typescript-eslint/parser": "^5.36.2",
+    "@typescript-eslint/eslint-plugin": "^5.40.0",
+    "@typescript-eslint/parser": "^5.40.0",
     "bufferutil": "^4.0.6",
     "depcheck": "^1.4.3",
-    "esbuild": "^0.15.7",
-    "eslint": "^8.23.0",
+    "esbuild": "^0.15.10",
+    "eslint": "^8.25.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.125.0",
-    "typescript": "^4.8.2",
+    "ts-proto": "^1.126.1",
+    "typescript": "^4.8.4",
     "utf-8-validate": "^5.0.9"
   },
   "dependencies": {
-    "@libp2p/interface-connection": "^3.0.1",
-    "@libp2p/interface-stream-muxer": "^2.0.2",
-    "@libp2p/mplex": "^5.1.1",
+    "@libp2p/interface-connection": "^3.0.2",
+    "@libp2p/interface-stream-muxer": "^3.0.0",
+    "@libp2p/mplex": "^6.0.2",
     "event-iterator": "^2.0.0",
+    "is-promise": "^4.0.0",
     "isomorphic-ws": "^5.0.0",
     "it-first": "^1.0.7",
     "it-length-prefixed": "^8.0.2",
@@ -86,8 +87,8 @@
     "it-ws": "^5.0.2",
     "long": "^5.2.0",
     "patch-package": "^6.4.7",
-    "protobufjs": "^7.1.0",
+    "protobufjs": "^7.1.2",
     "uint8arraylist": "^2.3.2",
-    "ws": "^8.8.1"
+    "ws": "^8.9.0"
   }
 }

package/patches/ts-proto+1.126.1.patch

@@ -0,0 +1,25 @@
+diff --git a/node_modules/ts-proto/build/generate-services.js b/node_modules/ts-proto/build/generate-services.js
+index 8ae7981..5ab6bf6 100644
+--- a/node_modules/ts-proto/build/generate-services.js
++++ b/node_modules/ts-proto/build/generate-services.js
+@@ -129,7 +129,7 @@ function generateRegularRpcMethod(ctx, fileDesc, serviceDesc, methodDesc) {
+       const data = ${encode};
+       const ${returnVariable} = this.rpc.${rpcMethod}(
+         ${maybeCtx}
+-        "${(0, utils_1.maybePrefixPackage)(fileDesc, serviceDesc.name)}",
++        this.service,
+         "${methodDesc.name}",
+         data
+       );
+@@ -148,7 +148,10 @@ function generateServiceClientImpl(ctx, fileDesc, serviceDesc) {
+     // Create the constructor(rpc: Rpc)
+     const rpcType = options.context ? "Rpc<Context>" : "Rpc";
+     chunks.push((0, ts_poet_1.code) `private readonly rpc: ${rpcType};`);
+-    chunks.push((0, ts_poet_1.code) `constructor(rpc: ${rpcType}) {`);
++    chunks.push((0, ts_poet_1.code) `private readonly service: string;`);
++    chunks.push((0, ts_poet_1.code) `constructor(rpc: ${rpcType}, service?: string) {`);
++    const serviceID = (0, utils_1.maybePrefixPackage)(fileDesc, serviceDesc.name);
++    chunks.push((0, ts_poet_1.code) `this.service = service || "${serviceID}";`);
+     chunks.push((0, ts_poet_1.code) `this.rpc = rpc;`);
+     // Bind each FooService method to the FooServiceImpl class
+     for (const methodDesc of serviceDesc.method) {

package/srpc/conn.ts

@@ -7,6 +7,7 @@ import { pipe } from 'it-pipe'
 import type { Duplex } from 'it-stream-types'
 import { Mplex } from '@libp2p/mplex'
 import { Uint8ArrayList } from 'uint8arraylist'
+import isPromise from 'is-promise'
 
 import type { OpenStreamFunc, Stream as SRPCStream } from './stream.js'
 import { Client } from './client.js'
@@ -29,7 +30,9 @@ export interface StreamHandler {
 }
 
 // streamToSRPCStream converts a Stream to a SRPCStream.
-export function streamToSRPCStream(stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): SRPCStream {
+export function streamToSRPCStream(
+  stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>
+): SRPCStream {
   return {
     source: pipe(stream, combineUint8ArrayListTransform()),
     sink: stream.sink,
@@ -83,6 +86,9 @@ export class Conn implements Duplex<Uint8Array> {
   // openStream implements the client open stream function.
   public async openStream(): Promise<SRPCStream> {
     const stream = this.muxer.newStream()
+    if (isPromise(stream)) {
+      return streamToSRPCStream(await stream)
+    }
     return streamToSRPCStream(stream)
   }
 

package/srpc/definition.ts

@@ -7,6 +7,7 @@ export interface Definition {
   // e.x.: Echo
   name: string
   // fullName is the fully qualified name of the service
+  // this is also referred to as the "service ID"
   // e.x.: echoer.Echoer
   fullName: string
   // methods is the set of RPC methods.

package/srpc/handler.ts

@@ -145,7 +145,16 @@ export function createInvokeFn<R, O>(
 }
 
 // createHandler creates a handler from a definition and an implementation.
-export function createHandler(definition: Definition, impl: any): Handler {
+// if serviceID is not set, uses the fullName of the service as the identifier.
+export function createHandler(
+  definition: Definition,
+  impl: any,
+  serviceID?: string
+): Handler {
+  // serviceID defaults to the full name of the service from Protobuf.
+  serviceID = serviceID || definition.fullName
+
+  // build map of method ID -> method prototype.
   const methodMap: MethodMap = {}
   for (const methodInfo of Object.values(definition.methods)) {
     const methodName = methodInfo.name
@@ -157,5 +166,5 @@ export function createHandler(definition: Definition, impl: any): Handler {
     methodMap[methodName] = createInvokeFn(methodInfo, methodProto)
   }
 
-  return new StaticHandler(definition.fullName, methodMap)
+  return new StaticHandler(serviceID, methodMap)
 }

package/srpc/server.ts

@@ -1,6 +1,5 @@
 import { Duplex } from 'it-stream-types'
 import { pipe } from 'it-pipe'
-import { Uint8ArrayList } from 'uint8arraylist'
 
 import { LookupMethod } from './mux.js'
 import { ServerRPC } from './server-rpc.js'
@@ -42,9 +41,7 @@ export class Server implements StreamHandler {
   }
 
   // handleDuplex handles an incoming message duplex.
-  public handleDuplex(
-    stream: Duplex<Uint8Array, Uint8Array>
-  ): ServerRPC {
+  public handleDuplex(stream: Duplex<Uint8Array, Uint8Array>): ServerRPC {
     const rpc = this.startRpc()
     pipe(
       stream,