starpc 0.1.4 → 0.1.7

package/README.md

@@ -9,11 +9,11 @@ supported by any of the major RPC libraries.
 
 The [rpcproto](./srpc/rpcproto.proto) file describes the protocol.
 
-Uses any Stream multiplexer: defaults to [libp2p-mplex] over a WebSocket.
+Can use any Stream multiplexer: defaults to [libp2p-mplex] over a WebSocket.
 
 [libp2p-mplex]: https://github.com/libp2p/js-libp2p-mplex
 
-The server side has not yet been implemented in TypeScript.
+Note: the server has not yet been implemented in TypeScript.
 
 # Usage
 

package/dist/srpc/client-rpc.js

@@ -85,7 +85,7 @@ export class ClientRPC {
         const callData = {
             data,
             complete: complete || false,
-            error: error || "",
+            error: error || '',
         };
         await this.writePacket({
             body: {
@@ -144,7 +144,7 @@ export class ClientRPC {
     // close closes the active call if not already completed.
     async close(err) {
         if (!this.closed) {
-            await this.writeCallData(new Uint8Array(0), true, err ? err.message : "");
+            await this.writeCallData(new Uint8Array(0), true, err ? err.message : '');
         }
         if (!err) {
             err = new Error('call closed');

package/dist/srpc/client.js

@@ -38,7 +38,10 @@ function writeClientStream(call, data) {
 }
 // waitCallComplete handles the call complete promise.
 function waitCallComplete(call, resolve, reject) {
-    call.waitComplete().catch(reject).finally(() => {
+    call
+        .waitComplete()
+        .catch(reject)
+        .finally(() => {
         // ensure we resolve it if no data was ever returned.
         resolve(new Uint8Array());
     });
@@ -86,9 +89,12 @@ export class Client {
         };
         this.startRpc(service, method, data, dataCb)
             .then((call) => {
-            call.waitComplete().catch((err) => {
+            call
+                .waitComplete()
+                .catch((err) => {
                 pushServerData.throw(err);
-            }).finally(() => {
+            })
+                .finally(() => {
                 pushServerData.end();
             });
         })
@@ -108,9 +114,12 @@ export class Client {
         this.startRpc(service, method, null, dataCb)
             .then((call) => {
             writeClientStream(call, data);
-            call.waitComplete().catch((err) => {
+            call
+                .waitComplete()
+                .catch((err) => {
                 pushServerData.throw(err);
-            }).finally(() => {
+            })
+                .finally(() => {
                 pushServerData.end();
             });
         })

package/dist/srpc/conn.d.ts

@@ -1,12 +1,16 @@
 import type { Stream } from '@libp2p/interface-connection';
+import type { StreamMuxerFactory } from '@libp2p/interface-stream-muxer';
 import type { Duplex } from 'it-stream-types';
 import type { Stream as SRPCStream } from './stream';
 import { Client } from './client';
+export interface ConnParams {
+    muxerFactory?: StreamMuxerFactory;
+}
 export declare class Conn implements Duplex<Uint8Array> {
     private muxer;
-    constructor();
+    constructor(connParams?: ConnParams);
     get sink(): import("it-stream-types").Sink<Uint8Array, Promise<void>>;
-    get source(): AsyncIterable<Uint8Array>;
+    get source(): import("it-stream-types").Source<Uint8Array>;
     get streams(): Stream[];
     buildClient(): Client;
     openStream(): Promise<SRPCStream>;

package/dist/srpc/conn.js

@@ -1,13 +1,15 @@
-import { Components } from '@libp2p/components';
-import { MplexStreamMuxer } from '@libp2p/mplex';
+import { Mplex } from '@libp2p/mplex';
 import { Client } from './client';
 // Conn implements a generic connection with a two-way stream.
 export class Conn {
     // muxer is the mplex stream muxer.
     muxer;
-    constructor() {
-        // see https://github.com/libp2p/js-libp2p-mplex/pull/179
-        this.muxer = new MplexStreamMuxer(new Components(), {
+    constructor(connParams) {
+        let muxerFactory = connParams?.muxerFactory;
+        if (!muxerFactory) {
+            muxerFactory = new Mplex();
+        }
+        this.muxer = muxerFactory.createStreamMuxer({
             onIncomingStream: this.handleIncomingStream.bind(this),
         });
     }

package/dist/srpc/websocket.js

@@ -1,12 +1,15 @@
 import { Conn } from './conn.js';
 import { duplex } from 'it-ws';
 import { pipe } from 'it-pipe';
+import { Mplex } from '@libp2p/mplex';
 // WebSocketConn implements a connection with a WebSocket.
 export class WebSocketConn extends Conn {
     // socket is the web socket
     socket;
     constructor(socket) {
-        super();
+        super({
+            muxerFactory: new Mplex(),
+        });
         this.socket = socket;
         const socketDuplex = duplex(socket);
         pipe(this.source, socketDuplex, this.sink);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.1.4",
+  "version": "0.1.7",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -42,10 +42,11 @@
     "gen": "make genproto",
     "test": "make test && npm run check",
     "test:integration": "make integration",
+    "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",
-    "postinstall": "patch-package",
+    "prepare": "patch-package",
     "precommit": "npm run format"
   },
   "prettier": {
@@ -80,7 +81,7 @@
     "patch-package": "^6.4.7",
     "protobufjs": "^6.11.3",
     "rxjs": "^7.5.5",
-    "ts-poet": "^4.12.0",
+    "ts-poet": "^4.13.0",
     "ws": "^8.8.0"
   }
 }

package/patches/ts-poet+4.13.0.patch

@@ -0,0 +1,35 @@
+diff --git a/node_modules/ts-poet/build/Import.js b/node_modules/ts-poet/build/Import.js
+index c43569e..a77a1b1 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) {
+         return '';
+     }
+     let result = '';
++    // HACK: take the project root import path from $PROJECT
++    const thisProject = process.env.PROJECT;
++    let ourModuleImportPath = path.normalize(ourModulePath);
++    // HACK: if this is an import from our project, set the path accordingly
++    // github.com/aperturerobotics/protobuf-project/example/example -> ./example/example
++    if (thisProject && ourModuleImportPath.startsWith(thisProject)) {
++        ourModuleImportPath = './' + ourModuleImportPath.substr(thisProject.length + 1);
++    }
+     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) {
+         if (modulePath in importMappings) {
+             modulePath = importMappings[modulePath];
+         }
+-        const importPath = maybeRelativePath(ourModulePath, modulePath);
++        if (thisProject && modulePath.startsWith('./')) {
++            if (!modulePath.substr(2).startsWith(thisProject)) {
++                modulePath = './vendor/' + path.normalize(modulePath);
++            } else {
++                modulePath = './' + modulePath.substr(3 + thisProject.length);
++            }
++        }
++        const importPath = maybeRelativePath(ourModuleImportPath, modulePath);
+         // Output star imports individually
+         unique(filterInstances(imports, ImportsAll).map((i) => i.symbol)).forEach((symbol) => {
+             result += `import * as ${symbol} from '${importPath}';\n`;

package/srpc/client-rpc.ts

@@ -95,11 +95,15 @@ export class ClientRPC {
   }
 
   // writeCallData writes the call data packet.
-  public async writeCallData(data: Uint8Array, complete?: boolean, error?: string) {
+  public async writeCallData(
+    data: Uint8Array,
+    complete?: boolean,
+    error?: string
+  ) {
     const callData: CallData = {
       data,
       complete: complete || false,
-      error: error || "",
+      error: error || '',
     }
     await this.writePacket({
       body: {
@@ -136,7 +140,9 @@ export class ClientRPC {
   // handleCallStart handles a CallStart packet.
   public async handleCallStart(packet: Partial<CallStart>) {
     // we do not implement server -> client RPCs.
-    throw new Error(`unexpected server to client rpc: ${packet.rpcService}/${packet.rpcMethod}`)
+    throw new Error(
+      `unexpected server to client rpc: ${packet.rpcService}/${packet.rpcMethod}`
+    )
   }
 
   // handleCallStartResp handles a CallStartResp packet.
@@ -164,7 +170,7 @@ export class ClientRPC {
   // close closes the active call if not already completed.
   public async close(err?: Error) {
     if (!this.closed) {
-      await this.writeCallData(new Uint8Array(0), true, err ? err.message : "")
+      await this.writeCallData(new Uint8Array(0), true, err ? err.message : '')
     }
     if (!err) {
       err = new Error('call closed')

package/srpc/client.ts

@@ -13,9 +13,7 @@ import {
 
 // unaryDataCb builds a new unary request data callback.
 function unaryDataCb(resolve: (data: Uint8Array) => void): DataCb {
-  return async (
-    data: Uint8Array
-  ): Promise<boolean | void> => {
+  return async (data: Uint8Array): Promise<boolean | void> => {
     // resolve the promise
     resolve(data)
     // this is the last data we expect.
@@ -53,12 +51,15 @@ function writeClientStream(call: ClientRPC, data: Observable<Uint8Array>) {
 function waitCallComplete(
   call: ClientRPC,
   resolve: (data: Uint8Array) => void,
-  reject: (err: Error) => void,
+  reject: (err: Error) => void
 ) {
-  call.waitComplete().catch(reject).finally(() => {
-    // ensure we resolve it if no data was ever returned.
-    resolve(new Uint8Array())
-  })
+  call
+    .waitComplete()
+    .catch(reject)
+    .finally(() => {
+      // ensure we resolve it if no data was ever returned.
+      resolve(new Uint8Array())
+    })
 }
 
 // Client implements the ts-proto Rpc interface with the drpcproto protocol.
@@ -112,7 +113,9 @@ export class Client implements TsProtoRpc {
   ): Observable<Uint8Array> {
     const pushServerData: Pushable<Uint8Array> = pushable()
     const serverData = observableFrom(pushServerData)
-    const dataCb: DataCb = async (data: Uint8Array): Promise<boolean | void> => {
+    const dataCb: DataCb = async (
+      data: Uint8Array
+    ): Promise<boolean | void> => {
       // push the message to the observable
       pushServerData.push(data)
       // expect more messages
@@ -120,11 +123,14 @@ export class Client implements TsProtoRpc {
     }
     this.startRpc(service, method, data, dataCb)
       .then((call) => {
-        call.waitComplete().catch((err: Error) => {
-          pushServerData.throw(err)
-        }).finally(() => {
-          pushServerData.end()
-        })
+        call
+          .waitComplete()
+          .catch((err: Error) => {
+            pushServerData.throw(err)
+          })
+          .finally(() => {
+            pushServerData.end()
+          })
       })
       .catch(pushServerData.throw.bind(pushServerData))
     return serverData
@@ -138,7 +144,9 @@ export class Client implements TsProtoRpc {
   ): Observable<Uint8Array> {
     const pushServerData: Pushable<Uint8Array> = pushable()
     const serverData = observableFrom(pushServerData)
-    const dataCb: DataCb = async (data: Uint8Array): Promise<boolean | void> => {
+    const dataCb: DataCb = async (
+      data: Uint8Array
+    ): Promise<boolean | void> => {
       // push the message to the observable
       pushServerData.push(data)
       // expect more messages
@@ -147,11 +155,14 @@ export class Client implements TsProtoRpc {
     this.startRpc(service, method, null, dataCb)
       .then((call) => {
         writeClientStream(call, data)
-        call.waitComplete().catch((err: Error) => {
-          pushServerData.throw(err)
-        }).finally(() => {
-          pushServerData.end()
-        })
+        call
+          .waitComplete()
+          .catch((err: Error) => {
+            pushServerData.throw(err)
+          })
+          .finally(() => {
+            pushServerData.end()
+          })
       })
       .catch(pushServerData.throw.bind(pushServerData))
     return serverData
@@ -174,7 +185,7 @@ export class Client implements TsProtoRpc {
       call,
       encodePacketSource,
       prependLengthPrefixTransform(),
-      conn,
+      conn
     )
     await call.writeCallStart(data || undefined)
     return call

package/srpc/conn.ts

@@ -1,18 +1,27 @@
 import type { Stream } from '@libp2p/interface-connection'
+import type { StreamMuxer, StreamMuxerFactory } from '@libp2p/interface-stream-muxer'
 import type { Duplex } from 'it-stream-types'
-import { Components } from '@libp2p/components'
-import { MplexStreamMuxer } from '@libp2p/mplex'
+import { Mplex } from '@libp2p/mplex'
 import type { Stream as SRPCStream } from './stream'
 import { Client } from './client'
 
+// ConnParams are parameters that can be passed to the Conn constructor.
+export interface ConnParams {
+  // muxerFactory overrides using the default factory (@libp2p/mplex).
+  muxerFactory?: StreamMuxerFactory
+}
+
 // Conn implements a generic connection with a two-way stream.
 export class Conn implements Duplex<Uint8Array> {
   // muxer is the mplex stream muxer.
-  private muxer: MplexStreamMuxer
-
-  constructor() {
-    // see https://github.com/libp2p/js-libp2p-mplex/pull/179
-    this.muxer = new MplexStreamMuxer(new Components(), {
+  private muxer: StreamMuxer
+
+  constructor(connParams?: ConnParams) {
+    let muxerFactory = connParams?.muxerFactory
+    if (!muxerFactory) {
+      muxerFactory = new Mplex()
+    }
+    this.muxer = muxerFactory.createStreamMuxer({
       onIncomingStream: this.handleIncomingStream.bind(this),
     })
   }

package/srpc/packet.ts

@@ -47,7 +47,11 @@ const uint32LEDecode = (data: Uint8Array) => {
 uint32LEDecode.bytes = 4
 
 // uint32LEEncode adds the length prefix.
-const uint32LEEncode = (value: number, target?: Uint8Array, offset?: number) => {
+const uint32LEEncode = (
+  value: number,
+  target?: Uint8Array,
+  offset?: number
+) => {
   target = target ?? new Uint8Array(4)
   const view = new DataView(target.buffer, target.byteOffset, target.byteLength)
   view.setUint32(offset ?? 0, value, true)
@@ -58,7 +62,7 @@ uint32LEEncode.bytes = 4
 // prependLengthPrefixTransform adds a length prefix to a message source.
 // little-endian uint32
 export function prependLengthPrefixTransform(): Transform<Uint8Array> {
-  return lengthPrefixEncode({lengthEncoder: uint32LEEncode})
+  return lengthPrefixEncode({ lengthEncoder: uint32LEEncode })
 }
 
 // parseLengthPrefixTransform parses the length prefix from a message source.

package/srpc/websocket.ts

@@ -1,6 +1,7 @@
 import { Conn } from './conn.js'
 import { duplex } from 'it-ws'
 import { pipe } from 'it-pipe'
+import { Mplex } from '@libp2p/mplex'
 import type WebSocket from 'isomorphic-ws'
 
 // WebSocketConn implements a connection with a WebSocket.
@@ -9,7 +10,9 @@ export class WebSocketConn extends Conn {
   private socket: WebSocket
 
   constructor(socket: WebSocket) {
-    super()
+    super({
+      muxerFactory: new Mplex(),
+    })
     this.socket = socket
     const socketDuplex = duplex(socket)
     pipe(this.source, socketDuplex, this.sink)

package/patches/@libp2p+mplex+2.0.0.patch

@@ -1,23 +0,0 @@
-diff --git a/node_modules/@libp2p/mplex/dist/src/index.d.ts b/node_modules/@libp2p/mplex/dist/src/index.d.ts
-index 14c5f6e..32d0ee0 100644
---- a/node_modules/@libp2p/mplex/dist/src/index.d.ts
-+++ b/node_modules/@libp2p/mplex/dist/src/index.d.ts
-@@ -1,6 +1,7 @@
- import { Components, Initializable } from '@libp2p/components';
- import type { StreamMuxerFactory, StreamMuxerInit } from '@libp2p/interface-stream-muxer';
- import { MplexStreamMuxer } from './mplex.js';
-+export { MplexStreamMuxer } from './mplex.js';
- export interface MplexInit {
-     /**
-      * The maximum size of message that can be sent in one go in bytes.
-diff --git a/node_modules/@libp2p/mplex/dist/src/index.js b/node_modules/@libp2p/mplex/dist/src/index.js
-index 4d692df..7bf592c 100644
---- a/node_modules/@libp2p/mplex/dist/src/index.js
-+++ b/node_modules/@libp2p/mplex/dist/src/index.js
-@@ -1,5 +1,6 @@
- import { Components } from '@libp2p/components';
- import { MplexStreamMuxer } from './mplex.js';
-+export { MplexStreamMuxer } from './mplex.js';
- export class Mplex {
-     constructor(init = {}) {
-         this.protocol = '/mplex/6.7.0';

package/patches/ts-poet+4.12.0.patch

@@ -1,72 +0,0 @@
-diff --git a/node_modules/ts-poet/build/Import.js b/node_modules/ts-poet/build/Import.js
-index 955a7eb..0ad3a67 100644
---- a/node_modules/ts-poet/build/Import.js
-+++ b/node_modules/ts-poet/build/Import.js
-@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
- exports.sameModule = exports.maybeRelativePath = exports.emitImports = exports.SideEffect = exports.Augmented = exports.ImportsAll = exports.ImportsDefault = exports.ImportsName = exports.Imported = exports.Implicit = exports.Import = exports.importType = void 0;
- const lodash_1 = __importDefault(require("lodash"));
- const path_1 = __importDefault(require("path"));
-+const path = require("path");
- const Node_1 = require("./Node");
- const typeImportMarker = '(?:t:)?';
- const fileNamePattern = '(?:[a-zA-Z0-9._-]+)';
-@@ -274,6 +275,15 @@ function emitImports(imports, ourModulePath, importMappings) {
-         return '';
-     }
-     let result = '';
-+    const thisProject = process.env.PROJECT;
-+    let ourModuleImportPath = path.normalize(ourModulePath);
-+    // HACK: if this is an import from our project, set the path accordingly
-+    // github.com/aperturerobotics/protobuf-project/example/example -> ./example/example
-+    if (thisProject && ourModuleImportPath.startsWith(thisProject)) {
-+        ourModuleImportPath = './' + ourModuleImportPath.substr(thisProject.length + 1);
-+    }
-+    // result += `// ourModulePath: ${ourModulePath}\n`;
-+    // result += `// ourModuleImportPath: ${ourModuleImportPath}\n`;
-     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 &&
-@@ -288,7 +298,16 @@ function emitImports(imports, ourModulePath, importMappings) {
-         if (modulePath in importMappings) {
-             modulePath = importMappings[modulePath];
-         }
--        const importPath = maybeRelativePath(ourModulePath, modulePath);
-+        // HACK: if this is an import from a different project, use vendor/ tree.
-+        if (thisProject && modulePath.startsWith('./')) {
-+            if (!modulePath.substr(2).startsWith(thisProject)) {
-+                modulePath = './vendor/' + path.normalize(modulePath);
-+            } else {
-+                modulePath = './' + modulePath.substr(3 + thisProject.length);
-+            }
-+        }
-+        // result += `// modulePath: ${modulePath}\n`;
-+        const importPath = maybeRelativePath(ourModuleImportPath, modulePath);
-         // Output star imports individually
-         unique(filterInstances(imports, ImportsAll).map((i) => i.symbol)).forEach((symbol) => {
-             result += `import * as ${symbol} from '${importPath}';\n`;
-@@ -337,17 +356,15 @@ function maybeRelativePath(outputPath, importPath) {
-     if (!importPath.startsWith('./')) {
-         return importPath;
-     }
--    // Drop the `./` prefix from the outputPath if it exists.
--    const basePath = outputPath.replace(/^.\//, '');
--    // Ideally we'd use a path library to do all this.
--    const numberOfDirs = basePath.split('').filter((l) => l === '/').length;
--    if (numberOfDirs === 0) {
--        return importPath;
-+    importPath = path.normalize(importPath);
-+    outputPath = path.normalize(outputPath);
-+    const outputPathDir = path.dirname(outputPath);
-+    let relativePath = path.relative(outputPathDir, importPath);
-+    if (!relativePath.startsWith('.')) {
-+      // ensure the js compiler recognizes this is a relative path.
-+      relativePath = './' + relativePath;
-     }
--    // Make an array of `..` to get our importPath to the root directory.
--    const a = new Array(numberOfDirs);
--    const prefix = a.fill('..', 0, numberOfDirs).join('/');
--    return prefix + importPath.substring(1);
-+    return relativePath;
- }
- exports.maybeRelativePath = maybeRelativePath;
- /** Checks if `path1 === path2` despite minor path differences like `./foo` and `foo`. */