starpc 0.5.2 → 0.6.2

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/dist/echo/server.js

@@ -36,7 +36,7 @@ export class EchoerServer {
             if (!this.proxyServer) {
                 throw new Error('rpc stream proxy server not set');
             }
-            return this.proxyServer;
+            return this.proxyServer.rpcStreamHandler;
         });
     }
 }

package/dist/rpcstream/index.d.ts

@@ -1,2 +1,2 @@
-export { RpcStream, RpcStreamCaller, RpcStreamGetter, handleRpcStream, buildRpcStreamOpenStream, } from './rpcstream.js';
-export { RpcStreamPacket, RpcStreamInit } from './rpcstream.pb.js';
+export { RpcStream, RpcStreamCaller, RpcStreamGetter, RpcStreamHandler, openRpcStream, handleRpcStream, buildRpcStreamOpenStream, } from './rpcstream.js';
+export { RpcStreamPacket, RpcStreamInit, RpcAck } from './rpcstream.pb.js';

package/dist/rpcstream/index.js

@@ -1,2 +1,2 @@
-export { RpcStream, handleRpcStream, buildRpcStreamOpenStream, } from './rpcstream.js';
-export { RpcStreamPacket, RpcStreamInit } from './rpcstream.pb.js';
+export { RpcStream, openRpcStream, handleRpcStream, buildRpcStreamOpenStream, } from './rpcstream.js';
+export { RpcStreamPacket, RpcStreamInit, RpcAck } from './rpcstream.pb.js';

package/dist/rpcstream/rpcstream.d.ts

@@ -1,12 +1,12 @@
 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';
+import { Duplex, Source, Sink } from 'it-stream-types';
 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 type RpcStreamHandler = (stream: Duplex<Uint8Array>) => void;
+export declare type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;
 export declare function handleRpcStream(packetStream: AsyncIterator<RpcStreamPacket>, getter: RpcStreamGetter): AsyncIterable<RpcStreamPacket>;
 export declare class RpcStream implements Stream {
     readonly source: Source<Uint8Array>;

package/dist/rpcstream/rpcstream.js

@@ -49,10 +49,10 @@ export async function* handleRpcStream(packetStream, getter) {
         throw new Error('expected init packet');
     }
     // lookup the server for the component id.
-    let server;
+    let handler = null;
     let err;
     try {
-        server = await getter(initRpcStreamPacket.body.init.componentId);
+        handler = await getter(initRpcStreamPacket.body.init.componentId);
     }
     catch (errAny) {
         err = errAny;
@@ -63,7 +63,7 @@ export async function* handleRpcStream(packetStream, getter) {
             err = new Error(`rpc getter failed: ${err}`);
         }
     }
-    if (!server && !err) {
+    if (!handler && !err) {
         err = new Error('not implemented');
     }
     yield* [
@@ -81,9 +81,11 @@ export async function* handleRpcStream(packetStream, getter) {
     }
     // build the outgoing packet sink & the packet source
     const packetSink = pushable({ objectMode: true });
-    // handle the stream
+    // handle the stream in the next event queue tick.
     const rpcStream = new RpcStream(packetSink, packetStream);
-    server.handleDuplex(rpcStream);
+    setTimeout(() => {
+        handler(rpcStream);
+    }, 1);
     // process packets
     for await (const packet of packetSink) {
         yield* [packet];

package/dist/srpc/server.d.ts

@@ -4,9 +4,11 @@ import { Mux } 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);
+    get rpcStreamHandler(): RpcStreamHandler;
     startRpc(): ServerRPC;
     handleStream(stream: Stream): ServerRPC;
     handleDuplex(stream: Duplex<Uint8Array>): ServerRPC;

package/dist/srpc/server.js

@@ -6,6 +6,10 @@ export class Server {
     constructor(mux) {
         this.mux = mux;
     }
+    // rpcStreamHandler implements the RpcStreamHandler interface.
+    get rpcStreamHandler() {
+        return this.handleDuplex.bind(this);
+    }
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.
     startRpc() {

package/echo/server.ts

@@ -4,7 +4,7 @@ import first from 'it-first'
 import { Server } from '../srpc/server.js'
 import { writeToPushable } from '../srpc/pushable.js'
 import { RpcStreamPacket } from '../rpcstream/rpcstream.pb.js'
-import { handleRpcStream } from '../rpcstream/rpcstream.js'
+import { handleRpcStream, RpcStreamHandler } from '../rpcstream/rpcstream.js'
 
 // EchoServer implements the Echoer server.
 export class EchoerServer implements Echoer {
@@ -52,11 +52,11 @@ export class EchoerServer implements Echoer {
   ): AsyncIterable<RpcStreamPacket> {
     return handleRpcStream(
       request[Symbol.asyncIterator](),
-      async (_componentId: string): Promise<Server> => {
+      async (_componentId: string): Promise<RpcStreamHandler> => {
         if (!this.proxyServer) {
           throw new Error('rpc stream proxy server not set')
         }
-        return this.proxyServer
+        return this.proxyServer.rpcStreamHandler
       }
     )
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.5.2",
+  "version": "0.6.2",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -58,16 +58,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.0",
+    "ts-proto": "^1.117.0",
     "typescript": "^4.7.4",
     "utf-8-validate": "^5.0.9"
   },

package/srpc/server.ts

@@ -12,6 +12,7 @@ import {
   encodePacketSource,
 } from './packet.js'
 import { StreamHandler } from './conn.js'
+import { RpcStreamHandler } from '../rpcstream/rpcstream.js'
 
 // Server implements the SRPC server in TypeScript with a Mux.
 export class Server implements StreamHandler {
@@ -22,6 +23,11 @@ export class Server implements StreamHandler {
     this.mux = mux
   }
 
+  // rpcStreamHandler implements the RpcStreamHandler interface.
+  public get rpcStreamHandler(): RpcStreamHandler {
+    return this.handleDuplex.bind(this)
+  }
+
   // startRpc starts a new server-side RPC.
   // the returned RPC handles incoming Packets.
   public startRpc(): ServerRPC {

package/patches/ts-proto+1.116.0.patch

@@ -1,14 +0,0 @@
-diff --git a/node_modules/ts-proto/build/utils.js b/node_modules/ts-proto/build/utils.js
-index 2148e97..e19b35f 100644
---- a/node_modules/ts-proto/build/utils.js
-+++ b/node_modules/ts-proto/build/utils.js
-@@ -170,7 +170,8 @@ function getPropertyAccessor(objectName, propertyName, optional = false) {
- }
- exports.getPropertyAccessor = getPropertyAccessor;
- function impProto(options, module, type) {
--    const importString = `${type}@./${module}${options.fileSuffix}`;
-+    // NOTE: TypeScript resolves importing foo.js to importing foo.ts.
-+    const importString = `${type}@./${module}${options.fileSuffix}.js`;
-     if (options.onlyTypes) {
-         return (0, ts_poet_1.imp)('t:' + importString);
-     }