starpc 0.4.9 → 0.5.0

package/dist/srpc/definition.d.ts

@@ -6,10 +6,10 @@ export interface Definition {
         [id: string]: MethodDefinition<unknown, unknown>;
     };
 }
-export interface MethodDefinition<RequestType, ResponseType> {
+export interface MethodDefinition<RequestT, ResponseT> {
     name: string;
-    requestType: MessageDefinition<RequestType>;
+    requestType: MessageDefinition<RequestT>;
     requestStream: boolean;
-    responseType: MessageDefinition<ResponseType>;
+    responseType: MessageDefinition<ResponseT>;
     responseStream: boolean;
 }

package/dist/srpc/handler.d.ts

@@ -1,5 +1,4 @@
 import type { Sink, Source } from 'it-stream-types';
-import { Observable } from 'rxjs';
 import { Definition, MethodDefinition } from './definition.js';
 export declare type InvokeFn = (dataSource: Source<Uint8Array>, dataSink: Sink<Uint8Array>) => Promise<void>;
 export interface Handler {
@@ -18,7 +17,7 @@ export declare class StaticHandler implements Handler {
     getMethodIDs(): string[];
     lookupMethod(serviceID: string, methodID: string): Promise<InvokeFn | null>;
 }
-declare type MethodProto = ((request: unknown) => Promise<unknown>) | ((request: unknown) => Observable<unknown>) | ((request: Observable<unknown>) => Promise<unknown>) | ((request: Observable<unknown>) => Observable<unknown>);
-export declare function createInvokeFn(methodInfo: MethodDefinition<unknown, unknown>, methodProto: MethodProto): InvokeFn;
+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 {};

package/dist/srpc/handler.js

@@ -1,7 +1,7 @@
 import { pipe } from 'it-pipe';
 import { pushable } from 'it-pushable';
-import { from as observableFrom } from 'rxjs';
 import { buildDecodeMessageTransform, buildEncodeMessageTransform, } from './message.js';
+import { writeToPushable } from './pushable.js';
 // StaticHandler is a handler with a definition and implementation.
 export class StaticHandler {
     constructor(serviceID, methods) {
@@ -40,8 +40,8 @@ export function createInvokeFn(methodInfo, methodProto) {
         // build the request argument.
         let requestArg;
         if (methodInfo.requestStream) {
-            // convert the request data source into an Observable<T>
-            requestArg = observableFrom(requestSource);
+            // use the request source as the argument.
+            requestArg = requestSource;
         }
         else {
             // receive a single message for the argument.
@@ -62,25 +62,8 @@ export function createInvokeFn(methodInfo, methodProto) {
                 throw new Error('return value was undefined');
             }
             if (methodInfo.responseStream) {
-                const responseObs = responseObj;
-                if (!responseObs.subscribe) {
-                    throw new Error('expected return value to be an Observable');
-                }
-                return new Promise((resolve, reject) => {
-                    responseObs.subscribe({
-                        next(value) {
-                            responseSink.push(value);
-                        },
-                        error: (err) => {
-                            responseSink.throw(err);
-                            reject(err);
-                        },
-                        complete: () => {
-                            responseSink.end();
-                            resolve();
-                        },
-                    });
-                });
+                const response = responseObj;
+                return writeToPushable(response, responseSink);
             }
             else {
                 const responsePromise = responseObj;

package/dist/srpc/index.d.ts

@@ -7,4 +7,4 @@ export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { Mux, createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
-export { ObservableSource } from './observable-source.js';
+export { writeToPushable } from './pushable';

package/dist/srpc/index.js

@@ -6,4 +6,4 @@ export { Packet, CallStart, CallData } from './rpcproto.pb.js';
 export { createMux } from './mux.js';
 export { BroadcastChannelDuplex, newBroadcastChannelDuplex, BroadcastChannelConn, } from './broadcast-channel.js';
 export { MessagePortIterable, newMessagePortIterable, MessagePortConn, } from './message-port.js';
-export { ObservableSource } from './observable-source.js';
+export { writeToPushable } from './pushable';

package/dist/srpc/packet.js

@@ -66,35 +66,3 @@ export function prependPacketLen(msgData) {
     merged.set(msgData, msgLenData.length);
     return merged;
 }
-/*
-// buildCallDataPacket builds a CallData packet.
-function buildCallDataPacket(data: Uint8Array): Packet {
-  const callData: CallData = {
-    data: p,
-    complete: false,
-    error: '',
-  }
-  const pkt: Packet = {
-    body: {
-      $case: 'callData',
-      callData: callData,
-    }
-  }
-  return pkt
-}
-
-// wrapCallDataTransform is a transformer that wraps call data into a Packet.
-export async function* wrapCallDataTransform(
-  source: Source<Uint8Array | Uint8Array>
-): AsyncIterable<Packet> {
-  for await (const pkt of source) {
-    if (Array.isArray(pkt)) {
-      for (const p of pkt) {
-        yield* [buildCallDataPacket(p)]
-      }
-    } else {
-      yield* [buildCallDataPacket(pkt)]
-    }
-  }
-}
-*/

package/dist/srpc/pushable.d.ts

@@ -0,0 +1,2 @@
+import { Pushable } from 'it-pushable';
+export declare function writeToPushable<T>(dataSource: AsyncIterable<T>, out: Pushable<T>): Promise<void>;

package/dist/srpc/pushable.js

@@ -0,0 +1,13 @@
+// writeToPushable writes the incoming server data to the pushable.
+export async function writeToPushable(dataSource, out) {
+    try {
+        for await (const data of dataSource) {
+            out.push(data);
+        }
+        out.end();
+    }
+    catch (err) {
+        out.end(err);
+        throw err;
+    }
+}

package/dist/srpc/rpcproto.pb.d.ts

@@ -1,14 +1,15 @@
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
+import { CallStart as CallStart1, CallData as CallData2 } from './rpcproto.pb.js';
 export declare const protobufPackage = "srpc";
 /** Packet is a message sent over a srpc packet connection. */
 export interface Packet {
     body?: {
         $case: 'callStart';
-        callStart: CallStart;
+        callStart: CallStart1;
     } | {
         $case: 'callData';
-        callData: CallData;
+        callData: CallData2;
     };
 }
 /** CallStart requests starting a new RPC call. */
@@ -48,6 +49,8 @@ export interface CallData {
 export declare const Packet: {
     encode(message: Packet, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): Packet;
+    encodeTransform(source: AsyncIterable<Packet | Packet[]> | Iterable<Packet | Packet[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<Packet>;
     fromJSON(object: any): Packet;
     toJSON(message: Packet): unknown;
     fromPartial<I extends {
@@ -91,7 +94,7 @@ export declare const Packet: {
                 rpcMethod?: string | undefined;
                 data?: Uint8Array | undefined;
                 dataIsZero?: boolean | undefined;
-            } & Record<Exclude<keyof I["body"]["callStart"], keyof CallStart>, never>) | undefined;
+            } & Record<Exclude<keyof I["body"]["callStart"], keyof CallStart1>, never>) | undefined;
             $case: "callStart";
         } & Record<Exclude<keyof I["body"], "callStart" | "$case">, never>) | ({
             callData?: {
@@ -113,7 +116,7 @@ export declare const Packet: {
                 dataIsZero?: boolean | undefined;
                 complete?: boolean | undefined;
                 error?: string | undefined;
-            } & Record<Exclude<keyof I["body"]["callData"], keyof CallData>, never>) | undefined;
+            } & Record<Exclude<keyof I["body"]["callData"], keyof CallData2>, never>) | undefined;
             $case: "callData";
         } & Record<Exclude<keyof I["body"], "callData" | "$case">, never>) | undefined;
     } & Record<Exclude<keyof I, "body">, never>>(object: I): Packet;
@@ -121,6 +124,8 @@ export declare const Packet: {
 export declare const CallStart: {
     encode(message: CallStart, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): CallStart;
+    encodeTransform(source: AsyncIterable<CallStart | CallStart[]> | Iterable<CallStart | CallStart[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<CallStart>;
     fromJSON(object: any): CallStart;
     toJSON(message: CallStart): unknown;
     fromPartial<I extends {
@@ -133,11 +138,13 @@ export declare const CallStart: {
         rpcMethod?: string | undefined;
         data?: Uint8Array | undefined;
         dataIsZero?: boolean | undefined;
-    } & Record<Exclude<keyof I, keyof CallStart>, never>>(object: I): CallStart;
+    } & Record<Exclude<keyof I, keyof CallStart1>, never>>(object: I): CallStart;
 };
 export declare const CallData: {
     encode(message: CallData, writer?: _m0.Writer): _m0.Writer;
     decode(input: _m0.Reader | Uint8Array, length?: number): CallData;
+    encodeTransform(source: AsyncIterable<CallData | CallData[]> | Iterable<CallData | CallData[]>): AsyncIterable<Uint8Array>;
+    decodeTransform(source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>): AsyncIterable<CallData>;
     fromJSON(object: any): CallData;
     toJSON(message: CallData): unknown;
     fromPartial<I extends {
@@ -150,7 +157,7 @@ export declare const CallData: {
         dataIsZero?: boolean | undefined;
         complete?: boolean | undefined;
         error?: string | undefined;
-    } & Record<Exclude<keyof I, keyof CallData>, never>>(object: I): CallData;
+    } & Record<Exclude<keyof I, keyof CallData2>, never>>(object: I): CallData;
 };
 declare type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
 export declare type DeepPartial<T> = T extends Builtin ? T : T extends Long ? string | number | Long : T extends Array<infer U> ? Array<DeepPartial<U>> : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>> : T extends {

package/dist/srpc/rpcproto.pb.js

@@ -1,6 +1,7 @@
 /* eslint-disable */
 import Long from 'long';
 import * as _m0 from 'protobufjs/minimal';
+import { CallStart as CallStart1, CallData as CallData2, } from './rpcproto.pb.js';
 export const protobufPackage = 'srpc';
 function createBasePacket() {
     return { body: undefined };
@@ -8,10 +9,10 @@ function createBasePacket() {
 export const Packet = {
     encode(message, writer = _m0.Writer.create()) {
         if (message.body?.$case === 'callStart') {
-            CallStart.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
+            CallStart1.encode(message.body.callStart, writer.uint32(10).fork()).ldelim();
         }
         if (message.body?.$case === 'callData') {
-            CallData.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
+            CallData2.encode(message.body.callData, writer.uint32(18).fork()).ldelim();
         }
         return writer;
     },
@@ -25,13 +26,13 @@ export const Packet = {
                 case 1:
                     message.body = {
                         $case: 'callStart',
-                        callStart: CallStart.decode(reader, reader.uint32()),
+                        callStart: CallStart1.decode(reader, reader.uint32()),
                     };
                     break;
                 case 2:
                     message.body = {
                         $case: 'callData',
-                        callData: CallData.decode(reader, reader.uint32()),
+                        callData: CallData2.decode(reader, reader.uint32()),
                     };
                     break;
                 default:
@@ -41,15 +42,43 @@ export const Packet = {
         }
         return message;
     },
+    // encodeTransform encodes a source of message objects.
+    // Transform<Packet, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [Packet.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [Packet.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, Packet>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [Packet.decode(p)];
+                }
+            }
+            else {
+                yield* [Packet.decode(pkt)];
+            }
+        }
+    },
     fromJSON(object) {
         return {
             body: isSet(object.callStart)
                 ? {
                     $case: 'callStart',
-                    callStart: CallStart.fromJSON(object.callStart),
+                    callStart: CallStart1.fromJSON(object.callStart),
                 }
                 : isSet(object.callData)
-                    ? { $case: 'callData', callData: CallData.fromJSON(object.callData) }
+                    ? { $case: 'callData', callData: CallData2.fromJSON(object.callData) }
                     : undefined,
         };
     },
@@ -57,11 +86,11 @@ export const Packet = {
         const obj = {};
         message.body?.$case === 'callStart' &&
             (obj.callStart = message.body?.callStart
-                ? CallStart.toJSON(message.body?.callStart)
+                ? CallStart1.toJSON(message.body?.callStart)
                 : undefined);
         message.body?.$case === 'callData' &&
             (obj.callData = message.body?.callData
-                ? CallData.toJSON(message.body?.callData)
+                ? CallData2.toJSON(message.body?.callData)
                 : undefined);
         return obj;
     },
@@ -72,7 +101,7 @@ export const Packet = {
             object.body?.callStart !== null) {
             message.body = {
                 $case: 'callStart',
-                callStart: CallStart.fromPartial(object.body.callStart),
+                callStart: CallStart1.fromPartial(object.body.callStart),
             };
         }
         if (object.body?.$case === 'callData' &&
@@ -80,7 +109,7 @@ export const Packet = {
             object.body?.callData !== null) {
             message.body = {
                 $case: 'callData',
-                callData: CallData.fromPartial(object.body.callData),
+                callData: CallData2.fromPartial(object.body.callData),
             };
         }
         return message;
@@ -136,6 +165,34 @@ export const CallStart = {
         }
         return message;
     },
+    // encodeTransform encodes a source of message objects.
+    // Transform<CallStart, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [CallStart.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [CallStart.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, CallStart>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [CallStart.decode(p)];
+                }
+            }
+            else {
+                yield* [CallStart.decode(pkt)];
+            }
+        }
+    },
     fromJSON(object) {
         return {
             rpcService: isSet(object.rpcService) ? String(object.rpcService) : '',
@@ -214,6 +271,34 @@ export const CallData = {
         }
         return message;
     },
+    // encodeTransform encodes a source of message objects.
+    // Transform<CallData, Uint8Array>
+    async *encodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [CallData.encode(p).finish()];
+                }
+            }
+            else {
+                yield* [CallData.encode(pkt).finish()];
+            }
+        }
+    },
+    // decodeTransform decodes a source of encoded messages.
+    // Transform<Uint8Array, CallData>
+    async *decodeTransform(source) {
+        for await (const pkt of source) {
+            if (Array.isArray(pkt)) {
+                for (const p of pkt) {
+                    yield* [CallData.decode(p)];
+                }
+            }
+            else {
+                yield* [CallData.decode(pkt)];
+            }
+        }
+    },
     fromJSON(object) {
         return {
             data: isSet(object.data)

package/dist/srpc/server.d.ts

@@ -10,5 +10,6 @@ export declare class Server implements StreamHandler {
     startRpc(): ServerRPC;
     handleStream(stream: Stream): ServerRPC;
     handleDuplex(stream: Duplex<Uint8Array>): ServerRPC;
+    handlePacketDuplex(stream: Duplex<Uint8Array>): ServerRPC;
     handlePacketStream(stream: Duplex<Packet>): ServerRPC;
 }

package/dist/srpc/server.js

@@ -21,6 +21,13 @@ export class Server {
         pipe(stream, parseLengthPrefixTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), stream);
         return rpc;
     }
+    // handlePacketDuplex handles an incoming Uint8Array duplex.
+    // skips the packet length prefix transform.
+    handlePacketDuplex(stream) {
+        const rpc = this.startRpc();
+        pipe(stream, decodePacketSource, rpc, encodePacketSource, stream);
+        return rpc;
+    }
     // handlePacketStream handles an incoming Packet duplex.
     handlePacketStream(stream) {
         const rpc = this.startRpc();

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

@@ -1,7 +1,6 @@
-import type { Observable } from 'rxjs';
 export interface TsProtoRpc {
     request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
-    clientStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Promise<Uint8Array>;
-    serverStreamingRequest(service: string, method: string, data: Uint8Array): Observable<Uint8Array>;
-    bidirectionalStreamingRequest(service: string, method: string, data: Observable<Uint8Array>): Observable<Uint8Array>;
+    clientStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): Promise<Uint8Array>;
+    serverStreamingRequest(service: string, method: string, data: Uint8Array): AsyncIterable<Uint8Array>;
+    bidirectionalStreamingRequest(service: string, method: string, data: AsyncIterable<Uint8Array>): AsyncIterable<Uint8Array>;
 }

package/e2e/e2e.ts

@@ -1,18 +1,20 @@
 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 echoer = new EchoerServer()
-  mux.register(createHandler(EchoerDefinition, echoer))
   const server = new Server(mux)
+  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)
 }
 
