starpc 0.10.3 → 0.10.6

package/dist/rpcstream/rpcstream.d.ts

@@ -1,16 +1,16 @@
 import { RpcStreamPacket } from './rpcstream.pb.js';
 import { OpenStreamFunc, Stream } from '../srpc/stream.js';
 import { Pushable } from 'it-pushable';
-import { Duplex, Source, Sink } from 'it-stream-types';
+import { Source, Sink } from 'it-stream-types';
 import { Uint8ArrayList } from 'uint8arraylist';
 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 RpcStreamHandler = (stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>) => void;
+export declare type RpcStreamHandler = (stream: Stream) => 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<Uint8ArrayList>;
+    readonly source: Source<Uint8Array>;
     readonly sink: Sink<Uint8ArrayList | Uint8Array>;
     private readonly _packetStream;
     private readonly _packetSink;

package/dist/rpcstream/rpcstream.js

@@ -1,5 +1,4 @@
 import { pushable } from 'it-pushable';
-import { Uint8ArrayList } from 'uint8arraylist';
 // 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) {
@@ -142,7 +141,7 @@ export class RpcStream {
                 if (!body || body.$case !== 'data') {
                     continue;
                 }
-                yield* [new Uint8ArrayList(body.data)];
+                yield* [body.data];
             }
         })();
     }

package/dist/srpc/conn.d.ts

@@ -9,8 +9,9 @@ export interface ConnParams {
     direction?: Direction;
 }
 export interface StreamHandler {
-    handleStream(strm: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): void;
+    handleStream(strm: SRPCStream): void;
 }
