jsonrpc-serializer

A simple library to serialize/deserialize JSON-RPC 2.0 messages

JSON-RPC serializer

This is a simple library to perform serialization/deserialization of JSON-RPC 2.0 messages. It has full support for Date and Error objects, comforms to the JSON-RPC 2.0 specifications, and allows plugins (in the near future) to extend the library.

JSON-RPC 2.0 is transport agnostic, but unfortunately this is not the case for most JSON-RPC modules in the NPM. Thus, when I needed a library to use JSON-RPC 2.0 over hook.io and 0MQ, I ran into a brick wall, and ended up writing this library.

It's small. It's simple. And I hope this will be useful to you as well.

npm install jsonrpc-serializer
var jrs = require('jsonrpc-serializer');

var request = jrs.request('request-id', 'request-method');

// ---> "{\"jsonrpc\":\"2.0\",\"id\":\"request-id\",\"method:\":\"request-method\"}"

var ok = "{\"jsonrpc\":\"2.0\",\"id\":\"request-id\",\"result\":\"success!!\"}";

var response = jrs.deserialize(ok);

// ---> 
//  {
//      type    : 'success',
//      payload : {
//          id     : 'request-id',
//          result : 'success!!'
//      }
//  }

The library works on serializing objects to JSON-RPC 2.0 (henceforth known as JR2) messages, and deserializing them back. There are 4 different kinds of objects that can be serialized: request, notification, success and error (JSON-RPC 2.0 Specs).


nametyperequireddescription
idstring or numberYESthe ID to attach to this JSON-RPC message
methodstringYESthe name of the method to invoke on the receiver
paramsstring, object or arrayNOparameters to pass to the receiver
returnstring-returns a serialized string of a proper JSON-RPC 2.0 request object

You can use this method to create a JSON-RPC 2.0 request payload to send over the transport of your choice. All you need is to generate an ID for this request, provide a method name to invoke on the receiver side, and parameters to pass over as well.

Here's an example of request() in action:

var jrs = require('jsonrpc-serializer');
var uuid = require('node-uuid'); // npm install node-uuid to get this

var payload = jrs.request(
    uuid.v4(),   // generates a V4 UUID string
    'saveUser',  // the method to call
    {
        name  : 'Ruben Tan',
        email : 'foo@bar.com',
        race  : 'unicorn'
    }
);

console.log(payload);
// This will output the following JSON object as a STRING
// {
//     "jsonrpc" : "2.0",
//     "id" : "0ea77279-b59a-47da-bfa9-21f5895fd28e",
//     "method" : "saveUser",
//     "params" : {
//         "name" : "Ruben Tan",
//         "email" : "foo@bar.com",
//         "race" : "unicorn"
//     }
// }

nametyperequireddescription
methodstringYESthe name of the method to invoke on the receiver
paramsstring, object or arrayNOparameters to pass to the receiver
returnstring-returns a serialized string of a proper JSON-RPC 2.0 notification object

Serializes a notification message. A notification message is the same as a request message, with the only difference being that it does not contain an id field, and thus does not expect a reply from the server. This also exempts notifications from receiving errors if any.

var jrs = require('jsonrpc-serializer');

var payload = jrs.request(
    'newMessage',  // the method to call
    {
        subject : 'Test message',
        message : 'This is a test message'
    }
);

console.log(payload);
// This will output the following JSON object as a STRING
// {
//     "jsonrpc" : "2.0",
//     "method" : "newMessage",
//     "params" : {
//         "subject" : "Test message",
//         "message" : "This is a test message"
//     }
// }

nametyperequireddescription
idstringYESthe ID of the request to be matched on the server side
resultstring, object or arrayYESthe result of the JSON-RPC call
returnstring-returns a serialized string of a proper JSON-RPC 2.0 success response

Serializes a success message. This is usually used on the server side to send results back to the client after receiving the RPC method call. It consists of an id and a result field.

Example pending

nametyperequireddescription
idstringYESthe ID of the request to be matched on the server side
errorobjectYESan error object containing the error to be passed to the server side
returnstring-returns a serialized string of a proper JSON-RPC 2.0 error response

Serializes an error message. This is the same as the success message, except instead of result we have error. The error field MUST be an object, and it MUST conform to the error object spec mentioned in the JSON-RPC 2.0 Specs.

See the specs for the exact format for error objects, but for the convenience of developers using this module, I've abstracted the defined ones into a few classes:

NamespaceCodeDescription
jrs.err.JsonRpcError( msg )-32603This is the base class for all the other custom RPC error objects. Please note that when integrating this module, make sure to derive from this base class if you want to create more custom errors. This will ensure that all serialization of error objects are consistent.
jrs.err.ParseError()-32700This is thrown when the deserializer fails to recognize the message as a proper JSON entity.
jrs.err.InvalidRequestError()-32600This is thrown when the deserializer successfully parses the message into JSON, but realizes it is not a proper JSON-RPC 2.0 message.
jrs.err.MethodNotFoundError()-32601This is what you use when the required method is not found.
jrs.err.InvalidParamsError()-32602This is what you use when the parameters provided is not compatible with the methods being invoked

nametyperequireddescription
msgstringYESa serialized JSON
returnobject-returns a deserailized javascript object

This method takes a message in msg, parses it, and tries to figure out which of the four JSON-RPC 2.0 objects it is: request, notification, success or error. If it cannot figure out, or the message is faulty, it will instead return an appropriate instance (or child instance) of JsonRpcError.

The object returned if successful looks like this:

{
    type    : 'request',
    payload : {
        id     : 'id',
        method : 'method'
    }
}

Where type is one of the four types (request, notification, success or error) and payload is the actual JSON-RPC message in JSON format itself, with the property jsonrpc="2.0" removed.

The message in msg is appended to the internal data structure as message:

var err = new jrs.err.JsonRpcError('This is an error');
var str = err.serialize();

//  str = {
//      code    : -32603,
//      message : 'This is an error',
//      name    : 'JsonRpcError',
//      data    : ['This is an error']
//  };

See below

See below

See below

Since all four of these errors are the same, I'll go through them together. They are essentially the same format as JsonRpcError, with the right serialize() method, but the difference is that the message property is fixed. Therefore, any params passed in the constructor will be saved into an array inside the data property, instead of changing the message property itself. Here's an example:

var err = new jrs.err.ParseError('This is an error');
var str = err.serialize();

//  str = {
//      code    : -32700,
//      message : 'Unable to parse payload as a JSON.',
//      name    : 'ParseError',
//      data    : ['This is an error']
//  };

Copyright (c) 2013 Ruben LZ Tan

Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.