bare-rpc 0.2.6 → 0.2.7

package/README.md

@@ -11,6 +11,7 @@ npm i bare-rpc
 ```js
 import RPC from 'bare-rpc'
 
+// On one end
 const rpc = new RPC(stream, (req) => {
   if (req.command === 42) {
     console.log(req.data.toString()) // ping
@@ -30,7 +31,7 @@ console.log(replyBuffer.toString()) // pong
 
 ### `RPC`
 
-#### `const rpc = new RPC(stream, [onrequest])`
+#### `const rpc = new RPC(stream[, onrequest])`
 
 Create an RPC instance using a duplex `stream`. `onrequest` is an optional callback run when a remote request is received. This is where processing and responding to an RPC request happens. `onrequest` receives a `RPCIncomingRequest` as an argument, for example:
 
@@ -64,7 +65,7 @@ A boolean for whether the request has been sent.
 
 A boolean for whether the request has received a reply.
 
-#### `req.send(data, [encoding])`
+#### `req.send(data[, encoding])`
 
 Send the request with the provided `data`. `data` can be a buffer or a string which will be encoded using `encoding`.
 
@@ -74,13 +75,13 @@ Send the request with the provided `data`. `data` can be a buffer or a string wh
 
 Await the reply from the remote end to the request. `encoding` can be defined for decoding the response `data` buffer back into a string.
 
-#### `const stream = req.createRequestStream([opts])`
+#### `const stream = req.createRequestStream([options])`
 
-Create a [`Writable`](https://github.com/mafintosh/streamx?tab=readme-ov-file#writable-stream) stream for sending data with the request.
+Create a [`Writable`](https://github.com/mafintosh/streamx#writable-stream) stream for sending data with the request.
 
-#### `const stream = req.createResponseStream([opts])`
+#### `const stream = req.createResponseStream([options])`
 
-Create a [`Readable`](https://github.com/mafintosh/streamx?tab=readme-ov-file#readable-stream) stream for receiving data in reply to the request.
+Create a [`Readable`](https://github.com/mafintosh/streamx#readable-stream) stream for receiving data in reply to the request.
 
 ### `RPCIncomingRequest`
 
@@ -104,11 +105,11 @@ A boolean for whether the request has been received as a stream. See [`req.creat
 
 Reply to the request with the provided `data`. `data` can be a buffer or a string which will be encoded using `encoding`.
 
-#### `const stream = req.createRequestStream([opts])`
+#### `const stream = req.createRequestStream([options])`
 
 Create a `Readable` stream for receiving data from the request.
 
-#### `const stream = req.createResponseStream([opts])`
+#### `const stream = req.createResponseStream([options])`
 
 Create a `Writable` stream for sending data in reply to the request.
 
@@ -118,8 +119,7 @@ An alternative way to define commands and handlers for receiving them.
 
 #### `const router = new RPC.CommandRouter()`
 
-Create a new command router. This router can then be used when creating an
-`rpc`. For example:
+Create a new command router. This router can then be used when creating an `rpc`. For example:
 
 ```js
 const router = new RPC.CommandRouter()
@@ -135,16 +135,18 @@ const req = rpc.request(42)
 req.send('ping')
 ```
 
-#### `router.respond(command, [opts], async (req, data) => {})`
+#### `router.respond(command[, options], async (req, data) => {})`
 
 Define a command and the handler for it. The callback for a command receives both the request (`req`) and the `data` buffer and can return a value to respond. If the request is responded to in the callback, the return value is ignored.
 
-`opts` can include:
+Options include:
 
 ```
 {
-  requestEncoding: c.raw, // Encoding for decoding incoming request
-  responseEncoding: c.raw, // Encoding for outgoing response
+  // Encoding for incoming request
+  requestEncoding: c.raw,
+  // Encoding for outgoing response
+  responseEncoding: c.raw,
 }
 ```
 

package/index.js

