starpc 0.6.1 → 0.7.1

package/Makefile

@@ -106,6 +106,7 @@ gents: $(PROTOWRAP) node_modules
 		--ts_proto_out=$$(pwd)/vendor \
 		--ts_proto_opt=esModuleInterop=true \
 		--ts_proto_opt=fileSuffix=.pb \
+		--ts_proto_opt=importSuffix=.js \
 		--ts_proto_opt=forceLong=long \
 		--ts_proto_opt=oneof=unions \
 		--ts_proto_opt=outputServices=default,outputServices=generic-definitions \

package/README.md

@@ -121,7 +121,7 @@ import { pushable } from 'it-pushable'
 const mux = createMux()
 const echoer = new EchoerServer()
 mux.register(createHandler(EchoerDefinition, echoer))
-const server = new Server(mux)
+const server = new Server(mux.lookupMethodFunc)
 
 const clientConn = new Conn()
 const serverConn = new Conn(server)

package/dist/e2e/e2e.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/e2e/e2e.js

@@ -0,0 +1,24 @@
+import { pipe } from 'it-pipe';
+import { createHandler, createMux, Server, Client, Conn } from '../srpc';
+import { EchoerDefinition, EchoerServer, runClientTest } from '../echo';
+import { runRpcStreamTest } from '../echo/client-test';
+async function runRPC() {
+    const mux = createMux();
+    const server = new Server(mux.lookupMethodFunc);
+    const echoer = new EchoerServer(server);
+    mux.register(createHandler(EchoerDefinition, echoer));
+    const clientConn = new Conn();
+    const serverConn = new Conn(server);
+    pipe(clientConn, serverConn, clientConn);
+    const client = new Client(clientConn.buildOpenStreamFunc());
+    await runRpcStreamTest(client);
+    await runClientTest(client);
+}
+runRPC()
+    .then(() => {
+    console.log('finished successfully');
+})
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/integration/integration.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/integration/integration.js

@@ -0,0 +1,22 @@
+import { WebSocketConn } from '../srpc/websocket.js';
+import { runClientTest, runRpcStreamTest } from '../echo/client-test.js';
+import WebSocket from 'isomorphic-ws';
+async function runRPC() {
+    const addr = 'ws://localhost:5000/demo';
+    console.log(`Connecting to ${addr}`);
+    const ws = new WebSocket(addr);
+    const channel = new WebSocketConn(ws);
+    const client = channel.buildClient();
+    console.log('Running client test via WebSocket..');
+    await runClientTest(client);
+    console.log('Running RpcStream test via WebSocket..');
+    await runRpcStreamTest(client);
+}
+runRPC()
+    .then(() => {
+    process.exit(0);
+})
+    .catch((err) => {
+    console.error(err);
+    process.exit(1);
+});

package/dist/srpc/mux.d.ts

@@ -1,11 +1,16 @@
 import { InvokeFn, Handler } from './handler';
+export declare type LookupMethod = (serviceID: string, methodID: string) => Promise<InvokeFn | null>;
 export interface Mux {
-    register(handler: Handler): void;
     lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>;
 }
-export declare function createMux(): Mux;
+export declare function createMux(): StaticMux;
 export declare class StaticMux implements Mux {
     private services;
+    private lookups;
+    get lookupMethodFunc(): LookupMethod;
     register(handler: Handler): void;
+    registerLookupMethod(lookupMethod: LookupMethod): void;
     lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>;
+    private lookupViaMap;
+    private lookupViaLookups;
 }

package/dist/srpc/mux.js

@@ -1,4 +1,4 @@
-// createMux builds a new Mux.
+// createMux builds a new StaticMux.
 export function createMux() {
     return new StaticMux();
 }
