starpc 0.1.7 → 0.2.0

package/srpc/server-rpc.ts

@@ -0,0 +1,65 @@
+import type { Sink } from 'it-stream-types'
+
+import type { CallData, CallStart } from './rpcproto.js'
+import { CommonRPC } from './common-rpc.js'
+import { InvokeFn } from './handler.js'
+import { Mux } from './mux.js'
+
+// ServerRPC is an ongoing RPC from the server side.
+export class ServerRPC extends CommonRPC {
+  // mux is used to handle incoming rpcs.
+  private mux: Mux
+
+  constructor(mux: Mux) {
+    super()
+    this.mux = mux
+  }
+
+  // handleCallStart handles a CallStart cket.
+  public override async handleCallStart(packet: Partial<CallStart>) {
+    if (this.service || this.method) {
+      throw new Error('call start must be sent only once')
+    }
+    this.service = packet.rpcService
+    this.method = packet.rpcMethod
+    if (!this.service || !this.method) {
+      throw new Error('rpcService and rpcMethod cannot be empty')
+    }
+    const methodDef = await this.mux.lookupMethod(this.service, this.method)
+    if (!methodDef) {
+      throw new Error(`not found: ${this.service}/${this.method}`)
+    }
+    this.pushRpcData(packet.data, packet.dataIsZero)
+    this.invokeRPC(methodDef)
+  }
+
+  // handleCallData handles a CallData packet.
+  public override async handleCallData(packet: Partial<CallData>) {
+    if (!this.service || !this.method) {
+      throw new Error('call start must be sent before call data')
+    }
+    return super.handleCallData(packet)
+  }
+
+  // invokeRPC starts invoking the RPC handler.
+  private invokeRPC(invokeFn: InvokeFn) {
+    const dataSink = this._createDataSink()
+    invokeFn(this.rpcDataSource, dataSink).catch((err) => {
+      this.close(err)
+    })
+  }
+
+  // _createDataSink creates a sink for outgoing data packets.
+  private _createDataSink(): Sink<Uint8Array> {
+    return async (source) => {
+      try {
+        for await (const msg of source) {
+          await this.writeCallData(msg)
+        }
+        await this.writeCallData(undefined, true)
+      } catch (err) {
+        this.close(err as Error)
+      }
+    }
+  }
+}

package/srpc/server.ts

@@ -0,0 +1,56 @@
+import { Stream } from '@libp2p/interface-connection'
+import { Duplex } from 'it-stream-types'
+import { pipe } from 'it-pipe'
+
+import { Mux } from './mux.js'
+import { ServerRPC } from './server-rpc.js'
+import { Packet } from './rpcproto.js'
+import {
+  parseLengthPrefixTransform,
+  prependLengthPrefixTransform,
+  decodePacketSource,
+  encodePacketSource,
+} from './packet.js'
+import { StreamHandler } from './conn.js'
+
+// Server implements the SRPC server in TypeScript with a Mux.
+export class Server implements StreamHandler {
+  // mux is the mux used to handle requests.
+  private mux: Mux
+
+  constructor(mux: Mux) {
+    this.mux = mux
+  }
+
+  // startRpc starts a new server-side RPC.
+  // the returned RPC handles incoming Packets.
+  public startRpc(): ServerRPC {
+    return new ServerRPC(this.mux)
+  }
+
+  // handleStream handles an incoming Uint8Array message duplex.
+  // closes the stream when the rpc completes.
+  public handleStream(stream: Stream): Promise<void> {
+    return this.handleDuplex(stream)
+  }
+
+  // handleDuplex handles an incoming message duplex.
+  public async handleDuplex(stream: Duplex<Uint8Array>): Promise<void> {
+    const rpc = this.startRpc()
+    await pipe(
+      stream,
+      parseLengthPrefixTransform(),
+      decodePacketSource,
+      rpc,
+      encodePacketSource,
+      prependLengthPrefixTransform(),
+      stream
+    )
+  }
+
+  // handlePacketStream handles an incoming Packet duplex.
+  public async handlePacketStream(stream: Duplex<Packet>): Promise<void> {
+    const rpc = this.startRpc()
+    await pipe(stream, rpc, stream)
+  }
+}

package/srpc/websocket.ts

@@ -1,16 +1,18 @@
-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.
+import { Conn } from './conn.js'
+import { Server } from './server.js'
+
+// WebSocketConn implements a connection with a WebSocket and optional Server.
 export class WebSocketConn extends Conn {
   // socket is the web socket
   private socket: WebSocket
 
-  constructor(socket: WebSocket) {
-    super({
+  constructor(socket: WebSocket, server?: Server) {
+    super(server, {
       muxerFactory: new Mplex(),
     })
     this.socket = socket