+export declare function streamToSRPCStream(stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): SRPCStream;
 export declare class Conn implements Duplex<Uint8Array> {
     private muxer;
     private server?;

package/dist/srpc/conn.js

@@ -1,5 +1,14 @@
+import { pipe } from 'it-pipe';
 import { Mplex } from '@libp2p/mplex';
 import { Client } from './client.js';
+import { combineUint8ArrayListTransform } from './array-list.js';
+// streamToSRPCStream converts a Stream to a SRPCStream.
+export function streamToSRPCStream(stream) {
+    return {
+        source: pipe(stream, combineUint8ArrayListTransform()),
+        sink: stream.sink,
+    };
+}
 // Conn implements a generic connection with a two-way stream.
 // Implements the client by opening streams with the remote.
 // Implements the server by handling incoming streams.
@@ -36,7 +45,8 @@ export class Conn {
     }
     // openStream implements the client open stream function.
     async openStream() {
-        return this.muxer.newStream();
+        const stream = this.muxer.newStream();
+        return streamToSRPCStream(stream);
     }
     // buildOpenStreamFunc returns openStream bound to this conn.
     buildOpenStreamFunc() {
@@ -48,6 +58,6 @@ export class Conn {
         if (!server) {
             return strm.abort(new Error('server not implemented'));
         }
-        server.handleStream(strm);
+        server.handleStream(streamToSRPCStream(strm));
     }
 }

package/dist/srpc/server.d.ts

@@ -1,10 +1,9 @@
-import { Stream } from '@libp2p/interface-connection';
 import { Duplex } from 'it-stream-types';
-import { Uint8ArrayList } from 'uint8arraylist';
 import { LookupMethod } from './mux.js';
 import { ServerRPC } from './server-rpc.js';
 import { Packet } from './rpcproto.pb.js';
 import { StreamHandler } from './conn.js';
+import { Stream } from './stream.js';
 import { RpcStreamHandler } from '../rpcstream/rpcstream.js';
 export declare class Server implements StreamHandler {
     private lookupMethod;
@@ -12,8 +11,7 @@ export declare class Server implements StreamHandler {
     get rpcStreamHandler(): RpcStreamHandler;
     startRpc(): ServerRPC;
     handleStream(stream: Stream): ServerRPC;
-    handleDuplex(stream: Duplex<Uint8ArrayList | Uint8Array, Uint8ArrayList | Uint8Array>): ServerRPC;
-    handleUint8ArrayDuplex(stream: Duplex<Uint8Array>): ServerRPC;
+    handleDuplex(stream: Duplex<Uint8Array, Uint8Array>): ServerRPC;
     handlePacketDuplex(stream: Duplex<Uint8Array>): ServerRPC;
     handlePacketStream(stream: Duplex<Packet>): ServerRPC;
 }

package/dist/srpc/server.js

@@ -9,7 +9,7 @@ export class Server {
     }
     // rpcStreamHandler implements the RpcStreamHandler interface.
     get rpcStreamHandler() {
-        return this.handleDuplex.bind(this);
+        return this.handleStream.bind(this);
     }
     // startRpc starts a new server-side RPC.
     // the returned RPC handles incoming Packets.
@@ -22,11 +22,6 @@ export class Server {
     }
     // handleDuplex handles an incoming message duplex.
     handleDuplex(stream) {
-        const rpc = this.startRpc();
-        pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), stream);
-        return rpc;
-    }
-    handleUint8ArrayDuplex(stream) {
         const rpc = this.startRpc();
         pipe(stream, parseLengthPrefixTransform(), combineUint8ArrayListTransform(), decodePacketSource, rpc, encodePacketSource, prependLengthPrefixTransform(), combineUint8ArrayListTransform(), stream);
         return rpc;

package/dist/srpc/stream.d.ts

@@ -1,6 +1,5 @@
 import type { Packet } from './rpcproto.pb.js';
 import type { Duplex } from 'it-stream-types';
-import { Uint8ArrayList } from 'uint8arraylist';
 export declare type PacketHandler = (packet: Packet) => Promise<void>;
-export declare type Stream = Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>;
+export declare type Stream = Duplex<Uint8Array>;
 export declare type OpenStreamFunc = () => Promise<Stream>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.10.3",
+  "version": "0.10.6",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {

package/srpc/conn.ts

@@ -3,12 +3,14 @@ import type {
   StreamMuxer,
   StreamMuxerFactory,
 } from '@libp2p/interface-stream-muxer'
+import { pipe } from 'it-pipe'
 import type { Duplex } from 'it-stream-types'
 import { Mplex } from '@libp2p/mplex'
 import { Uint8ArrayList } from 'uint8arraylist'
 
 import type { OpenStreamFunc, Stream as SRPCStream } from './stream.js'
 import { Client } from './client.js'
+import { combineUint8ArrayListTransform } from './array-list.js'
 
 // ConnParams are parameters that can be passed to the Conn constructor.
 export interface ConnParams {
@@ -23,7 +25,15 @@ export interface ConnParams {
 // Implemented by Server.
 export interface StreamHandler {
   // handleStream handles an incoming stream.
-  handleStream(strm: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): void
+  handleStream(strm: SRPCStream): void
+}
+
+// streamToSRPCStream converts a Stream to a SRPCStream.
+export function streamToSRPCStream(stream: Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>): SRPCStream {
+  return {
+    source: pipe(stream, combineUint8ArrayListTransform()),
+    sink: stream.sink,
+  }
 }
 
 // Conn implements a generic connection with a two-way stream.
@@ -72,7 +82,8 @@ export class Conn implements Duplex<Uint8Array> {
 
   // openStream implements the client open stream function.
   public async openStream(): Promise<SRPCStream> {
-    return this.muxer.newStream()
+    const stream = this.muxer.newStream()
+    return streamToSRPCStream(stream)
   }
 
   // buildOpenStreamFunc returns openStream bound to this conn.
@@ -86,6 +97,6 @@ export class Conn implements Duplex<Uint8Array> {
     if (!server) {
       return strm.abort(new Error('server not implemented'))
     }
-    server.handleStream(strm)
+    server.handleStream(streamToSRPCStream(strm))
   }
 }

package/srpc/server.ts

@@ -1,4 +1,3 @@
-import { Stream } from '@libp2p/interface-connection'
 import { Duplex } from 'it-stream-types'
 import { pipe } from 'it-pipe'
 import { Uint8ArrayList } from 'uint8arraylist'
@@ -13,6 +12,7 @@ import {
   encodePacketSource,
 } from './packet.js'
 import { StreamHandler } from './conn.js'
+import { Stream } from './stream.js'
 import { RpcStreamHandler } from '../rpcstream/rpcstream.js'
 import { combineUint8ArrayListTransform } from './array-list.js'
 
@@ -27,7 +27,7 @@ export class Server implements StreamHandler {
 
   // rpcStreamHandler implements the RpcStreamHandler interface.
   public get rpcStreamHandler(): RpcStreamHandler {
-    return this.handleDuplex.bind(this)
+    return this.handleStream.bind(this)
   }
 
   // startRpc starts a new server-side RPC.
@@ -43,24 +43,7 @@ export class Server implements StreamHandler {
 
   // handleDuplex handles an incoming message duplex.
   public handleDuplex(
-    stream: Duplex<Uint8ArrayList | Uint8Array, Uint8ArrayList | Uint8Array>
-  ): ServerRPC {
-    const rpc = this.startRpc()
-    pipe(
-      stream,
-      parseLengthPrefixTransform(),
-      combineUint8ArrayListTransform(),
-      decodePacketSource,
-      rpc,
-      encodePacketSource,
-      prependLengthPrefixTransform(),
-      stream
-    )
-    return rpc
-  }
-
-  public handleUint8ArrayDuplex(
-    stream: Duplex<Uint8Array>
+    stream: Duplex<Uint8Array, Uint8Array>
   ): ServerRPC {
     const rpc = this.startRpc()
     pipe(

package/srpc/stream.ts

@@ -1,12 +1,11 @@
 import type { Packet } from './rpcproto.pb.js'
 import type { Duplex } from 'it-stream-types'
-import { Uint8ArrayList } from 'uint8arraylist'
 
 // PacketHandler handles incoming packets.
 export type PacketHandler = (packet: Packet) => Promise<void>
 
 // Stream is an open connection.
-export type Stream = Duplex<Uint8ArrayList, Uint8ArrayList | Uint8Array>
+export type Stream = Duplex<Uint8Array>
 
 // OpenStreamFunc is a function to start a new RPC by opening a Stream.
 export type OpenStreamFunc = () => Promise<Stream>