starpc 0.17.0 → 0.18.0

package/dist/rpcstream/rpcstream.d.ts

@@ -4,7 +4,7 @@ import { Pushable } from 'it-pushable';
 import { Source, Sink } from 'it-stream-types';
 import { Uint8ArrayList } from 'uint8arraylist';
 export type RpcStreamCaller = (request: AsyncIterable<RpcStreamPacket>) => AsyncIterable<RpcStreamPacket>;
-export declare function openRpcStream(componentId: string, caller: RpcStreamCaller): Promise<Stream>;
+export declare function openRpcStream(componentId: string, caller: RpcStreamCaller, waitAck?: boolean): Promise<Stream>;
 export declare function buildRpcStreamOpenStream(componentId: string, caller: RpcStreamCaller): OpenStreamFunc;
 export type RpcStreamHandler = (stream: Stream) => void;
 export type RpcStreamGetter = (componentId: string) => Promise<RpcStreamHandler | null>;

package/dist/rpcstream/rpcstream.js

@@ -1,7 +1,7 @@
 import { pushable } from 'it-pushable';
 // openRpcStream attempts to open a stream over a RPC call.
-// waits for the remote to ack the stream before returning.
-export async function openRpcStream(componentId, caller) {
+// if waitAck is set, waits for the remote to ack the stream before returning.
+export async function openRpcStream(componentId, caller, waitAck) {
     const packetSink = pushable({ objectMode: true });
     const packetSource = caller(packetSink);
     // write the component id
@@ -11,21 +11,24 @@ export async function openRpcStream(componentId, caller) {
             init: { componentId },
         },
     });
-    // wait for ack
+    // construct packet stream
     const packetIt = packetSource[Symbol.asyncIterator]();
-    const ackPacketIt = await packetIt.next();
-    if (ackPacketIt.done) {
-        throw new Error(`rpcstream: closed before ack packet`);
-    }
-    const ackPacket = ackPacketIt.value;
-    const ackBody = ackPacket?.body;
-    if (!ackBody || ackBody.$case !== 'ack') {
-        const msgType = ackBody?.$case || 'none';
-        throw new Error(`rpcstream: expected ack packet but got ${msgType}`);
-    }
-    const errStr = ackBody.ack?.error;
-    if (errStr) {
-        throw new Error(`rpcstream: remote: ${errStr}`);
+    // wait for ack, if set.
+    if (waitAck) {
+        const ackPacketIt = await packetIt.next();
+        if (ackPacketIt.done) {
+            throw new Error(`rpcstream: closed before ack packet`);
+        }
+        const ackPacket = ackPacketIt.value;
+        const ackBody = ackPacket?.body;
+        if (!ackBody || ackBody.$case !== 'ack') {
+            const msgType = ackBody?.$case || 'none';
+            throw new Error(`rpcstream: expected ack packet but got ${msgType}`);
+        }
+        const errStr = ackBody.ack?.error;
+        if (errStr) {
+            throw new Error(`rpcstream: remote: ${errStr}`);
+        }
     }
     // build & return the data stream
     return new RpcStream(packetSink, packetIt); // packetSource)
@@ -136,10 +139,19 @@ export class RpcStream {
                 }
                 const value = msgIt.value;
                 const body = value?.body;
-                if (!body || body.$case !== 'data') {
+                if (!body) {
                     continue;
                 }
-                yield* [body.data];
+                switch (body.$case) {
+                    case 'ack':
+                        if (body.ack?.error?.length) {
+                            throw new Error(body.ack.error);
+                        }
+                        break;
+                    case 'data':
+                        yield* [body.data];
+                        break;
+                }
             }
         })();
     }

package/dist/srpc/index.d.ts

