starpc 0.1.7 → 0.2.0

package/e2e/e2e.ts

@@ -0,0 +1,27 @@
+import { pipe } from 'it-pipe'
+import { createHandler, createMux, Server, Client, Conn } from '../srpc'
+import { EchoerDefinition, EchoerServer, runClientTest } from '../echo'
+
+async function runRPC() {
+  const mux = createMux()
+  const echoer = new EchoerServer()
+  mux.register(createHandler(EchoerDefinition, echoer))
+  const server = new Server(mux)
+
+  const clientConn = new Conn()
+  const serverConn = new Conn(server)
+  pipe(clientConn, serverConn, clientConn)
+  const client = new Client(clientConn.buildOpenStreamFunc())
+
+  await runClientTest(client)
+}
+
+runRPC()
+  .then(() => {
+    console.log('finished successfully')
+  })
+  .catch((err) => {
+    console.log('failed')
+    console.error(err)
+    process.exit(1)
+  })

package/echo/client-test.ts

@@ -0,0 +1,41 @@
+import { Client } from '../srpc/index.js'
+import { EchoerClientImpl, EchoMsg } from './echo.js'
+import { Observable } from 'rxjs'
+
+export async function runClientTest(client: Client) {
+  const demoServiceClient = new EchoerClientImpl(client)
+
+  console.log('Calling Echo: unary call...')
+  let result = await demoServiceClient.Echo({
+    body: 'Hello world!',
+  })
+  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()
+  })
+
+  console.log('Calling EchoClientStream: client -> server...')
+  result = await demoServiceClient.EchoClientStream(clientRequestStream)
+  console.log('success: output', result.body)
+
+  console.log('Calling EchoServerStream: server -> 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)
+      },
+    })
+  })
+}

package/echo/echo.ts

@@ -125,6 +125,51 @@ export class EchoerClientImpl implements Echoer {
   }
 }
 
