Jsonrpcserver NPM

JSON-RPC Server

Simple-to-use JSON-RPC Server with endpoints implementation (JSON-RPC Specification).

install

$ npm install jsonrpcserver --save

how to use

You can instantiate HTTP-server (default usage):

var logger = require('mylogger'),
    API = require('myapi'),
    JsonRpcServer = require('jsonrpcserver');
    
var rpcServerInstance = new JsonRpcServer(logger); //logger is an optional one

...

rpcServerInstance.register('/my/new/endpoint', {
    "context": new API(),
    "map": {
        "testMethod": {
            "handler": "test",
            "params": [
                {
                    "type": "string",
                    "required": true
                }
            ]
        },
        "yetAnotherMethod": {
            "handler": function(options, cb) {
                (typeof cb == 'function') && cb(null, options);
            },
            "params": {
                "first": {
                    "type": "number",
                    "required": true
                },
                "second": {
                    "type": "any",
                    "required": false,
                    "default": "Foo"
                }
            }
        }
    }
});

...

rpcServerInstance.init({
    handler: 80,
    timeout: 10
});

Or you can use jsonrpcserver as proxy:

var logger = require('mylogger'),
    API = require('myapi'),
    JsonRpcServer = require('jsonrpcserver');
    
var rpcServerInstance = new JsonRpcServer(logger); //logger is an optional one

...

rpcServerInstance.register('/my/new/endpoint', {
    "context": new API(),
    "map": {
        "testMethod": {
            "handler": "test",
            "params": [
                {
                    "type": "string",
                    "required": true
                }
            ]
        },
        "yetAnotherMethod": {
            "handler": function(options, cb) {
                (typeof cb == 'function') && cb(null, options);
            },
            "params": {
                "first": {
                    "type": "number",
                    "required": true
                },
                "second": {
                    "type": "any",
                    "required": false,
                    "default": "Foo"
                }
            }
        }
    }
});

...

// proxy my request 
var request = {
    method: "yetAnotherMethod",
    params: {
        first: 1,
        second: "Bar"
    },
    id: 1
};
rpcServerInstance.proxy('/my/new/endpoint', request, function(response) {
    console.log(response);
    
    //  {
    //      httpCode: 200,
    //      headers: {
    //          'Content-Type': 'application/json-rpc'
    //      },
    //      payload: {
    //          jsonrpc: '2.0',
    //          result: { ok: 1 },
    //          id: 1
    //      }
    //  }
});

api

`constructor (logger)` - create the server

logger - an optional parameter, it means reference to the logger instance; console will use by default

`register (endpoint, map)` - register endpoint

You can use register method (as well as unload) at any time in code, definition order (before or after init) doesn't matter.

endpoint - - endpoint URI, that will handle your requests
map - - API schema map, such as (type 'any' could use for non-strict type validation):

/**
 * @param map = {
 *      context: <object>,
 *      map: {
 *          methodName1: {
 *              handler: <functionName|callable>,
 *              //-- with named params ---
 *              params: {
 *                  param1: {
 *                      type: "string|number|boolean|object|array|any",
 *                      required: true|false,
 *                      default: <defaultValue>
 *                  },
 *              ...
 *              }
 *              //-- or with array-like params --
 *              params: [
 *                  {
 *                      type: "string|number|boolean|object|array|any",
 *                      required: true|false,
 *                      default: <defaultValue>
 *                  },
 *              ...
 *              ]
 *          },
 *          ...
 *      }
 * }
 */

`unload (endpoint)` - unload the endpoint

endpoint - - endpoint URI that would be unloaded

`proxy (endpoint, payload, callback)` - emulate the request

endpoint - - endpoint URI that would be unloaded
payload - - request object according to JSON-RPC 2.0 Specification
callback - - callback that handles the response

`init (configuration)` - instantiate the server

configuration - - an optional parameter, that describe server configuration (look below, with defaults):

{
    "handler": 80,  // it may be port, unix-socket path or instance of HTTP/HTTPS server, by default 80 port
    "https": false, // boolean flag sets true if we want set up the HTTPS server
    "key": null,    // the SSL-key path (for HTTPS only)
    "cert": null,   // the SSL-cert path (for HTTPS only)
    "timeout": 60   // the request timeout in sec, by default 60
}