Jayson

Jayson is a JSON-RPC 2.0 and 1.0 compliant server and client written in JavaScript for node.js that aims to be as simple as possible to use.

Table of contents

• Features
• Example
• Installation
• Changelog
• Requirements
• Class Documentation
• Running tests
• Typescript
• Usage
  • Client
    • Interface description
    • Browser usage
    • Notifications
    • Batches
    • Callback syntactic sugar
    • Events
  • Server
    • Interface description
    • Many interfaces at the same time
    • Using the server as a relay
    • Method routing
    • Method definition
    • Events
    • Errors
    • CORS
    • Context
• Revivers and replacers
• Named parameters
• Promises
  • Batches
• FAQ
• Recommended usage
• Contributing

Features

• Servers that can listen to several interfaces at the same time
• Supports both HTTP and TCP client and server connections
• Server-side method routing
• Relaying of requests to other servers
• JSON reviving and replacing for transparent serialization of complex objects
• CLI client
• Promises
• Fully tested to comply with the official JSON-RPC 2.0 specification
• Also supports JSON-RPC 1.0

Example

A basic JSON-RPC 2.0 server via HTTP:

Server example in examples/simple_example/server.js:

'use strict';
 
const jayson = require('./../..');
 
// create a server
const server = jayson.server({
  add: function(args, callback) {
    callback(null, args[0] + args[1]);
  }
});
 
server.http().listen(3000);

Client example in examples/simple_example/client.js invoking add on the above server:

'use strict';
 
const jayson = require('./../..');
 
// create a client
const client = jayson.client.http({
  port: 3000
});
 
// invoke "add"
client.request('add', [1, 1], function(err, response) {
  if(err) throw err;
  console.log(response.result); // 2
});

Installation

Install the latest version of jayson from npm by executing npm install jayson in your shell. Do a global install with npm install --global jayson if you want the jayson client CLI in your PATH.

Changelog (only notable milestones)

• 3.0.0
  • Can pass a context object to handlers
  • Breaking: collect option removed from jayson.Server/Method. JSON-RPC params to handlers are now always in the first argument.
• 2.1.0
  • Experimental typescript support
• 2.0.6
  • Clarified how to use in the browser
• 2.0.0
  • Added support for promises
  • Breaking: collect: true is now the default option for a new jayson.Server and jayson.Method
• 1.2.0
  • Greatly improved server method definition
• 1.1.1
  • More http server events
  • Remove fork server and client
  • Add server routing
• 1.0.11 Add support for a HTTPS client
• 1.0.9 Add support for TCP servers and clients

CLI client

There is a basic CLI client in bin/jayson.js and it should be available as jayson in your shell if you installed the package globally. Run jayson --help to see how it works.

Requirements

Jayson does not have any special dependencies that cannot be resolved with a simple npm install. It is being continuously tested using travis-ci. You can look inside .travis.yml if you want to see which versions are tested against.

Class documentation

In addition to this document, a comprehensive class documentation made with jsdoc is available at jayson.tedeh.net.

Running tests

• Change directory to the repository root
• Install the development packages by executing npm install --dev
• Run the tests with npm run test

Typescript

Since v2.1.0 there is experimental typescript support available with jayson. Anyone that would like to improve on the type definitions is most welcome to provide a pull request.

If you would just like to report an issue with the type definitions that you can't solve by yourself, please read the previous discussion here first: https://github.com/tedeh/jayson/issues/99

Usage

Client

The client is available as the Client or client property of require('jayson').

Client interface description

Every client supports these options:

Client.http

Uses the same options as http.request in addition to these options:

Client.http Events

The HTTP server will emit the following events:

It is possible to pass a string URL as the first argument. The URL will be run through url.parse. Example:

var jayson = require('jayson');
var client = jayson.client.http('http://localhost:3000');
// client.options is now the result of url.parse

Client.https

Uses the same options as https.request in addition to the same options as Client.http. This means it is also possible to pass a string URL as the first argument and have it interpreted by url.parse.