+/** Echoer service returns the given message. */
+export type EchoerDefinition = typeof EchoerDefinition
+export const EchoerDefinition = {
+  name: 'Echoer',
+  fullName: 'echo.Echoer',
+  methods: {
+    /** Echo returns the given message. */
+    echo: {
+      name: 'Echo',
+      requestType: EchoMsg,
+      requestStream: false,
+      responseType: EchoMsg,
+      responseStream: false,
+      options: {},
+    },
+    /** EchoServerStream is an example of a server -> client one-way stream. */
+    echoServerStream: {
+      name: 'EchoServerStream',
+      requestType: EchoMsg,
+      requestStream: false,
+      responseType: EchoMsg,
+      responseStream: true,
+      options: {},
+    },
+    /** EchoClientStream is an example of client->server one-way stream. */
+    echoClientStream: {
+      name: 'EchoClientStream',
+      requestType: EchoMsg,
+      requestStream: true,
+      responseType: EchoMsg,
+      responseStream: false,
+      options: {},
+    },
+    /** EchoBidiStream is an example of a two-way stream. */
+    echoBidiStream: {
+      name: 'EchoBidiStream',
+      requestType: EchoMsg,
+      requestStream: true,
+      responseType: EchoMsg,
+      responseStream: true,
+      options: {},
+    },
+  },
+} as const
+
 interface Rpc {
   request(
     service: string,

package/echo/index.ts

@@ -0,0 +1,3 @@
+export * from './echo.js'
+export * from './server.js'
+export { runClientTest } from './client-test.js'

package/echo/server.ts

@@ -0,0 +1,57 @@
+import { Observable, from as observableFrom } from 'rxjs'
+import { Echoer, EchoMsg } from './echo'
+import { pushable, Pushable } from 'it-pushable'
+
+// EchoServer implements the Echoer server.
+export class EchoerServer implements Echoer {
+  public async Echo(request: EchoMsg): Promise<EchoMsg> {
+    return request
+  }
+
+  public EchoServerStream(request: EchoMsg): Observable<EchoMsg> {
+    // send 5 responses, with a 200ms delay for each
+    return observableFrom(
+      (async function* response(): AsyncIterable<EchoMsg> {
+        for (let i = 0; i < 5; i++) {
+          yield request
+          await new Promise((resolve) => setTimeout(resolve, 200))
+        }
+      })()
+    )
+  }
+
+  public EchoClientStream(request: Observable<EchoMsg>): Promise<EchoMsg> {
+    return new Promise<EchoMsg>((resolve, reject) => {
+      request.subscribe({
+        next(msg) {
+          resolve(msg)
+        },
+        error(err: any) {
+          reject(err)
+        },
+        complete() {
+          reject(new Error('none received'))
+        },
+      })
+    })
+  }
+
+  public EchoBidiStream(request: Observable<EchoMsg>): Observable<EchoMsg> {
+    // build result observable
+    const pushResponse: Pushable<EchoMsg> = pushable({ objectMode: true })
+    const response = observableFrom(pushResponse)
+    pushResponse.push({ body: 'hello from server' })
+    request.subscribe({
+      next(msg) {
+        pushResponse.push(msg)
+      },
+      error(err) {
+        pushResponse.throw(err)
+      },
+      complete() {
+        pushResponse.end()
+      },
+    })
+    return response
+  }
+}

package/integration/integration.bash

@@ -3,7 +3,7 @@ set -eo pipefail
 
 echo "Compiling ts..."
 # ../node_modules/.bin/tsc --out integration.js --project tsconfig.json
-../node_modules/.bin/esbuild integration.ts --bundle --platform=node --outfile=integration.js 
+../node_modules/.bin/esbuild integration.ts --bundle --platform=node --outfile=integration.js
 
 echo "Compiling go..."
 go build -o integration -v ./

package/integration/integration.ts

@@ -1,7 +1,6 @@
-import { WebSocketConn } from '../dist/srpc/websocket.js'
-import { EchoerClientImpl, EchoMsg } from '../dist/echo/echo.js'
+import { WebSocketConn } from '../srpc'
+import { runClientTest } from '../echo'
 import WebSocket from 'isomorphic-ws'
-import { Observable } from 'rxjs'
 
 async function runRPC() {
   const addr = 'ws://localhost:5000/demo'
@@ -9,46 +8,15 @@ async function runRPC() {
   const ws = new WebSocket(addr)
   const channel = new WebSocketConn(ws)
   const client = channel.buildClient()
-  const demoServiceClient = new EchoerClientImpl(client)
 
-  console.log('Calling Echo: unary call...')
-  let result = await demoServiceClient.Echo({
-    body: "Hello world!"
-  })
-  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()
-  })
-
-  console.log('Calling EchoClientStream: client -> server...')
-  result = await demoServiceClient.EchoClientStream(clientRequestStream)
-  console.log('success: output', result.body)
+  await runClientTest(client)
+}
 
-  console.log('Calling EchoServerStream: server -> client...')
-  const serverStream = demoServiceClient.EchoServerStream({
-    body: 'Hello world from server to client streaming request.',
+runRPC()
+  .then(() => {
+    process.exit(0)
   })
-  await new Promise<void>((resolve, reject) => {
-    serverStream.subscribe({
-      next(result) {
-        console.log('server: output', result.body)
-      },
-      complete() {
-        resolve()
-      },
-      error(err: Error) {
-        reject(err)
-      },
-    })
+  .catch((err) => {
+    console.error(err)
+    process.exit(1)
   })
-}
-
-runRPC().then(() => {
-  process.exit(0)
-}).catch((err) => {
-  console.error(err)
-  process.exit(1)
-})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "starpc",
-  "version": "0.1.7",
+  "version": "0.2.0",
   "description": "Streaming protobuf RPC service protocol over any two-way channel.",
   "license": "MIT",
   "author": {
@@ -15,7 +15,7 @@
       "url": "http://github.com/paralin"
     }
   ],
-  "main": "dist/srpc/index.js",
+  "main": "./dist/srpc/index.js",
   "types": "./dist/srpc/index.d.ts",
   "files": [
     "!**/*.tsbuildinfo",
@@ -34,13 +34,16 @@
     "url": "git@github.com:aperturerobotics/starpc.git"
   },
   "scripts": {
-    "build": "tsc --project tsconfig.build.json --outDir ./dist/",
+    "build": "rimraf ./dist && tsc --project tsconfig.build.json --outDir ./dist/",
     "check": "tsc",
+    "deps": "depcheck",
     "codegen": "npm run gen",
     "ci": "npm run build && npm run lint:js && npm run lint:go",
-    "format": "prettier --write './srpc/**/(*.ts|*.tsx|*.js|*.html|*.css)'",
+    "format": "prettier --write './{srpc,echo,e2e,integration}/**/(*.ts|*.tsx|*.html|*.css)'",
     "gen": "make genproto",
-    "test": "make test && npm run check",
+    "test": "npm run test:js && npm run test:go",
+    "test:go": "make test",
+    "test:js": "npm run build && cd e2e && esbuild e2e.ts --sourcemap --outfile=e2e.js --bundle --platform=node && node ./e2e.js",
     "test:integration": "make integration",
     "integration": "npm run test:integration",
     "lint": "npm run lint:go && npm run lint:js",
@@ -54,23 +57,21 @@
     "singleQuote": true
   },
   "devDependencies": {
-    "@types/varint": "^6.0.0",
     "@typescript-eslint/eslint-plugin": "^5.27.1",
     "@typescript-eslint/parser": "^5.27.1",
-    "esbuild": "^0.14.44",
-    "eslint": "^8.17.0",
+    "depcheck": "^1.4.3",
+    "esbuild": "^0.14.46",
+    "eslint": "^8.18.0",
     "eslint-config-prettier": "^8.5.0",
-    "eslint-config-standard-with-typescript": "^21.0.1",
-    "eslint-plugin-react-hooks": "^4.6.0",
-    "husky": "^8.0.1",
-    "prettier": "^2.7.0",
+    "prettier": "^2.7.1",
+    "rimraf": "^3.0.2",
     "ts-proto": "^1.115.4",
-    "typescript": "^4.7.3"
+    "typescript": "^4.7.4"
   },
   "dependencies": {
-    "@libp2p/components": "^1.0.0",
-    "@libp2p/interface-connection": "^1.0.1",
-    "@libp2p/mplex": "^2.0.0",
+    "@libp2p/interface-connection": "^2.0.0",
+    "@libp2p/interface-stream-muxer": "^1.0.2",
+    "@libp2p/mplex": "^3.0.0",
     "event-iterator": "^2.0.0",
     "isomorphic-ws": "^4.0.1",
     "it-length-prefixed": "^7.0.1",
@@ -78,10 +79,10 @@
     "it-pushable": "^3.0.0",
     "it-stream-types": "^1.0.4",
     "it-ws": "^5.0.2",
+    "long": "^5.2.0",
     "patch-package": "^6.4.7",
     "protobufjs": "^6.11.3",
     "rxjs": "^7.5.5",
-    "ts-poet": "^4.13.0",
     "ws": "^8.8.0"
   }
 }

package/srpc/broadcast-channel.ts

@@ -1,7 +1,8 @@
 import type { Duplex, Sink } from 'it-stream-types'
-import { Conn } from './conn'
+import { Conn, ConnParams } from './conn'
 import { EventIterator } from 'event-iterator'
 import { pipe } from 'it-pipe'
+import { Server } from './server'
 
 // BroadcastChannelIterable is a AsyncIterable wrapper for BroadcastChannel.
 export class BroadcastChannelIterable<T> implements Duplex<T> {
@@ -59,8 +60,12 @@ export class BroadcastChannelConn extends Conn {
   // channel is the broadcast channel iterable
   private channel: BroadcastChannelIterable<Uint8Array>
 
-  constructor(channel: BroadcastChannel) {
-    super()
+  constructor(
+    channel: BroadcastChannel,
+    server?: Server,
+    connParams?: ConnParams
+  ) {
+    super(server, connParams)
     this.channel = new BroadcastChannelIterable<Uint8Array>(channel)
     pipe(this, this.channel, this)
   }

package/srpc/client-rpc.go

@@ -108,8 +108,6 @@ func (r *ClientRPC) HandlePacket(msg *Packet) error {
 		return r.HandleCallStart(b.CallStart)
 	case *Packet_CallData:
 		return r.HandleCallData(b.CallData)
-	case *Packet_CallStartResp:
-		return r.HandleCallStartResp(b.CallStartResp)
 	default:
 		return nil
 	}
@@ -127,7 +125,7 @@ func (r *ClientRPC) HandleCallData(pkt *CallData) error {
 		return ErrCompleted
 	}
 
-	if data := pkt.GetData(); len(data) != 0 {
+	if data := pkt.GetData(); len(data) != 0 || pkt.GetDataIsZero() {
 		select {
 		case <-r.ctx.Done():
 			return context.Canceled
@@ -149,12 +147,6 @@ func (r *ClientRPC) HandleCallData(pkt *CallData) error {
 	return nil
 }
 
-// HandleCallStartResp handles the CallStartResp packet.
-func (r *ClientRPC) HandleCallStartResp(resp *CallStartResp) error {
-	// client-side calls not supported
-	return errors.Wrap(ErrUnrecognizedPacket, "call start resp packet unexpected")
-}
-
 // Close releases any resources held by the ClientRPC.
 // not concurrency safe with HandlePacket.
 func (r *ClientRPC) Close() {

package/srpc/client-rpc.ts

@@ -1,90 +1,25 @@
-import type { CallData, CallStart, CallStartResp } from './rpcproto'
-import { Packet } from './rpcproto'
-import type { Sink } from 'it-stream-types'
-import { pushable } from 'it-pushable'
-
-// DataCb is a callback to handle incoming RPC messages.
-// Returns true if more data is expected, false otherwise.
-// If returns undefined, assumes more data is expected.
-export type DataCb = (data: Uint8Array) => Promise<boolean | void>
+import type { CallStart } from './rpcproto.js'
+import { CommonRPC } from './common-rpc.js'
 
 // ClientRPC is an ongoing RPC from the client side.
-export class ClientRPC {
-  // sink is the data sink for incoming messages.
-  public sink: Sink<Packet>
-  // source is the packet source for outgoing Packets.
-  public source: AsyncIterable<Packet>
-  // _source is used to write to the source.
-  private readonly _source: {
-    push: (val: Packet) => void
-    end: (err?: Error) => void
-  }
-  // service is the rpc service
-  private service: string
-  // method is the rpc method
-  private method: string
-  // dataCb is called with any incoming data.
-  private dataCb?: DataCb
-  // started is resolved when the request starts.
-  private started: Promise<void>
-  // onStarted is called by the message handler when the request starts.
-  private onStarted?: (err?: Error) => void
-  // complete is resolved when the request completes.
-  // rejected with an error if the call encountered any error.
-  private complete: Promise<void>
-  // onComplete is called by the message handler when the call completes.
-  private onComplete?: (err?: Error) => void
-  // closed indicates close has been called
-  private closed: boolean
-
-  constructor(service: string, method: string, dataCb: DataCb | null) {
-    this.closed = false
-    this.sink = this._createSink()
-    const sourcev = this._createSource()
-    this.source = sourcev
-    this._source = sourcev
+export class ClientRPC extends CommonRPC {
+  constructor(service: string, method: string) {
+    super()
     this.service = service
     this.method = method
-    if (dataCb) {
-      this.dataCb = dataCb
-    }
-    this.started = new Promise<void>((resolveStarted, rejectStarted) => {
-      this.onStarted = (err?: Error) => {
-        if (err) {
-          rejectStarted(err)
-        } else {
-          resolveStarted()
-        }
-      }
-    })
-    this.complete = new Promise<void>((resolveComplete, rejectComplete) => {
-      this.onComplete = (err?: Error) => {
-        this.closed = true
-        if (err) {
-          rejectComplete(err)
-        } else {
-          resolveComplete()
-        }
-      }
-    })
-  }
-
-  // waitStarted returns the started promise.
-  public waitStarted(): Promise<void> {
-    return this.started
-  }
-
-  // waitComplete returns the complete promise.
-  public waitComplete(): Promise<void> {
-    return this.complete
   }
 
   // writeCallStart writes the call start packet.
+  // if data === undefined and data.length === 0 sends empty data packet.
   public async writeCallStart(data?: Uint8Array) {
+    if (!this.service || !this.method) {
+      throw new Error('service and method must be set')
+    }
     const callStart: CallStart = {
       rpcService: this.service,
       rpcMethod: this.method,
       data: data || new Uint8Array(0),
+      dataIsZero: !!data && data.length === 0,
     }
     await this.writePacket({
       body: {
@@ -94,110 +29,11 @@ export class ClientRPC {
     })
   }
 
-  // writeCallData writes the call data packet.
-  public async writeCallData(
-    data: Uint8Array,
-    complete?: boolean,
-    error?: string
-  ) {
-    const callData: CallData = {
-      data,
-      complete: complete || false,
-      error: error || '',
-    }
-    await this.writePacket({
-      body: {
-        $case: 'callData',
-        callData,
-      },
-    })
-  }
-
-  // writePacket writes a packet to the stream.
-  private async writePacket(packet: Packet) {
-    this._source.push(packet)
-  }
-
-  // handleMessage handles an incoming encoded Packet.
-  //
-  // note: may throw an error if the message was unexpected or invalid.
-  public async handleMessage(message: Uint8Array) {
-    return this.handlePacket(Packet.decode(message))
-  }
-
-  // handlePacket handles an incoming packet.
-  public async handlePacket(packet: Partial<Packet>) {
-    switch (packet?.body?.$case) {
-      case 'callStart':
-        return this.handleCallStart(packet.body.callStart)
-      case 'callStartResp':
-        return this.handleCallStartResp(packet.body.callStartResp)
-      case 'callData':
-        return this.handleCallData(packet.body.callData)
-    }
-  }
-
   // handleCallStart handles a CallStart packet.
-  public async handleCallStart(packet: Partial<CallStart>) {
+  public override async handleCallStart(packet: Partial<CallStart>) {
     // we do not implement server -> client RPCs.
     throw new Error(
       `unexpected server to client rpc: ${packet.rpcService}/${packet.rpcMethod}`
     )
   }
-
-  // handleCallStartResp handles a CallStartResp packet.
-  public async handleCallStartResp(packet: Partial<CallStartResp>) {
-    if (packet.error && packet.error.length) {
-      const err = new Error(packet.error)
-      this.onStarted!(err)
-      this.onComplete!(err)
-    }
-  }
-
-  // handleCallData handles a CallData packet.
-  public async handleCallData(packet: Partial<CallData>) {
-    const data = packet.data
-    if (this.dataCb && data?.length) {
-      await this.dataCb(data)
-    }
-    if (packet.error && packet.error.length) {
-      this.onComplete!(new Error(packet.error))
-    } else if (packet.complete) {
-      this.onComplete!()
-    }
-  }
-
-  // close closes the active call if not already completed.
-  public async close(err?: Error) {
-    if (!this.closed) {
-      await this.writeCallData(new Uint8Array(0), true, err ? err.message : '')
-    }
-    if (!err) {
-      err = new Error('call closed')
-    }
-    this.onComplete!(err)
-  }
-
-  // _createSink initializes the sink field.
-  private _createSink(): Sink<Packet> {
-    return async (source) => {
-      try {
-        for await (const msg of source) {
-          await this.handlePacket(msg)
-        }
-      } catch (err) {
-        this.close(err as Error)
-      }
-    }
-  }
-
-  // _createSource initializes the source field.
-  private _createSource() {
-    return pushable<Packet>({
-      objectMode: true,
-      onEnd: (err?: Error): void => {
-        this.onComplete!(err)
-      },
-    })
-  }
 }