@@ -8,7 +8,7 @@ export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { Mux, StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
-export { MessageDefinition, DecodeMessageTransform, buildDecodeMessageTransform, EncodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
+export { MessageDefinition, DecodeMessageTransform, buildDecodeMessageTransform, EncodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';
 export { writeToPushable } from './pushable';

package/dist/srpc/index.js

@@ -7,7 +7,7 @@ export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { StaticMux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
-export { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
+export { buildDecodeMessageTransform, buildEncodeMessageTransform, memoProto, memoProtoDecode, } from './message.js';
 export { ValueCtr } from './value-ctr.js';
 export { OpenStreamCtr } from './open-stream-ctr.js';
 export { writeToPushable } from './pushable';

package/dist/srpc/message.d.ts

@@ -1,10 +1,13 @@
 import * as pbjs from 'protobufjs/minimal';
 import type { Source } from 'it-stream-types';
 export interface MessageDefinition<T> {
+    create(msg?: Partial<T>): T;
     encode(message: T, writer?: pbjs.Writer): pbjs.Writer;
     decode(input: pbjs.Reader | Uint8Array, length?: number): T;
 }
+export declare function memoProto<T>(def: MessageDefinition<T>): (msg: Partial<T>) => Uint8Array;
+export declare function memoProtoDecode<T>(def: MessageDefinition<T>): (msg: Uint8Array) => T;
 export type DecodeMessageTransform<T> = (source: Source<Uint8Array | Uint8Array[]>) => AsyncIterable<T>;
-export declare function buildDecodeMessageTransform<T>(def: MessageDefinition<T>): DecodeMessageTransform<T>;
+export declare function buildDecodeMessageTransform<T>(def: MessageDefinition<T>, memoize?: boolean): DecodeMessageTransform<T>;
 export type EncodeMessageTransform<T> = (source: Source<T | T[]>) => AsyncIterable<Uint8Array>;
-export declare function buildEncodeMessageTransform<T>(def: MessageDefinition<T>): EncodeMessageTransform<T>;
+export declare function buildEncodeMessageTransform<T>(def: MessageDefinition<T>, memoize?: boolean): EncodeMessageTransform<T>;

package/dist/srpc/message.js

@@ -1,31 +1,53 @@
+import memoize from 'memoize-one';
+// memoProto returns a function that encodes the message and caches the result.
+export function memoProto(def) {
+    return memoize((msg) => {
+        return def.encode(def.create(msg)).finish();
+    });
+}
+// memoProtoDecode returns a function that decodes the message and caches the result.
+export function memoProtoDecode(def) {
+    return memoize((msg) => {
+        return def.decode(msg);
+    });
+}
 // buildDecodeMessageTransform builds a source of decoded messages.
-export function buildDecodeMessageTransform(def) {
+//
+// set memoize if you expect to repeatedly see the same message.
+export function buildDecodeMessageTransform(def, memoize) {
+    const decode = memoize ? memoProtoDecode(def) : def.decode.bind(def);
     // decodeMessageSource unmarshals and async yields encoded Messages.
     return async function* decodeMessageSource(source) {
         for await (const pkt of source) {
             if (Array.isArray(pkt)) {
                 for (const p of pkt) {
-                    yield* [def.decode(p)];
+                    yield* [decode(p)];
                 }
             }
             else {
-                yield* [def.decode(pkt)];
+                yield* [decode(pkt)];
             }
         }
     };
 }
 // buildEncodeMessageTransform builds a source of decoded messages.
-export function buildEncodeMessageTransform(def) {
+// set memoize if you expect to repeatedly encode the same message.
+export function buildEncodeMessageTransform(def, memoize) {
+    const encode = memoize
+        ? memoProto(def)
+        : (msg) => {
+            return def.encode(msg).finish();
+        };
     // encodeMessageSource encodes messages to byte arrays.
     return async function* encodeMessageSource(source) {
         for await (const pkt of source) {
             if (Array.isArray(pkt)) {
                 for (const p of pkt) {
-                    yield* [def.encode(p).finish()];
+                    yield* [encode(p)];
                 }
             }
             else {
-                yield* [def.encode(pkt).finish()];
+                yield* [encode(pkt)];
             }
         }
     };

package/e2e/e2e_test.go

@@ -227,7 +227,7 @@ func TestE2E_RpcStream(t *testing.T) {
 	RunE2E(t, func(client echo.SRPCEchoerClient) error {
 		openStreamFn := rpcstream.NewRpcStreamOpenStream(func(ctx context.Context) (rpcstream.RpcStream, error) {
 			return client.RpcStream(ctx)
-		}, "test")
+		}, "test", false)
 		proxiedClient := srpc.NewClient(openStreamFn)
 		proxiedSvc := echo.NewSRPCEchoerClient(proxiedClient)
 

package/go.mod

@@ -9,7 +9,7 @@ require (
 )
 
 require (
-	github.com/aperturerobotics/util v0.0.0-20230105015752-3e6dd02b20c6
+	github.com/aperturerobotics/util v1.0.3-0.20230130061818-dab10b56858b
 	github.com/libp2p/go-libp2p v0.24.2
 	github.com/libp2p/go-yamux/v4 v4.0.1-0.20220919134236-1c09f2ab3ec1
 	github.com/sirupsen/logrus v1.9.0

package/go.sum

@@ -1,5 +1,5 @@
-github.com/aperturerobotics/util v0.0.0-20230105015752-3e6dd02b20c6 h1:YCg1Eyh5M5SvWCpJmdM62iInd0yfZXSGFld10GQIIPA=
-github.com/aperturerobotics/util v0.0.0-20230105015752-3e6dd02b20c6/go.mod h1:up2AYcp62UgmFVTm7QhM4USXAKGv73gpb5dHraKmzxQ=
+github.com/aperturerobotics/util v1.0.3-0.20230130061818-dab10b56858b h1:E+riBVCoYAZL2ATHTlDZYZRZj/6FPb+UGHVTQdU03UU=
+github.com/aperturerobotics/util v1.0.3-0.20230130061818-dab10b56858b/go.mod h1:gFLdglkzXYEWP/iYrOGeJEKzfjarlMDPrLNLgwDHC1o=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
 github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
 github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.17.0",
+  "version": "0.18.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -36,7 +36,7 @@
     "build": "rimraf ./dist && tsc --project tsconfig.build.json --outDir ./dist/",
     "check": "npm run typecheck",
     "typecheck": "tsc --noEmit",
-    "deps": "depcheck --ignores 'bufferutil,utf-8-validate,ts-proto,@aperturerobotics/ts-common'",
+    "deps": "depcheck --ignores 'bufferutil,utf-8-validate,ts-proto,rimraf,@aperturerobotics/ts-common'",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
     "format": "prettier --write './{srpc,echo,e2e,integration,rpcstream}/**/(*.ts|*.tsx|*.html|*.css)'",
@@ -71,7 +71,7 @@
     "prettier": "^2.8.3",
     "rimraf": "^4.1.0",
     "ts-proto": "^1.138.0",
-    "typescript": "^4.9.4",
+    "typescript": "^4.9.5",
     "utf-8-validate": "^6.0.0"
   },
   "dependencies": {
@@ -88,6 +88,7 @@
     "it-stream-types": "^1.0.5",
     "it-ws": "^5.0.6",
     "long": "^5.2.1",
+    "memoize-one": "^6.0.0",
     "patch-package": "^6.5.1",
     "protobufjs": "^7.1.2",
     "uint8arraylist": "^2.4.3",

package/srpc/index.ts

@@ -22,6 +22,8 @@ export {
   buildDecodeMessageTransform,
   EncodeMessageTransform,
   buildEncodeMessageTransform,
+  memoProto,
+  memoProtoDecode,
 } from './message.js'
 export { ValueCtr } from './value-ctr.js'
 export { OpenStreamCtr } from './open-stream-ctr.js'

package/srpc/message.ts

@@ -1,23 +1,49 @@
 import * as pbjs from 'protobufjs/minimal'
 import type { Source } from 'it-stream-types'
+import memoize from 'memoize-one'
 
 // MessageDefinition represents a ts-proto message definition.
 export interface MessageDefinition<T> {
+  // create creates a full message from a partial and/or no message.
+  create(msg?: Partial<T>): T
   // encode encodes the message and returns writer.
   encode(message: T, writer?: pbjs.Writer): pbjs.Writer
   // decode decodes the message from the reader
   decode(input: pbjs.Reader | Uint8Array, length?: number): T
 }
 
+// memoProto returns a function that encodes the message and caches the result.
+export function memoProto<T>(
+  def: MessageDefinition<T>
+): (msg: Partial<T>) => Uint8Array {
+  return memoize((msg: Partial<T>): Uint8Array => {
+    return def.encode(def.create(msg)).finish()
+  })
+}
+
+// memoProtoDecode returns a function that decodes the message and caches the result.
+export function memoProtoDecode<T>(
+  def: MessageDefinition<T>
+): (msg: Uint8Array) => T {
+  return memoize((msg: Uint8Array): T => {
+    return def.decode(msg)
+  })
+}
+
 // DecodeMessageTransform decodes messages to objects.
 export type DecodeMessageTransform<T> = (
   source: Source<Uint8Array | Uint8Array[]>
 ) => AsyncIterable<T>
 
 // buildDecodeMessageTransform builds a source of decoded messages.
+//
+// set memoize if you expect to repeatedly see the same message.
 export function buildDecodeMessageTransform<T>(
-  def: MessageDefinition<T>
+  def: MessageDefinition<T>,
+  memoize?: boolean
 ): DecodeMessageTransform<T> {
+  const decode = memoize ? memoProtoDecode(def) : def.decode.bind(def)
+
   // decodeMessageSource unmarshals and async yields encoded Messages.
   return async function* decodeMessageSource(
     source: Source<Uint8Array | Uint8Array[]>
@@ -25,10 +51,10 @@ export function buildDecodeMessageTransform<T>(
     for await (const pkt of source) {
       if (Array.isArray(pkt)) {
         for (const p of pkt) {
-          yield* [def.decode(p)]
+          yield* [decode(p)]
         }
       } else {
-        yield* [def.decode(pkt)]
+        yield* [decode(pkt)]
       }
     }
   }
@@ -40,9 +66,17 @@ export type EncodeMessageTransform<T> = (
 ) => AsyncIterable<Uint8Array>
 
 // buildEncodeMessageTransform builds a source of decoded messages.
+// set memoize if you expect to repeatedly encode the same message.
 export function buildEncodeMessageTransform<T>(
-  def: MessageDefinition<T>
+  def: MessageDefinition<T>,
+  memoize?: boolean
 ): EncodeMessageTransform<T> {
+  const encode = memoize
+    ? memoProto(def)
+    : (msg: T): Uint8Array => {
+        return def.encode(msg).finish()
+      }
+
   // encodeMessageSource encodes messages to byte arrays.
   return async function* encodeMessageSource(
     source: Source<T | T[]>
@@ -50,10 +84,10 @@ export function buildEncodeMessageTransform<T>(
     for await (const pkt of source) {
       if (Array.isArray(pkt)) {
         for (const p of pkt) {
-          yield* [def.encode(p).finish()]
+          yield* [encode(p)]
         }
       } else {
-        yield* [def.encode(pkt).finish()]
+        yield* [encode(pkt)]
       }
     }
   }