Will emit the same custom events as Client.http.

Client.tcp

Uses the same options as net.connect in addition to the same options as Client.http.

Client.tls

Uses the same options as tls.connect in addition to the same options as Client.http.

Client.browser

The browser client is a simplified version of the regular client for use browser-side. It does not have any dependencies on node.js core libraries (but does depend on the uuid and lodash) and also does not know how to "send" a request to a server like the other clients.

Because it does not depend on any core libraries, the browser client is not an instance of JaysonClient or EventEmitter and therefore does not emit any of the normal request events that the other clients do.

To use the browser client, require('jayson/lib/client/browser') and pass a calling/transport function as the first argument. The transport function receives a JSON-RPC string request and is expected to callback with a string response received from the server (not JSON) or an error (not a JSON-RPC error).

The reason for dealing with strings is to support the reviver and replacer options like the other clients.

This client example in examples/browser_client/client.js below uses node-fetch in the transport function, but a dropin replacement for use in an actual browser could instead use whatwg-fetch.

'use strict';
 
const jaysonBrowserClient = require('./../../lib/client/browser');
const fetch = require('node-fetch');
 
const callServer = function(request, callback) {
  const options = {
    method: 'POST',
    body: request,
    headers: {
      'Content-Type': 'application/json',
    }
  };
 
  fetch('http://localhost:3000', options)
    .then(function(res) { return res.text(); })
    .then(function(text) { callback(null, text); })
    .catch(function(err) { callback(err); });
};
 
const client = jaysonBrowserClient(callServer, {
  // other options go here
});
 
client.request('multiply', [5, 5], function(err, error, result) {
  if(err) throw err;
  console.log(result); // 25
});

Notifications

Notification requests are for cases where the reply from the server is not important and should be ignored. This is accomplished by setting the id property of a request object to null.

Client example in examples/notifications/client.js doing a notification request:

'use strict';
 
const jayson = require('./../..');
 
const client = jayson.client.http({
  port: 3000
});
 
// the third parameter is set to "null" to indicate a notification
client.request('ping', [], null, function(err) {
  if(err) throw err;
  console.log('ok'); // request was received successfully
});

Server example in examples/notifications/server.js:

'use strict';
 
const jayson = require('./../..');
 
const server = jayson.server({
  ping: function(args, callback) {
    // do something, do nothing
    callback();
  }
});
 
server.http().listen(3000);

Notes

• Any value that the server returns will be discarded when doing a notification request.
• Omitting the third argument null to Client.prototype.request does not generate a notification request. This argument has to be set explicitly to null for this to happen.
• Network errors and the like will still reach the callback. When the callback is invoked (with or without error) one can be certain that the server has received the request.
• See the Official JSON-RPC 2.0 Specification for additional information on how Jayson handles notifications that are erroneous.

Batches

A batch request is an array of individual requests that are sent to the server as one. Doing a batch request is very simple in Jayson and consists of constructing an array of individual requests (created by not passing a callback to Client.prototype.request) that is then itself passed to Client.prototype.request.

Combined server/client example in examples/batch_request/index.js:

'use strict';
 
const jayson = require('./../..');
 
const server = jayson.server({
  add: function(args, callback) {
    callback(null, args[0] + args[1]);
  }
});
 
const client = jayson.client(server);
 
const batch = [
  client.request('does_not_exist', [10, 5]),
  client.request('add', [1, 1]),
  client.request('add', [0, 0], null) // a notification
];
 
client.request(batch, function(err, errors, successes) {
  if(err) throw err;
  console.log('errors', errors); // array of requests that errored
  console.log('successes', successes); // array of requests that succeeded
});
 
client.request(batch, function(err, responses) {
  if(err) throw err;
  console.log('responses', responses); // all responses together
});

Notes

