This library is not bound to a specific method for transmitting data back and forth between your app and the queried server. Therefore you have to provide the facilities for this on your own. For all examples below, we use a WebSocket instance:
var jrpc = ;var Schema = jrpcSchema;var socket = 'ws://localhost/';
The main "meat" of the library. The
Schema constructor should be invoked with a JSON Schema object (not a JSON string). The second parameter should be a transmitter function, which takes a json string as its first argument and sends it to the server.
var schema = someSchema socketsend;
You will then have to pass your servers responses into the schemas
To handle any errors while e.g. parsing JSON, you can attach a handler to the schema object:
If no handler is attached, the error will be thrown.
true if the value is valid and
In addition, if the validators schema had any other schemas assigned to it as properties (this will be the case for almost all top-level json-schemas), it has a validator function for each of those sub-schemas assigned to it as a property (as functions are objects in js).
var schema ="type":"object""name":"type": "string""age" :"type": "integer""maximum": 125
var root = schema someTransmitter;//Returns true if `value` is an objectroot//Returns true if `value` is a stringrootschemanamevalue//Returns true if `value` is an integer larger then 125rootschema
If a json-schema describes a JSON-RPC method, we do not create a validator function. Instead we generate a wrapper for that method. This wrapper takes arguments either by order as an array, or as one object by name. The method will return a promise, which will be fulfilled with the methods return value once it becomes available.
var schema ="square":"type": "method""returns": "number""params":"type": "number""name": "square""required": true"minimum": 0"description": "Number to find the square root of""type": "number""name": "nth""default": 2"minimum": 2"description": "The degree of the root"
var root = schema someTransmitter;rootschema;//By orderrootschema
If you need to send multiple requests in a batch, you can use a batch object:
var root = schema transmitter;var batch = root;var res = batchschema;var res2 = batchschema;batch;
The batch object will have all the methods of the main schema. But they will all be queued until you call
.send() on the batch object.
The methods still return promises which will be resolved with the methods result.
JSON RPC notifications are treated similarly to methods.
var schema ="notify":"params":"name": "data""required": true"type": number"returns": null"type": "notification"
var root = schema someTransmitter;//May be called multiple timesrootschema;//Alternative without the need to have been defined in the schemarootnotifications
Call a single json-rpc method and return a Promise.
method should be the method name,
params should be a parameter object and the
transmitter should be a function which takes a json string as its only argument. This string should then be send to the server.
The returned Promise has a
.handle(json) which you should call with all of your servers responses. The promise will then be resolved with the correct value as soon as it is available.
//Run the requestvar playerInfo = jrpc;//Log the resultplayerInfo;//Ensure the library gets the servers datasocket;
As you can see, this is slightly convoluted and does not utilize json-schemas at all.
You should use an instance of
jrpc.Schema wherever possible.