bare-rpc 0.1.3 → 0.2.0

package/index.d.ts

@@ -4,7 +4,7 @@ import {
   ReadableOptions,
   Writable,
   WritableOptions,
-  PassThrough
+  Duplex
 } from 'bare-stream'
 
 declare const constants: {
@@ -24,11 +24,12 @@ declare const constants: {
 }
 
 interface RPCIncomingRequest {
-  rpc: RPC
-  id: number
-  command: string
-  data: Buffer
-  sent: boolean
+  readonly rpc: RPC
+  readonly id: number
+  readonly command: number
+  readonly data: Buffer
+  readonly sent: boolean
+  readonly received: boolean
 
   reply(data: Buffer | string, encoding?: BufferEncoding): void
 
@@ -37,10 +38,16 @@ interface RPCIncomingRequest {
 }
 
 declare class RPCIncomingRequest {
-  constructor(rpc: RPC, id: number, command: string, data: Buffer)
+  constructor(rpc: RPC, id: number, command: number, data: Buffer)
 }
 
 interface RPCOutgoingRequest {
+  readonly rpc: RPC
+  readonly id: number
+  readonly command: number
+  readonly sent: boolean
+  readonly received: boolean
+
   send(data: Buffer | string, encoding?: BufferEncoding): void
 
   reply(encoding?: BufferEncoding): Promise<Buffer>
@@ -50,7 +57,7 @@ interface RPCOutgoingRequest {
 }
 
 declare class RPCOutgoingRequest {
-  constructor(rpc: RPC, command: string)
+  constructor(rpc: RPC, command: number)
 }
 
 declare class RPCIncomingStream extends Readable {
@@ -72,11 +79,11 @@ declare class RPCOutgoingStream extends Writable {
 }
 
 interface RPC {
-  request(command: string): RPCOutgoingRequest
+  request(command: number): RPCOutgoingRequest
 }
 
 declare class RPC {
-  constructor(stream: PassThrough, onrequest: (req: RPCIncomingRequest) => void)
+  constructor(stream: Duplex, onrequest: (req: RPCIncomingRequest) => void)
 }
 
 export = RPC

package/index.js

@@ -7,8 +7,9 @@ const IncomingRequest = require('./lib/incoming-request')
 const IncomingStream = require('./lib/incoming-stream')
 const OutgoingRequest = require('./lib/outgoing-request')
 const OutgoingStream = require('./lib/outgoing-stream')
+const CommandRouter = require('./lib/command-router')
 
-module.exports = class RPC {
+module.exports = exports = class RPC {
   constructor(stream, onrequest) {
     this._stream = stream
 
@@ -23,14 +24,20 @@ module.exports = class RPC {
 
     this._buffer = null
 
-    this._onrequest = onrequest.bind(this)
+    if (typeof onrequest === 'function') {
+      onrequest = onrequest.bind(this)
+    } else {
+      onrequest = onrequest._onrequest.bind(onrequest)
+    }
+
+    this._onrequest = onrequest
     this._ondata = this._ondata.bind(this)
 
     this._stream.on('data', this._ondata)
   }
 
   request(command) {
-    return new OutgoingRequest(++this._id, this, command)
+    return new OutgoingRequest(this, ++this._id, command)
   }
 
   _sendMessage(message) {
@@ -357,3 +364,5 @@ module.exports = class RPC {
     stream.destroy(message.error)
   }
 }
+
+exports.CommandRouter = CommandRouter

package/lib/command-router.js

@@ -0,0 +1,49 @@
+const c = require('compact-encoding')
+
+module.exports = class RPCCommandRouter {
+  constructor(opts = {}) {
+    const { valueEncoding = c.raw } = opts
+
+    this._responders = new Map()
+    this._defaultValueEncoding = valueEncoding
+  }
+
+  respond(command, opts = {}, onrequest) {
+    if (typeof opts === 'function') {
+      onrequest = opts
+      opts = {}
+    }
+
+    const {
+      valueEncoding = this._defaultValueEncoding,
+      requestEncoding = valueEncoding,
+      responseEncoding = valueEncoding
+    } = opts
+
+    this._responders.set(command, {
+      onrequest,
+      requestEncoding,
+      responseEncoding
+    })
+  }
+
+  async _onrequest(req) {
+    const responder = this._responders.get(req.command)
+
+    if (responder === undefined) return
+
+    const { onrequest, requestEncoding, responseEncoding } = responder
+
+    let data = req.data
+
+    if (requestEncoding) data = c.decode(requestEncoding, data)
+
+    data = await onrequest(req, req.data)
+
+    if (req.sent) return
+
+    if (responseEncoding) data = c.encode(responseEncoding, data)
+
+    req.reply(data)
+  }
+}

package/lib/errors.js

@@ -19,4 +19,8 @@ module.exports = class RPCError extends Error {
   static ALREADY_SENT(msg) {
     return new RPCError(msg, 'ALREADY_SENT', RPCError.ALREADY_SENT)
   }
+
+  static ALREADY_RECEIVED(msg) {
+    return new RPCError(msg, 'ALREADY_RECEIVED', RPCError.ALREADY_RECEIVED)
+  }
 }

package/lib/incoming-request.js

@@ -8,13 +8,17 @@ module.exports = class RPCIncomingRequest {
     this.command = command
     this.data = data
     this.sent = false
+    this.received = false
 
     this._requestStream = null
     this._responseStream = null
   }
 
   reply(data, encoding) {
-    if (this.sent) throw errors.ALREADY_SENT('Response has already been sent')
+    if (this.sent) {
+      throw errors.ALREADY_SENT('Response has already been sent')
+    }
+
     this.sent = true
 
     this.rpc._sendResponse(
@@ -24,15 +28,25 @@ module.exports = class RPCIncomingRequest {
   }
 
   createResponseStream(opts = {}) {
-    if (this._responseStream === null)
-      this.rpc._createResponseStream(this, true, opts)
+    if (this.sent) {
+      throw errors.ALREADY_SENT('Response has already been sent')
+    }
+
+    this.sent = true
+
+    this.rpc._createResponseStream(this, true, opts)
 
     return this._responseStream
   }
 
   createRequestStream(opts = {}) {
-    if (this._requestStream === null)
-      this.rpc._createRequestStream(this, false, opts)
+    if (this.received) {
+      throw errors.ALREADY_RECEIVED('Request has already been received')
+    }
+
+    this.received = true
+
+    this.rpc._createRequestStream(this, false, opts)
 
     return this._requestStream
   }

package/lib/messages.js

@@ -4,17 +4,17 @@ const errors = require('./errors')
 
 const request = {
   preencode(state, m) {
-    c.utf8.preencode(state, m.command)
+    c.uint.preencode(state, m.command)
     c.uint.preencode(state, m.stream)
     if (m.stream === 0) c.buffer.preencode(state, m.data)
   },
   encode(state, m) {
-    c.utf8.encode(state, m.command)
+    c.uint.encode(state, m.command)
     c.uint.encode(state, m.stream)
     if (m.stream === 0) c.buffer.encode(state, m.data)
   },
   decode(state, id) {
-    const command = c.utf8.decode(state)
+    const command = c.uint.decode(state)
     const stream = c.uint.decode(state)
     const data = stream === 0 ? c.buffer.decode(state) : null
 

package/lib/outgoing-request.js

@@ -2,11 +2,12 @@ const b4a = require('b4a')
 const errors = require('./errors')
 
 module.exports = class RPCOutgoingRequest {
-  constructor(id, rpc, command) {
-    this.id = id
+  constructor(rpc, id, command) {
     this.rpc = rpc
+    this.id = id
     this.command = command
     this.sent = false
+    this.received = false
 
     this._promise = new Promise((resolve, reject) => {
       this._resolve = resolve
@@ -18,7 +19,10 @@ module.exports = class RPCOutgoingRequest {
   }
 
   send(data, encoding) {
-    if (this.sent) throw errors.ALREADY_SENT('Request has already been sent')
+    if (this.sent) {
+      throw errors.ALREADY_SENT('Request has already been sent')
+    }
+
     this.sent = true
 
     this.rpc._sendRequest(
@@ -28,24 +32,38 @@ module.exports = class RPCOutgoingRequest {
   }
 
   reply(encoding) {
+    if (this.received) {
+      throw errors.ALREADY_RECEIVED('Response is already being received')
+    }
+
+    this.received = true
+
     return encoding && encoding !== 'buffer'
       ? this._promise.then((data) => b4a.toString(data, encoding))
       : this._promise
   }
 
   createRequestStream(opts = {}) {
-    if (this._requestStream === null) {
-      this.rpc._createRequestStream(this, true, opts)
+    if (this.sent) {
+      throw errors.ALREADY_SENT('Request has already been sent')
     }
 
+    this.sent = true
+
+    this.rpc._createRequestStream(this, true, opts)
+
     return this._requestStream
   }
 
   createResponseStream(opts = {}) {
-    if (this._requestStream === null) {
-      this.rpc._createResponseStream(this, false, opts)
+    if (this.received) {
+      throw errors.ALREADY_RECEIVED('Response has already been received')
     }
 
+    this.received = true
+
+    this.rpc._createResponseStream(this, false, opts)
+
     return this._responseStream
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bare-rpc",
-  "version": "0.1.3",
+  "version": "0.2.0",
   "description": "librpc ABI compatible RPC for Bare",
   "exports": {
     ".": {