• See the Official JSON-RPC 2.0 Specification for additional information on how Jayson handles different types of batches, mainly with regards to notifications, request errors and so forth.
• There is no guarantee that the results will be in the same order as request Array request. To find the right result, compare the ID from the request with the ID in the result yourself.

Client callback syntactic sugar

When the length (number of arguments) of a client callback function is either 2 or 3 it receives slightly different values when invoked.

• 2 arguments: first argument is an error or null, second argument is the response object as returned (containing either a result or a error property) or null for notifications.
• 3 arguments: first argument is an error or null, second argument is a JSON-RPC error property or null (if success), third argument is a JSON-RPC result property or null (if error).

When doing a batch request with a 3-length callback, the second argument will be an array of requests with a error property and the third argument will be an array of requests with a result property.

Client events

A client will emit the following events (in addition to any special ones emitted by a specific interface):

Server

The server classes are available as the Server or server property of require('jayson').

The server also sports several interfaces that can be accessed as properties of an instance of Server.

Server interface description

Servers supports these options:

Server.tcp

Uses the same options as the base class. Inherits from net.Server.

Server.tls

Uses the same options as the base class. Inherits from tls.Server.

Server.http

Uses the same options as the base class. Inherits from http.Server.

Server.http Events

Server.https

Uses the same options as the base class. Inherits from https.Server and jayson.Server.http. For information on how to configure certificates, see the documentation on https.Server.

Will emit the same custom events as Server.http.

Server.middleware

Uses the same options as the base class. Returns a function that is compatible with Connect or Express. Will expect the request to be req.body, meaning that the request body must be parsed (typically using connect.bodyParser) before the middleware is invoked.

The middleware supports the following options:

Middleware example in examples/middleware/server.js:

'use strict';
 
const jayson = require('./../..');
const jsonParser = require('body-parser').json;
const connect = require('connect');
const app = connect();
 
const server = jayson.server({
  add: function(args, callback) {
    callback(null, args[0] + args[1]);
  }
});
 
// parse request body before the jayson middleware
app.use(jsonParser());
app.use(server.middleware());
 
app.listen(3000);

Many interfaces at the same time

A Jayson server can use many interfaces at the same time.

Server example in examples/many_interfaces/server.js that listens to both http and a https requests:

'use strict';
 
const jayson = require('./../..');
 
const server = jayson.server();
 
// "http" will be an instance of require('http').Server
const http = server.http();
 
// "https" will be an instance of require('https').Server
const https = server.https({
  //cert: require('fs').readFileSync('cert.pem'),
  //key require('fs').readFileSync('key.pem')
});
 
http.listen(80, function() {
  console.log('Listening on *:80');
});
 
https.listen(443, function() {
  console.log('Listening on *:443');
});

Using the server as a relay

Passing an instance of a client as a method to the server makes the server relay incoming requests to wherever the client is pointing to. This might be used to delegate computationally expensive functions into a separate server or to abstract a cluster of servers behind a common interface.

Frontend server example in examples/relay/server_public.js listening on *:3000:

'use strict';
 
const jayson = require('./../..');
 
// create a server where "add" will relay a localhost-only server
const server = jayson.server({
  add: jayson.client.http({
    port: 3001
  })
});
 
// let the frontend server listen to *:3000
server.http().listen(3000);

Backend server example in examples/relay/server_private.js listening on *:3001:

'use strict';
 
const jayson = require('./../..');
 
const server = jayson.server({
  add: function(args, callback) {
    callback(null, args[0] + args[1]);
  }
});
 
// let the backend listen to *:3001
server.http().listen(3001);

Every request to add on the public server will now relay the request to the private server. See the client example in examples/relay/client.js.

Method routing

Passing a property named router in the server options will enable you to write your own logic for routing requests to specific functions.

Server example with custom routing logic in examples/method_routing/server.js:

'use strict';
 
const jayson = require('./../..');
 
const methods = {
  add: function(args, callback) {
    callback(null, args[0] + args[1]);
  }
};
 