@@ -12,7 +12,6 @@ const CommandRouter = require('./lib/command-router')
 module.exports = exports = class RPC {
   constructor(stream, onrequest = noop) {
     this._stream = stream
-
     this._id = 0
 
     this._outgoingRequests = new Map()
@@ -43,7 +42,11 @@ module.exports = exports = class RPC {
   }
 
   _sendMessage(message) {
-    this._stream.write(c.encode(m.message, message))
+    const header = c.encode(m.header, message)
+
+    this._stream.write(header)
+
+    if (message.data) this._stream.write(message.data)
   }
 
   _sendRequest(request, data = null) {

package/lib/incoming-request.js

@@ -1,4 +1,4 @@
-const b4a = require('b4a')
+const c = require('compact-encoding')
 const errors = require('./errors')
 
 module.exports = class RPCIncomingRequest {
@@ -19,12 +19,16 @@ module.exports = class RPCIncomingRequest {
       throw errors.ALREADY_SENT('Response has already been sent')
     }
 
+    encoding =
+      encoding && encoding !== 'buffer'
+        ? c.from(encoding)
+        : typeof data === 'string'
+          ? c.raw.utf8
+          : null
+
     this.sent = true
 
-    this.rpc._sendResponse(
-      this,
-      typeof data === 'string' ? b4a.from(data, encoding) : data
-    )
+    this.rpc._sendResponse(this, encoding ? c.encode(encoding, data) : data)
   }
 
   createResponseStream(opts = {}) {

package/lib/messages.js

@@ -2,26 +2,6 @@ const c = require('compact-encoding')
 const { type: t, stream: s } = require('./constants')
 const errors = require('./errors')
 
-const request = {
-  preencode(state, m) {
-    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.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.uint.decode(state)
-    const stream = c.uint.decode(state)
-    const data = stream === 0 ? c.buffer.decode(state) : null
-
-    return { type: t.REQUEST, id, command, stream, data }
-  }
-}
-
 const error = {
   preencode(state, m) {
     c.utf8.preencode(state, m.message)
@@ -41,79 +21,38 @@ const error = {
   }
 }
 
-const response = {
-  preencode(state, m) {
-    c.bool.preencode(state, !!m.error)
-    c.uint.preencode(state, m.stream)
-
-    if (m.error) error.preencode(state, m.error)
-    else if (m.stream === 0) c.buffer.preencode(state, m.data)
-  },
-  encode(state, m) {
-    c.bool.encode(state, !!m.error)
-    c.uint.encode(state, m.stream)
-
-    if (m.error) error.encode(state, m.error)
-    else if (m.stream === 0) c.buffer.encode(state, m.data)
-  },
-  decode(state) {
-    const err = c.bool.decode(state)
-    const stream = c.uint.decode(state)
-
-    if (err) {
-      return { stream, error: error.decode(state), data: null }
-    }
-
-    if (stream === 0) {
-      return { stream, error: null, data: c.buffer.decode(state) }
-    }
-
-    return { stream, error: null, data: null }
-  }
-}
-
-const stream = {
-  preencode(state, m) {
-    c.uint.preencode(state, m.stream)
-
-    if (m.stream & s.ERROR) error.preencode(state, m.error)
-    else if (m.stream & s.DATA) c.buffer.preencode(state, m.data)
-  },
-  encode(state, m) {
-    c.uint.encode(state, m.stream)
-
-    if (m.stream & s.ERROR) error.encode(state, m.error)
-    else if (m.stream & s.DATA) c.buffer.encode(state, m.data)
-  },
-  decode(state) {
-    const stream = c.uint.decode(state)
-
-    if (stream & s.ERROR)
-      return { stream, error: error.decode(state), data: null }
-    if (stream & s.DATA)
-      return { stream, error: null, data: c.buffer.decode(state) }
-
-    return { stream, error: null, data: null }
-  }
-}
-
-exports.message = {
+exports.header = {
   preencode(state, m) {
     c.uint32.preencode(state, 0) // Frame
     c.uint.preencode(state, m.type)
     c.uint.preencode(state, m.id)
 
+    let hasData = false
+
     switch (m.type) {
       case t.REQUEST:
-        request.preencode(state, m)
+        c.uint.preencode(state, m.command)
+        c.uint.preencode(state, m.stream)
+        if (m.stream === 0) hasData = true
         break
+
       case t.RESPONSE:
-        response.preencode(state, m)
+        c.bool.preencode(state, !!m.error)
+        c.uint.preencode(state, m.stream)
+
+        if (m.error) error.preencode(state, m.error)
+        else if (m.stream === 0) hasData = true
         break
+
       case t.STREAM:
-        stream.preencode(state, m)
+        c.uint.preencode(state, m.stream)
+
+        if (m.stream & s.ERROR) error.preencode(state, m.error)
+        else if (m.stream & s.DATA) hasData = true
         break
     }
+
+    if (hasData) c.uint.preencode(state, m.data.byteLength)
   },
   encode(state, m) {
     const frame = state.start
@@ -125,26 +64,44 @@ exports.message = {
     c.uint.encode(state, m.type)
     c.uint.encode(state, m.id)
 
+    let hasData = false
+
     switch (m.type) {
       case t.REQUEST:
-        request.encode(state, m)
+        c.uint.encode(state, m.command)
+        c.uint.encode(state, m.stream)
+        if (m.stream === 0) hasData = true
         break
+
       case t.RESPONSE:
-        response.encode(state, m)
+        c.bool.encode(state, !!m.error)
+        c.uint.encode(state, m.stream)
+
+        if (m.error) error.encode(state, m.error)
+        else if (m.stream === 0) hasData = true
         break
+
       case t.STREAM:
-        stream.encode(state, m)
+        c.uint.encode(state, m.stream)
+
+        if (m.stream & s.ERROR) error.encode(state, m.error)
+        else if (m.stream & s.DATA) hasData = true
         break
     }
 
+    if (hasData) c.uint.encode(state, m.data.byteLength)
+
     const end = state.start
 
     state.start = frame
 
-    c.uint32.encode(state, end - start)
+    c.uint32.encode(state, end - start + (hasData ? m.data.byteLength : 0))
 
     state.start = end
-  },
+  }
+}
+
+exports.message = {
   decode(state) {
     const frame = c.uint32.decode(state)
 
@@ -154,12 +111,42 @@ exports.message = {
     const id = c.uint.decode(state)
 
     switch (type) {
-      case t.REQUEST:
-        return { type, id, ...request.decode(state, id) }
-      case t.RESPONSE:
-        return { type, id, ...response.decode(state, id) }
+      case t.REQUEST: {
+        const command = c.uint.decode(state)
+        const stream = c.uint.decode(state)
+        const data = stream === 0 ? c.buffer.decode(state) : null
+
+        return { type, id, command, stream, data }
+      }
+
+      case t.RESPONSE: {
+        const err = c.bool.decode(state)
+        const stream = c.uint.decode(state)
+
+        if (err) {
+          return { type, id, stream, error: error.decode(state), data: null }
+        }
+
+        if (stream === 0) {
+          return { type, id, stream, error: null, data: c.buffer.decode(state) }
+        }
+
+        return { type, id, stream, error: null, data: null }
+      }
+
       case t.STREAM:
-        return { type, id, ...stream.decode(state, id) }
+        const stream = c.uint.decode(state)
+
+        if (stream & s.ERROR) {
+          return { type, id, stream, error: error.decode(state), data: null }
+        }
+
+        if (stream & s.DATA) {
+          return { type, id, stream, error: null, data: c.buffer.decode(state) }
+        }
+
+        return { type, id, stream, error: null, data: null }
+
       default:
         throw errors.UNKNOWN_MESSAGE(`Unknown message '${type}'`)
     }

package/lib/outgoing-request.js

@@ -1,4 +1,4 @@
-const b4a = require('b4a')
+const c = require('compact-encoding')
 const errors = require('./errors')
 
 module.exports = class RPCOutgoingRequest {
@@ -23,12 +23,16 @@ module.exports = class RPCOutgoingRequest {
       throw errors.ALREADY_SENT('Request has already been sent')
     }
 
+    encoding =
+      encoding && encoding !== 'buffer'
+        ? c.from(encoding)
+        : typeof data === 'string'
+          ? c.raw.utf8
+          : null
+
     this.sent = true
 
-    this.rpc._sendRequest(
-      this,
-      typeof data === 'string' ? b4a.from(data, encoding) : data
-    )
+    this.rpc._sendRequest(this, encoding ? c.encode(encoding, data) : data)
   }
 
   reply(encoding) {
@@ -36,10 +40,12 @@ module.exports = class RPCOutgoingRequest {
       throw errors.ALREADY_RECEIVED('Response is already being received')
     }
 
+    encoding = encoding && encoding !== 'buffer' ? c.from(encoding) : null
+
     this.received = true
 
-    return encoding && encoding !== 'buffer'
-      ? this._promise.then((data) => b4a.toString(data, encoding))
+    return encoding
+      ? this._promise.then((data) => c.decode(encoding, data))
       : this._promise
   }
 

package/package.json

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