Node bindings for Exosite One Platform API
JavaScript
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
test
.gitignore
.jshintrc
HISTORY.md
README.md
main.js
package.json
rpc.js

README.md

This is a node.js library that provides access to the One Platform RPC API.

NPM

Usage

var rpc = require('onep/rpc');
rpc.call(cik, 'info', [{alias: ''}, {}],
  function(err, rpcresponse, httpresponse) {
  if (err) {
    console.log('error: ' + err);  
  } else {
    if (rpcresponse[0].status === 'ok') {
      console.log(JSON.stringify(rpcresponse[0].result));
    } else {
      console.log('Bad status: ' + rpcresponse[0].status);
    }
  }
});

API

rpc.call

Make a single call to the RPC API.

rpc.call(auth, procedure, arguments, callback)
  • auth may be a 40 character client key (e.g. '0808160000000000000000000000000000000000'), or an auth object (e.g. {cik: '0808160000000000000000000000000000000000', client_key: 'e208160000000000000000000000000000000000'}). See the RPC documentation for details.
  • procedure is the procedure name, e.g. 'read' or 'info'.
  • arguments is a list of arguments to pass the call. These are specific to <procedure>. See the RPC documentation for a list of procedures and arguments.
  • callback is a function that takes three parameters: err is null if the call was made successfully (no HTTP or RPC general error). If the call failed, err contains the error message. rpcresponse contains a list containing a single RPC response. httpresponse is the response object.

Example

var rpc = require('onep/rpc');
rpc.call(
    cik,
    'listing',
    [['client', 'dataport'], {}],
    function(err, rpcresponse, httpresponse) {
      if (err) {
        console.log('error: ' + err);
      } else {
        console.log('response: ' + util.inspect(rpcresponse, false, null));
      }
  });

// output: 
response: [ { status: 'ok',
    result: 
     { client: [ '0808160000000000000000000000000000000000',
         'c138cc0000000000000000000000000000000000',
         'fdc8160000000000000000000000000000000000' ],
       dataport: [ '7e5c6f0000000000000000000000000000000000' ] } } ]

rpc.callMulti

Make multiple calls to the RPC API.

rpc.callMulti(auth, calls, callback)
  • auth may be a 40 character client key (e.g. '0808160000000000000000000000000000000000'), or an auth object (e.g. {cik: '0808160000000000000000000000000000000000', client_key: 'e208160000000000000000000000000000000000'}). See the RPC documentation for details.
  • calls is a list of calls like this: {procedure: <procedure>, arguments: <arguments>}. See the RPC documentation for a list of procedures and arguments.
  • callback is a function is called when the call completes. It takes three parameters: err is null if the call was made successfully (no HTTP or RPC general error). If the call failed, err contains the error message. rpcresponse contains a list of RPC responses. httpresponse is the response object.

Example

// get listing and info in one request
rpc.callMulti(
  cik,
  [
    {procedure: 'info', arguments: [{alias: ""}, {basic: true}]}
    {procedure: 'listing', arguments: [['client', 'dataport']]},
  ],
  function(err, rpcresponse, httpresponse) {
    if (err) {
      console.log('error: ' + err);
    } else {
      console.log('response: ' + util.inspect(rpcresponse, false, null));
    }
});

// output:
response: [ { id: 0,
    status: 'ok',
    result: 
     { client: [ '0808160000000000000000000000000000000000',
         'c138cc0000000000000000000000000000000000',
         'fdc8160000000000000000000000000000000000' ],
       dataport: [ '7e5c6f0000000000000000000000000000000000' ] } },
  { id: 1,
    status: 'ok',
    result: 
     { basic: 
        { modified: 1374553089,
          subscribers: 0,
          type: 'client',
          status: 'activated' } } } ]

rpc.tree

Return the RIDs of all descendants of a client.

rpc.tree(auth, options, callback)
  • auth may be a 40 character client key (e.g. '0808160000000000000000000000000000000000'), or an auth object (e.g. {cik: '0808160000000000000000000000000000000000', client_key: 'e208160000000000000000000000000000000000'}). See the RPC documentation for details.

  • options is an object with the following keys, all optional:

    • depth stop at a given depth from the root client (if omitted, depth is not limited)

    • visit function to call for each resource visited. It is called with rid, type, and depth parameters.

    • types list of type strings. Options are 'dataport', 'datarule', 'dispatch'. If omitted, visits only clients.

    • info if non-null, calls info on each resource with the specified options, e.g., {basic: true}. May also be a function called with rid, type, and depth parameters for each resource. If a function, it should return null or info options for that resource.

  • callback is a function is called when the call completes. It takes the following parameters:

    • err is null if the call succeeded. If the call failed, err contains the error message.

    • tree is the tree. If the call failed, it is undefined.

Example

rpc.tree(
  '76343a56f23d9ee80f2569c8209f4e9b11a5752e',
  {
    depth: 1,
    visit: function (rid, type, depth) {
      console.log(rid + ' (' + type + ') depth:' + depth);
    },
    types: ['dataport', 'datarule', 'dispatch'],
    info: function(rid, type, depth) {
      return type === 'client' ? {basic: true} : null;
    }
  },
  function(err, tree) { 
    console.log(err ? 'Error ' + err : JSON.stringify(tree, null, 2));
  });

// output
datarule
30e8a54ef29e55415b444ed72a961be4ea0ec270 (client) depth:0
0affc14ebdf520587b6957170ec6af06b7b6ca2a (dataport) depth:1
cbf6f7731ed8ae0285b2e8f9b437356544332679 (dataport) depth:1
a0ebc3d703c94e9b37bb4a2796e447334d7ffea2 (datarule) depth:1
{
  "rid": "30e8a54ef29e55415b444ed72a961be4ea0ec270",
  "type": "client",
  "children": [
    {
      "rid": "0affc14ebdf520587b6957170ec6af06b7b6ca2a",
      "type": "dataport"
    },
    {
      "rid": "cbf6f7731ed8ae0285b2e8f9b437356544332679",
      "type": "dataport"
    },
    {
      "rid": "a0ebc3d703c94e9b37bb4a2796e447334d7ffea2",
      "type": "datarule"
    }
  ],
  "info": {
    "basic": {
      "modified": 1422061952,
      "subscribers": 0,
      "type": "client",
      "status": "activated"
    }
  }
}

rpc.batch

Make a lot of RPC calls, splitting the calls into evenly sized chunks to avoid timeouts and calling in parallel to go fast.

rpc.batch(auth, calls, options, callback)
  • auth is an RPC auth object or CIK string

  • calls is an array of call objects like this: {procedure: <procedure>, arguments: <args>}

  • options are:

    • chunkSize is the number of calls per request

    • parallelLimit is the maximum number of concurrent requests to run in parallel

rpc.walk

Walk the object returned by tree().

rpc.walk(tree, visit);
  • tree is the object returned by calling tree()

  • calls visit(resource, depth, parentRID) on each resource. For the root resource, parentRID is undefined.

rpc.setOptions

Set options for connecting to the One Platform.

rpc.setOptions(\<options\>)
  • <options> contains one or more options to update. Default options are as follows:
{
  host: 'm2.exosite.com',
  path: '/api:v1/rpc/process',
  agent: 'node-onep',
  https: true,
  port: 443,
  strictSSL: true
}

You may also specify timeout in milliseconds, which defaults to the default for the request module.

Tests

$ cp test/config-template.js test/config.js
$ mocha

By default the tests run against the mock 1P server. To make them run against production 1P, modify test/config.js with a production CIK and turn off using the mock server.