const server = jayson.server(methods, {
  router: function(method, params) {
    // regular by-name routing first
    if(typeof(this._methods[method]) === 'function') return this._methods[method];
    if(method === 'add_2') {
      const fn = server.getMethod('add').getHandler();
      return new jayson.Method(function(args, done) {
        args.unshift(2);
        fn(args, done);
      });
    }
  }
});
 
server.http().listen(3000);

Client example in examples/method_routing/client.js invoking add_2 on the above server:

'use strict';
 
const jayson = require('./../..');
 
// create a client
const client = jayson.client.http({
  port: 3000
});
 
// invoke "add_2"
client.request('add_2', [3], function(err, response) {
  if(err) throw err;
  console.log(response.result); // 5!
});

Server example of nested routes where each property is separated by a dot (you do not need to use the router option for this):

'use strict';
 
const _ = require('lodash');
const jayson = require('jayson');
 
const methods = {
  foo: {
    bar: function(callback) {
      callback(null, 'ping pong');
    }
  },
  math: {
    add: function(args, callback) {
      callback(null, args[0] + args[1]);
    }
  }
};
 
// this reduction produces an object like this: {'foo.bar': [Function], 'math.add': [Function]}
const map = _.reduce(methods, collapse('', '.'), {});
const server = jayson.server(map);
 
function collapse(stem, sep) {
  return function(map, value, key) {
    var prop = stem ? stem + sep + key : key;
    if(_.isFunction(value)) map[prop] = value;
    else if(_.isObject(value)) map = _.reduce(value, collapse(prop, sep), map);
    return map;
  }
}

Notes

• If router does not return anything, the server will respond with a Method Not Found error.
• The Server.prototype methods method, methods, removeMethod and hasMethod will not use the router method, but will operate on the internal Server.prototype._methods map.
• The router method is expected to return instances of jayson.Method (>=1.2.0)

Method definition

You can also define server methods inside a wrapping object named jayson.Method. This allows additional options about the method to be specified. Using this wrapper - explicitly or implicitly (via server options) - makes it trivial to have your method accept a variable amount of arguments.

The method class is available as the Method or method property of require('jayson'). It supports these options:

Server example showcasing most features and options in examples/method_definitions/server.js:

'use strict';
 
const jayson = require('./../..');
const _ = require('lodash');
 
const methods = {
 
  // this function will be wrapped in jayson.Method with options given to the server
  sum: function(args, done) {
    done(null, sum(args));
  },
 
  // this function always receives a context object as second arg
  // it can be overriden on the server level
  context: jayson.Method(function(args, context, done) {
    done(null, context);
  }, {useContext: true}),
 
  // specifies some default values (alternate definition too)
  sumDefault: jayson.Method(function(args, done) {
    const total = sum(args);
    done(null, total);
  }, {
    params: {a: 2, b: 5} // map of defaults
  }),
 
  // this method returns true when it gets an array (which it always does)
  isArray: new jayson.Method({
    handler: function(args, done) {
      const result = _.isArray(args);
      done(null, result);
    },
    params: Array // could also be "Object"
  })
 
};
 
const server = jayson.server(methods, {
  // these options are given as options to jayson.Method when adding the method "sum".
  // this is because it is not wrapped in jayson.Method like the others.
  useContext: false,
  params: Array
});
 
server.http().listen(3000);
 
// sums all numbers in an array or object
function sum(list) {
  return _.reduce(list, function(sum, val) {
    return sum + val;
  }, 0);
}

Client example in examples/method_definitions/client.js:

'use strict';
 
const jayson = require('./../..');
 
const client = jayson.client.http({
  port: 3000
});
 
// invoke "sum" with array
client.request('sum', [3, 5, 9, 11], function(err, response) {
  if(err) throw err;
  console.log(response.result); // 28
});
 
// invoke "sum" with an object
client.request('sum', {a: 2, b: 3, c: 4}, function(err, response) {
  if(err) throw err;
  console.log(response.result); // 9
});
 