@@ -21,7 +23,6 @@ runRPC()
     console.log('finished successfully')
   })
   .catch((err) => {
-    console.log('failed')
     console.error(err)
     process.exit(1)
   })

package/e2e/e2e_test.go

@@ -8,6 +8,7 @@ import (
 	"time"
 
 	"github.com/aperturerobotics/starpc/echo"
+	"github.com/aperturerobotics/starpc/rpcstream"
 	"github.com/aperturerobotics/starpc/srpc"
 	"github.com/libp2p/go-libp2p/p2p/muxer/mplex"
 	mp "github.com/libp2p/go-mplex"
@@ -17,8 +18,8 @@ import (
 // RunE2E runs an end to end test with a callback.
 func RunE2E(t *testing.T, cb func(client echo.SRPCEchoerClient) error) {
 	// construct the server
-	echoServer := &echo.EchoServer{}
 	mux := srpc.NewMux()
+	echoServer := echo.NewEchoServer(mux)
 	if err := echo.SRPCRegisterEchoer(mux, echoServer); err != nil {
 		t.Fatal(err.Error())
 	}
@@ -179,3 +180,25 @@ func TestE2E_BidiStream(t *testing.T) {
 		return strm.Close()
 	})
 }
+
+func TestE2E_RpcStream(t *testing.T) {
+	ctx := context.Background()
+	RunE2E(t, func(client echo.SRPCEchoerClient) error {
+		openStreamFn := rpcstream.NewRpcStreamOpenStream(func(ctx context.Context) (rpcstream.RpcStream, error) {
+			return client.RpcStream(ctx)
+		}, "test")
+		proxiedClient := srpc.NewClient(openStreamFn)
+		proxiedSvc := echo.NewSRPCEchoerClient(proxiedClient)
+
+		// run a RPC proxied over another RPC
+		resp, err := proxiedSvc.Echo(ctx, &echo.EchoMsg{Body: "hello world"})
+		if err != nil {
+			return err
+		}
+		if resp.GetBody() != "hello world" {
+			return errors.Errorf("response body incorrect: %q", resp.GetBody())
+		}
+
+		return nil
+	})
+}

package/echo/client-test.ts

@@ -1,6 +1,7 @@
 import { Client } from '../srpc/index.js'
 import { EchoerClientImpl, EchoMsg } from './echo.pb.js'
-import { Observable } from 'rxjs'
+import { pushable } from 'it-pushable'
+import { buildRpcStreamOpenStream } from '../rpcstream/rpcstream.js'
 
 export async function runClientTest(client: Client) {
   const demoServiceClient = new EchoerClientImpl(client)
@@ -12,10 +13,9 @@ export async function runClientTest(client: Client) {
   console.log('success: output', result.body)
 
   // observable for client requests
-  const clientRequestStream = new Observable<EchoMsg>((subscriber) => {
-    subscriber.next({ body: 'Hello world from streaming request.' })
-    subscriber.complete()
-  })
+  const clientRequestStream = pushable<EchoMsg>({ objectMode: true })
+  clientRequestStream.push({ body: 'Hello world from streaming request.' })
+  clientRequestStream.end()
 
   console.log('Calling EchoClientStream: client -> server...')
   result = await demoServiceClient.EchoClientStream(clientRequestStream)
@@ -25,17 +25,22 @@ export async function runClientTest(client: Client) {
   const serverStream = demoServiceClient.EchoServerStream({
     body: 'Hello world from server to client streaming request.',
   })
-  await new Promise<void>((resolve, reject) => {
-    serverStream.subscribe({
-      next(result) {
-        console.log('server: output', result.body)
-      },
-      complete() {
-        resolve()
-      },
-      error(err: Error) {
-        reject(err)
-      },
-    })
-  })
+  for await (const msg of serverStream) {
+    console.log('server: output', msg.body)
+  }
+}
+
+// runRpcStreamTest tests a RPCStream.
+export async function runRpcStreamTest(client: Client) {
+  console.log('Calling RpcStream to open a RPC stream client...')
+  const service = new EchoerClientImpl(client)
+  const openStreamFn = buildRpcStreamOpenStream(
+    'test',
+    service.RpcStream.bind(service)
+  )
+  const proxiedClient = new Client(openStreamFn)
+  const proxiedService = new EchoerClientImpl(proxiedClient)
+  console.log('Calling Echo via RPC stream...')
+  const resp = await proxiedService.Echo({ body: 'hello world via proxy' })
+  console.log('rpc stream test: succeeded: response: ' + resp.body)
 }