@@ -8,6 +8,13 @@ export class StaticMux {
     constructor() {
         // services contains a mapping from service id to handlers.
         this.services = {};
+        // lookups is the list of lookup methods to call.
+        // called if the method is not resolved by the services list.
+        this.lookups = [];
+    }
+    // lookupMethodFunc implements the LookupMethod type.
+    get lookupMethodFunc() {
+        return this.lookupMethod.bind(this);
     }
     register(handler) {
         const serviceID = handler?.getServiceID();
@@ -21,10 +28,21 @@ export class StaticMux {
         }
         this.services[serviceID] = serviceMethods;
     }
+    // registerLookupMethod registers a extra lookup function to the mux.
+    registerLookupMethod(lookupMethod) {
+        this.lookups.push(lookupMethod);
+    }
     async lookupMethod(serviceID, methodID) {
-        if (!serviceID) {
-            return null;
+        if (serviceID) {
+            const invokeFn = await this.lookupViaMap(serviceID, methodID);
+            if (invokeFn) {
+                return invokeFn;
+            }
         }
+        return await this.lookupViaLookups(serviceID, methodID);
+    }
+    // lookupViaMap looks up the method via the services map.
+    async lookupViaMap(serviceID, methodID) {
         const serviceMethods = this.services[serviceID];
         if (!serviceMethods) {
             return null;
@@ -35,4 +53,14 @@ export class StaticMux {
         }
         return await handler.lookupMethod(serviceID, methodID);
     }
+    // lookupViaLookups looks up the method via the lookup funcs.
+    async lookupViaLookups(serviceID, methodID) {
+        for (const lookupMethod of this.lookups) {
+            const invokeFn = await lookupMethod(serviceID, methodID);
+            if (invokeFn) {
+                return invokeFn;
+            }
+        }
+        return null;
+    }
 }

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

@@ -1,9 +1,9 @@
 import type { CallData, CallStart } from './rpcproto.pb.js';
 import { CommonRPC } from './common-rpc.js';
-import { Mux } from './mux.js';
+import { LookupMethod } from './mux.js';
 export declare class ServerRPC extends CommonRPC {
-    private mux;
-    constructor(mux: Mux);
+    private lookupMethod;
+    constructor(lookupMethod: LookupMethod);
     handleCallStart(packet: Partial<CallStart>): Promise<void>;
     handleCallData(packet: Partial<CallData>): Promise<void>;
     private invokeRPC;

package/dist/srpc/server-rpc.js

@@ -1,9 +1,9 @@
 import { CommonRPC } from './common-rpc.js';
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
-    constructor(mux) {
+    constructor(lookupMethod) {
         super();
-        this.mux = mux;
+        this.lookupMethod = lookupMethod;
     }
     // handleCallStart handles a CallStart cket.
     async handleCallStart(packet) {
@@ -15,7 +15,7 @@ export class ServerRPC extends CommonRPC {
         if (!this.service || !this.method) {
             throw new Error('rpcService and rpcMethod cannot be empty');
         }
-        const methodDef = await this.mux.lookupMethod(this.service, this.method);
+        const methodDef = await this.lookupMethod(this.service, this.method);
         if (!methodDef) {
             throw new Error(`not found: ${this.service}/${this.method}`);
         }

package/dist/srpc/server.d.ts

@@ -1,13 +1,13 @@
 import { Stream } from '@libp2p/interface-connection';
 import { Duplex } from 'it-stream-types';
-import { Mux } from './mux.js';
+import { LookupMethod } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
 import { Packet } from './rpcproto.pb.js';
 import { StreamHandler } from './conn.js';
 import { RpcStreamHandler } from '../rpcstream/rpcstream.js';
 export declare class Server implements StreamHandler {
-    private mux;
-    constructor(mux: Mux);
+    private lookupMethod;
+    constructor(lookupMethod: LookupMethod);
     get rpcStreamHandler(): RpcStreamHandler;
     startRpc(): ServerRPC;
     handleStream(stream: Stream): ServerRPC;

package/dist/srpc/server.js

@@ -3,8 +3,8 @@ import { ServerRPC } from './server-rpc.js';
 import { parseLengthPrefixTransform, prependLengthPrefixTransform, decodePacketSource, encodePacketSource, } from './packet.js';
 // Server implements the SRPC server in TypeScript with a Mux.
 export class Server {
-    constructor(mux) {
-        this.mux = mux;
+    constructor(lookupMethod) {
+        this.lookupMethod = lookupMethod;
     }
     // rpcStreamHandler implements the RpcStreamHandler interface.
     get rpcStreamHandler() {
@@ -13,7 +13,7 @@ export class Server {
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.
     startRpc() {
-        return new ServerRPC(this.mux);
+        return new ServerRPC(this.lookupMethod);
     }
     // handleStream handles an incoming Uint8Array message duplex.
     handleStream(stream) {

package/e2e/e2e.ts

@@ -5,7 +5,7 @@ import { runRpcStreamTest } from '../echo/client-test'
 
 async function runRPC() {
   const mux = createMux()
-  const server = new Server(mux)
+  const server = new Server(mux.lookupMethodFunc)
   const echoer = new EchoerServer(server)
   mux.register(createHandler(EchoerDefinition, echoer))
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.6.1",
+  "version": "0.7.1",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -34,7 +34,8 @@
   },
   "scripts": {
     "build": "rimraf ./dist && tsc --project tsconfig.build.json --outDir ./dist/",
-    "check": "tsc",
+    "check": "npm run typecheck",
+    "typecheck": "tsc --noEmit",
     "deps": "depcheck --ignores 'bufferutil,utf-8-validate'",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
@@ -58,16 +59,16 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@typescript-eslint/eslint-plugin": "^5.30.3",
-    "@typescript-eslint/parser": "^5.30.3",
+    "@typescript-eslint/eslint-plugin": "^5.30.5",
+    "@typescript-eslint/parser": "^5.30.5",
     "bufferutil": "^4.0.6",
     "depcheck": "^1.4.3",
     "esbuild": "^0.14.48",
-    "eslint": "^8.18.0",
+    "eslint": "^8.19.0",
     "eslint-config-prettier": "^8.5.0",
     "prettier": "^2.7.1",
     "rimraf": "^3.0.2",
-    "ts-proto": "^1.116.1",
+    "ts-proto": "^1.117.0",
     "typescript": "^4.7.4",
     "utf-8-validate": "^5.0.9"
   },

package/patches/ts-poet+4.15.0.patch

@@ -1,8 +1,16 @@
 diff --git a/node_modules/ts-poet/build/Import.js b/node_modules/ts-poet/build/Import.js
-index b92bea3..608add9 100644
+index b92bea3..d35c845 100644
 --- a/node_modules/ts-poet/build/Import.js
 +++ b/node_modules/ts-poet/build/Import.js
-@@ -293,6 +293,14 @@ function emitImports(imports, ourModulePath, importMappings) {
+@@ -26,6 +26,7 @@ exports.sameModule = exports.maybeRelativePath = exports.emitImports = exports.S
+ const lodash_1 = __importDefault(require("lodash"));
+ const path = __importStar(require("path"));
+ const Node_1 = require("./Node");
++const fs = require('fs');
+ const typeImportMarker = '(?:t:)?';
+ const fileNamePattern = '(?:[a-zA-Z0-9._-]+)';
+ const modulePattern = `@?(?:(?:${fileNamePattern}(?:/${fileNamePattern})*))`;
+@@ -293,6 +294,16 @@ function emitImports(imports, ourModulePath, importMappings) {
          return '';
      }
      let result = '';
@@ -13,11 +21,13 @@ index b92bea3..608add9 100644
 +    // github.com/aperturerobotics/protobuf-project/example/example -> ./example/example
 +    if (thisProject && ourModuleImportPath.startsWith(thisProject)) {
 +        ourModuleImportPath = './' + ourModuleImportPath.substr(thisProject.length + 1);
++    } else {
++      ourModuleImportPath = './vendor/' + ourModuleImportPath;
 +    }
      const augmentImports = lodash_1.default.groupBy(filterInstances(imports, Augmented), (a) => a.augmented);
      // Group the imports by source module they're imported from
      const importsByModule = lodash_1.default.groupBy(imports.filter((it) => it.source !== undefined &&
-@@ -307,7 +315,14 @@ function emitImports(imports, ourModulePath, importMappings) {
+@@ -307,7 +318,14 @@ function emitImports(imports, ourModulePath, importMappings) {
          if (modulePath in importMappings) {
              modulePath = importMappings[modulePath];
          }

package/srpc/mux.ts

@@ -1,16 +1,17 @@
 import { InvokeFn, Handler } from './handler'
 
+// LookupMethod is a function to lookup a RPC method.
+export type LookupMethod = (serviceID: string, methodID: string) => Promise<InvokeFn | null>
+
 // Mux contains a set of <service, method> handlers.
 export interface Mux {
-  // register registers a new RPC method handler.
-  register(handler: Handler): void
   // lookupMethod looks up the method matching the service & method ID.
   // returns null if not found.
   lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>
 }
 
-// createMux builds a new Mux.
-export function createMux(): Mux {
+// createMux builds a new StaticMux.
+export function createMux(): StaticMux {
   return new StaticMux()
 }
 
@@ -22,6 +23,14 @@ type staticMuxMethods = { [methodID: string]: Handler }
 export class StaticMux implements Mux {
   // services contains a mapping from service id to handlers.
   private services: { [id: string]: staticMuxMethods } = {}
+  // lookups is the list of lookup methods to call.
+  // called if the method is not resolved by the services list.
+  private lookups: LookupMethod[] = []
+
+  // lookupMethodFunc implements the LookupMethod type.
+  public get lookupMethodFunc(): LookupMethod {
+    return this.lookupMethod.bind(this)
+  }
 
   public register(handler: Handler): void {
     const serviceID = handler?.getServiceID()
@@ -36,13 +45,27 @@ export class StaticMux implements Mux {
     this.services[serviceID] = serviceMethods
   }
 
+  // registerLookupMethod registers a extra lookup function to the mux.
+  public registerLookupMethod(lookupMethod: LookupMethod) {
+    this.lookups.push(lookupMethod)
+  }
+
   public async lookupMethod(
     serviceID: string,
     methodID: string
   ): Promise<InvokeFn | null> {
-    if (!serviceID) {
-      return null
+    if (serviceID) {
+      const invokeFn = await this.lookupViaMap(serviceID, methodID)
+      if (invokeFn) {
+        return invokeFn
+      }
     }
+
+    return await this.lookupViaLookups(serviceID, methodID)
+  }
+
+  // lookupViaMap looks up the method via the services map.
+  private async lookupViaMap(serviceID: string, methodID: string): Promise<InvokeFn | null> {
     const serviceMethods = this.services[serviceID]
     if (!serviceMethods) {
       return null
@@ -53,4 +76,16 @@ export class StaticMux implements Mux {
     }
     return await handler.lookupMethod(serviceID, methodID)
   }
+
+  // lookupViaLookups looks up the method via the lookup funcs.
+  private async lookupViaLookups(serviceID: string, methodID: string): Promise<InvokeFn | null> {
+    for (const lookupMethod of this.lookups) {
+      const invokeFn = await lookupMethod(serviceID, methodID)
+      if (invokeFn) {
+        return invokeFn
+      }
+    }
+
+    return null
+  }
 }

package/srpc/packet.go

@@ -58,7 +58,7 @@ func NewCallDataPacket(data []byte, dataIsZero bool, complete bool, err error) *
 
 // Validate performs cursory validation of the packet.
 func (p *CallData) Validate() error {
-	if len(p.GetData()) == 0 && !p.GetComplete() && len(p.GetError()) == 0 {
+	if len(p.GetData()) == 0 && !p.GetComplete() && len(p.GetError()) == 0 && !p.GetDataIsZero() {
 		return ErrEmptyPacket
 	}
 	return nil

package/srpc/server-rpc.ts

@@ -3,16 +3,16 @@ import type { Sink } from 'it-stream-types'
 import type { CallData, CallStart } from './rpcproto.pb.js'
 import { CommonRPC } from './common-rpc.js'
 import { InvokeFn } from './handler.js'
-import { Mux } from './mux.js'
+import { LookupMethod } from './mux.js'
 
 // ServerRPC is an ongoing RPC from the server side.
 export class ServerRPC extends CommonRPC {
-  // mux is used to handle incoming rpcs.
-  private mux: Mux
+  // lookupMethod looks up the incoming RPC methods.
+  private lookupMethod: LookupMethod
 
-  constructor(mux: Mux) {
+  constructor(lookupMethod: LookupMethod) {
     super()
-    this.mux = mux
+    this.lookupMethod = lookupMethod
   }
 
   // handleCallStart handles a CallStart cket.
@@ -25,7 +25,7 @@ export class ServerRPC extends CommonRPC {
     if (!this.service || !this.method) {
       throw new Error('rpcService and rpcMethod cannot be empty')
     }
-    const methodDef = await this.mux.lookupMethod(this.service, this.method)
+    const methodDef = await this.lookupMethod(this.service, this.method)
     if (!methodDef) {
       throw new Error(`not found: ${this.service}/${this.method}`)
     }

package/srpc/server.ts

@@ -2,7 +2,7 @@ import { Stream } from '@libp2p/interface-connection'
 import { Duplex } from 'it-stream-types'
 import { pipe } from 'it-pipe'
 
-import { Mux } from './mux.js'
+import { LookupMethod } from './mux.js'
 import { ServerRPC } from './server-rpc.js'
 import { Packet } from './rpcproto.pb.js'
 import {
@@ -16,11 +16,11 @@ import { RpcStreamHandler } from '../rpcstream/rpcstream.js'
 
 // Server implements the SRPC server in TypeScript with a Mux.
 export class Server implements StreamHandler {
-  // mux is the mux used to handle requests.
-  private mux: Mux
+  // lookupMethod looks up the incoming RPC methods.
+  private lookupMethod: LookupMethod
 
-  constructor(mux: Mux) {
-    this.mux = mux
+  constructor(lookupMethod: LookupMethod) {
+    this.lookupMethod = lookupMethod
   }
 
   // rpcStreamHandler implements the RpcStreamHandler interface.
@@ -31,7 +31,7 @@ export class Server implements StreamHandler {
   // startRpc starts a new server-side RPC.
   // the returned RPC handles incoming Packets.
   public startRpc(): ServerRPC {
-    return new ServerRPC(this.mux)
+    return new ServerRPC(this.lookupMethod)
   }
 
   // handleStream handles an incoming Uint8Array message duplex.