bare-rpc 0.1.4 → 0.2.1

package/index.d.ts

@@ -4,7 +4,7 @@ import {
   ReadableOptions,
   Writable,
   WritableOptions,
-  PassThrough
+  Duplex
 } from 'bare-stream'
 
 declare const constants: {
@@ -26,9 +26,10 @@ declare const constants: {
 interface RPCIncomingRequest {
   readonly rpc: RPC
   readonly id: number
-  readonly command: string
+  readonly command: number
   readonly data: Buffer
   readonly sent: boolean
+  readonly received: boolean
 
   reply(data: Buffer | string, encoding?: BufferEncoding): void
 
@@ -37,14 +38,15 @@ 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: string
+  readonly command: number
   readonly sent: boolean
+  readonly received: boolean
 
   send(data: Buffer | string, encoding?: BufferEncoding): void
 
@@ -55,7 +57,7 @@ interface RPCOutgoingRequest {
 }
 
 declare class RPCOutgoingRequest {
-  constructor(rpc: RPC, command: string)
+  constructor(rpc: RPC, command: number)
 }
 
 declare class RPCIncomingStream extends Readable {
@@ -77,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
 
@@ -21,9 +22,17 @@ module.exports = class RPC {
     this._pendingRequests = new Set()
     this._pendingResponses = new Set()
 
-    this._buffer = null
+    this._buffer = []
+    this._buffered = 0
+    this._frame = -1
 
-    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)
@@ -122,58 +131,84 @@ module.exports = class RPC {
   }
 
   _ondata(data) {
-    if (this._buffer === null) this._buffer = data
-    else this._buffer = b4a.concat([this._buffer, data])
+    this._buffer.push(data)
+    this._buffered += data.byteLength
+
+    if (this._frame === -1) {
+      this._onbeforeframe()
+    } else {
+      this._onafterframe()
+    }
+  }
 
-    while (this._buffer !== null) {
-      const state = { start: 0, end: this._buffer.length, buffer: this._buffer }
+  _onbeforeframe() {
+    if (this._buffered < 4) return
 
-      let message
-      try {
-        message = m.message.decode(state)
-      } catch (err) {
-        safetyCatch(err)
+    const buffer =
+      this._buffer.length === 1 ? this._buffer[0] : b4a.concat(this._buffer)
 
-        return this._stream.destroy(err)
-      }
+    this._buffer = [buffer]
+    this._frame = 4 + c.uint32.decode(c.state(0, 4, buffer))
 
-      if (message === null) return
-
-      switch (message.type) {
-        case t.REQUEST: {
-          const request = new IncomingRequest(
-            this,
-            message.id,
-            message.command,
-            message.data
-          )
-
-          try {
-            this._onrequest(request)
-          } catch (err) {
-            safetyCatch(err)
-
-            this._sendError(request, err)
-          }
-          break
-        }
-        case t.RESPONSE:
-          try {
-            this._onresponse(message)
-          } catch (err) {
-            safetyCatch(err)
-          }
-          break
-        case t.STREAM:
-          try {
-            this._onstream(message)
-          } catch (err) {
-            safetyCatch(err)
-          }
-      }
+    this._onafterframe()
+  }
+
+  _onafterframe() {
+    while (this._frame >= 0 && this._frame <= this._buffered) {
+      const buffer =
+        this._buffer.length === 1 ? this._buffer[0] : b4a.concat(this._buffer)
 
-      this._buffer =
-        state.start === state.end ? null : this._buffer.subarray(state.start)
+      const frame = this._frame
+
+      this._buffered -= frame
+      this._buffer = this._buffered > 0 ? [buffer.subarray(frame)] : []
+      this._frame = -1
+
+      this._onmessage(buffer.subarray(0, frame))
+      this._onbeforeframe()
+    }
+  }
+
+  _onmessage(buffer) {
+    let message
+    try {
+      message = m.message.decode(c.state(0, buffer.length, buffer))
+    } catch (err) {
+      safetyCatch(err)
+
+      return this._stream.destroy(err)
+    }
+
+    switch (message.type) {
+      case t.REQUEST:
+        const request = new IncomingRequest(
+          this,
+          message.id,
+          message.command,
+          message.data
+        )
+
+        try {
+          this._onrequest(request)
+        } catch (err) {
+          safetyCatch(err)
+
+          this._sendError(request, err)
+        }
+        break
+      case t.RESPONSE:
+        try {
+          this._onresponse(message)
+        } catch (err) {
+          safetyCatch(err)
+        }
+        break
+      case t.STREAM:
+        try {
+          this._onstream(message)
+        } catch (err) {
+          safetyCatch(err)
+        }
     }
   }
 
@@ -357,3 +392,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
 
@@ -142,11 +142,9 @@ exports.message = {
     state.start = end
   },
   decode(state) {
-    if (state.end - state.start < 4) return null
-
     const frame = c.uint32.decode(state)
 
-    if (state.end - state.start < frame) return null
+    if (state.end - state.start < frame) throw new RangeError('Out of bounds')
 
     const type = c.uint.decode(state)
     const id = c.uint.decode(state)

package/lib/outgoing-request.js

@@ -7,6 +7,7 @@ module.exports = class RPCOutgoingRequest {
     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.4",
+  "version": "0.2.1",
   "description": "librpc ABI compatible RPC for Bare",
   "exports": {
     ".": {