// invoke "sumDefault" with object missing some defined members
client.request('sumDefault', {b: 10}, function(err, response) {
  if(err) throw err;
  console.log(response.result); // 12
});
 
// invoke "isArray" with an Object
client.request('isArray', {a: 5, b: 2, c: 9}, function(err, response) {
  if(err) throw err;
  console.log(response.result); // true
});
 
// invoke "context"
client.request('context', {hello: 'world'}, function(err, response) {
  if(err) throw err;
  console.log(response.result); // {} - just an empty object
});

Server events

In addition to events that are specific to certain interfaces, all servers will emit the following events:

Server Errors

If you should like to return an error from an method request to indicate a failure, remember that the JSON-RPC 2.0 specification requires the error to be an Object with a code (Integer/Number) to be regarded as valid. You can also provide a message (String) and a data (Object) with additional information. Example:

var jayson = require('jayson');
 
var server = jayson.server({
  i_cant_find_anything: function(args, callback) {
    var error = {code: 404, message: 'Cannot find ' + args.id};
    callback(error); // will return the error object as given
  },
  i_cant_return_a_valid_error: function(callback) {
    callback({message: 'I forgot to enter a code'}); // will return a pre-defined "Internal Error"
  }
});

Predefined Errors

It is also possible to cause a method to return one of the predefined JSON-RPC 2.0 error codes using the server helper function Server.prototype.error inside of a server method. Example:

var jayson = require('jayson');
 
var server = jayson.server({
  invalid_params: function(args, callback) {
    var error = this.error(-32602); // returns an error with the default properties set
    callback(error);
  }
});

You can even override the default messages:

var jayson = require('jayson');
 
var server = jayson.server({
  error_giver_of_doom: function(callback) {
    callback(true) // invalid error format, which causes an Internal Error to be returned instead
  }
});
 
// Override the default message
server.errorMessages[Server.errors.INTERNAL_ERROR] = 'I has a sad. I cant do anything right';

Server CORS

Jayson does not include functionality for supporting CORS requests natively but it is easy to use a CORS-enabling middleware like cors. An example of this can be found in examples/cors/server.js:

'use strict';
 
const jayson = require('./../..');
const cors = require('cors');
const connect = require('connect');
const jsonParser = require('body-parser').json;
const app = connect();
 
const server = jayson.server({
  myNameIs: function(args, callback) {
    callback(null, 'Your name is: ' + args.name);
  }
});
 
app.use(cors({methods: ['POST']}));
app.use(jsonParser());
app.use(server.middleware());
 
app.listen(3000);

Server Context

Since version 3.0.0

You can provide an optional context object to JSON-RPC method handlers. This can be used to give extra data to a handler such as request headers, authentication tokens, and so on.

This feature is unlocked by having jayson.Method accepts a boolean option called useContext. It always defaults to false for backwards compatibility. When it is set to true the method handler that jayson.Method wraps will always receive a context object as the second argument. The object can be given as the third argument to jayson.Server.prototype.call.

Server example in examples/context/server.js:

'use strict';
 
const _ = require('lodash');
const jayson = require('./../..');
const jsonParser = require('body-parser').json;
const express = require('express');
const app = express();
 
const server = jayson.server({
 
  getHeaders: function(args, context, callback) {
    callback(null, context.headers);
  },
 
  // old method not receiving a context object (here for reference)
  oldMethod: new jayson.Method(function(args, callback) {
    callback(null, {});
  }, {
    // this setting overrides the server option set below for this particular method only
    useContext: false
  })
 
}, {
  // all methods will receive a context object as the second arg
  useContext: true
});
 
app.use(jsonParser());
app.use(function(req, res, next) {
  // prepare a context object passed into the JSON-RPC method
  const context = {headers: req.headers};
  server.call(req.body, context, function(err, result) {
    if(err) return next(err);
    res.send(result || {});
  });
});
 
app.listen(3001);