starpc 0.23.2 → 0.24.0

package/srpc/pushable.ts

@@ -1,5 +1,5 @@
 import { Pushable } from 'it-pushable'
-import { Source, Sink } from 'it-stream-types'
+import { Sink, Source } from 'it-stream-types'
 
 // writeToPushable writes the incoming server data to the pushable.
 export async function writeToPushable<T>(
@@ -23,14 +23,12 @@ export function buildPushableSink<T>(
   return async (source: Source<T>): Promise<void> => {
     try {
       if (Symbol.asyncIterator in source) {
-        // Handle AsyncIterable
-        for await (const pkt of source as AsyncIterable<any>) {
-          processPacket(pkt, target)
+        for await (const pkt of source) {
+          target.push(pkt)
         }
       } else {
-        // Handle Iterable
-        for (const pkt of source as Iterable<any>) {
-          processPacket(pkt, target)
+        for (const pkt of source) {
+          target.push(pkt)
         }
       }
       target.end()
@@ -39,13 +37,3 @@ export function buildPushableSink<T>(
     }
   }
 }
-
-function processPacket<T>(pkt: T, target: Pushable<T>): void {
-  if (Array.isArray(pkt)) {
-    for (const p of pkt) {
-      target.push(p)
-    }
-  } else {
-    target.push(pkt)
-  }
-}

package/srpc/server-rpc.ts

@@ -62,6 +62,7 @@ export class ServerRPC extends CommonRPC {
           await this.writeCallData(msg)
         }
         await this.writeCallData(undefined, true)
+        this.close()
       } catch (err) {
         this.close(err as Error)
       }

package/srpc/server.ts

@@ -1,19 +1,11 @@
-import { Duplex, Source } from 'it-stream-types'
 import { pipe } from 'it-pipe'
 
 import { LookupMethod } from './mux.js'
 import { ServerRPC } from './server-rpc.js'
-import { Packet } from './rpcproto.pb.js'
-import {
-  parseLengthPrefixTransform,
-  prependLengthPrefixTransform,
-  decodePacketSource,
-  encodePacketSource,
-} from './packet.js'
+import { decodePacketSource, encodePacketSource } from './packet.js'
 import { StreamHandler } from './conn.js'
-import { Stream } from './stream.js'
+import { PacketStream } from './stream.js'
 import { RpcStreamHandler } from '../rpcstream/rpcstream.js'
-import { combineUint8ArrayListTransform } from './array-list.js'
 
 // Server implements the SRPC server in TypeScript with a Mux.
 export class Server implements StreamHandler {
@@ -36,37 +28,13 @@ export class Server implements StreamHandler {
     return new ServerRPC(this.lookupMethod)
   }
 
-  // handleFragmentStream handles an incoming stream.
-  // assumes that stream does not maintain packet framing.
-  // uses length-prefixed packets for packet framing.
-  public handleFragmentStream(stream: Stream): ServerRPC {
-    const rpc = this.startRpc()
-    pipe(
-      stream,
-      parseLengthPrefixTransform(),
-      combineUint8ArrayListTransform(),
-      decodePacketSource,
-      rpc,
-      encodePacketSource,
-      prependLengthPrefixTransform(),
-      combineUint8ArrayListTransform(),
-      stream,
-    )
-    return rpc
-  }
-
   // handlePacketStream handles an incoming Uint8Array duplex.
   // the stream has one Uint8Array per packet w/o length prefix.
-  public handlePacketStream(stream: Stream): ServerRPC {
+  public handlePacketStream(stream: PacketStream): ServerRPC {
     const rpc = this.startRpc()
     pipe(stream, decodePacketSource, rpc, encodePacketSource, stream)
-    return rpc
-  }
-
-  // handlePacketDuplex handles an incoming Packet duplex.
-  public handlePacketDuplex(stream: Duplex<Source<Packet>>): ServerRPC {
-    const rpc = this.startRpc()
-    pipe(stream, rpc, stream)
+      .catch((err: Error) => rpc.close(err))
+      .then(() => rpc.close())
     return rpc
   }
 }

package/srpc/stream.ts

@@ -1,16 +1,41 @@
-import type { Packet } from './rpcproto.pb.js'
 import type { Duplex, Source } from 'it-stream-types'
+import { pipe } from 'it-pipe'
+import { Stream } from '@libp2p/interface'
+
+import type { Packet } from './rpcproto.pb.js'
+import { combineUint8ArrayListTransform } from './array-list.js'
+import {
+  parseLengthPrefixTransform,
+  prependLengthPrefixTransform,
+} from './packet.js'
 
 // PacketHandler handles incoming packets.
 export type PacketHandler = (packet: Packet) => Promise<void>
 
-// Stream is an open connection.
-// This stream type assumes that each Uint8Array corresponds to a Packet.
-export type Stream<T = Uint8Array> = Duplex<
-  AsyncGenerator<T>,
-  Source<T>,
+// PacketStream represents a stream of packets where each Uint8Array represents one packet.
+export type PacketStream = Duplex<
+  AsyncGenerator<Uint8Array>,
+  Source<Uint8Array>,
   Promise<void>
 >
 
 // OpenStreamFunc is a function to start a new RPC by opening a Stream.
-export type OpenStreamFunc = () => Promise<Stream>
+export type OpenStreamFunc = () => Promise<PacketStream>
+
+// streamToPacketStream converts a Stream into a PacketStream using length-prefix framing.
+//
+// The stream is closed when the source writing to the sink ends.
+export function streamToPacketStream(stream: Stream): PacketStream {
+  return {
+    source: pipe(
+      stream,
+      parseLengthPrefixTransform(),
+      combineUint8ArrayListTransform(),
+    ),
+    sink: async (source: Source<Uint8Array>): Promise<void> => {
+      await pipe(source, prependLengthPrefixTransform(), stream)
+        .catch((err) => stream.close(err))
+        .then(() => stream.close())
+    },
+  }
+}

package/srpc/websocket.ts

@@ -4,12 +4,12 @@ import { Direction } from '@libp2p/interface'
 import duplex from '@aptre/it-ws/duplex'
 import type WebSocket from '@aptre/it-ws/web-socket'
 
-import { Conn } from './conn.js'
+import { StreamConn } from './conn.js'
 import { Server } from './server.js'
 import { combineUint8ArrayListTransform } from './array-list.js'
 
 // WebSocketConn implements a connection with a WebSocket and optional Server.
-export class WebSocketConn extends Conn {
+export class WebSocketConn extends StreamConn {
   // socket is the web socket
   private socket: WebSocket
 

package/dist/srpc/conn-stream.d.ts

@@ -1,8 +0,0 @@
-import { Conn, ConnParams } from './conn.js';
-import { Server } from './server';
-import { Stream } from './stream.js';
-export declare class StreamConn extends Conn {
-    private channel;
-    constructor(duplex: Stream, server?: Server, connParams?: ConnParams);
-    getChannelStream(): Stream;
-}

package/dist/srpc/conn-stream.js

@@ -1,16 +0,0 @@
-import { pipe } from 'it-pipe';
-import { Conn } from './conn.js';
-// StreamConn wraps any Stream into a Conn.
-//
-// expects Uint8Array objects
-export class StreamConn extends Conn {
-    constructor(duplex, server, connParams) {
-        super(server, connParams);
-        this.channel = duplex;
-        pipe(this.channel, this, this.channel);
-    }
-    // getChannelStream returns the Duplex channel.
-    getChannelStream() {
-        return this.channel;
-    }
-}

package/srpc/conn-stream.ts

@@ -1,24 +0,0 @@
-import { pipe } from 'it-pipe'
-
-import { Conn, ConnParams } from './conn.js'
-import { Server } from './server'
-import { Stream } from './stream.js'
-
-// StreamConn wraps any Stream into a Conn.
-//
-// expects Uint8Array objects
-export class StreamConn extends Conn {
-  // channel is the iterable
-  private channel: Stream
-
-  constructor(duplex: Stream, server?: Server, connParams?: ConnParams) {
-    super(server, connParams)
-    this.channel = duplex
-    pipe(this.channel, this, this.channel)
-  }
-
-  // getChannelStream returns the Duplex channel.
-  public getChannelStream(): Stream {
-    return this.channel
-  }
-}