Wrapper for calling Restful API
npm install wrapiwrapi
=====
Wrap Restful API endpoints as callable functions.
Create a Rest API SDK under 3 minutes.




With wrapi you make calls to HTTP based APIs just like ordinary JavaScript functions.
*
``sh`
$ npm install wrapi --save
Or
`sh`
$ yarn add wrapi
1. Create a JSON file listing all API endpoints you want to work with.
2. Wrap endpoints with wrapi.
3. Call individual endpoints as functions.
See Sample Code
------
`jsexpress
"function_name": {
"method": "HTTP_METHOD", // 'GET', 'POST', 'PUT', 'PATCH' or 'DELETE'
"path": "relative/path/to/:api/endpoint" // Use style path params`
}
E.g. a small set of github.com API:
`json
{
"repo": {
"method" : "GET",
"path" : "repos/:owner/:repo"
},
"contributors": {
"method" : "GET",
"path" : "repos/:owner/:repo/contributors"
},
"languages": {
"method" : "GET",
"path" : "repos/:owner/:repo/languages"
},
"tags": {
"method" : "GET",
"path" : "repos/:owner/:repo/tags"
},
"branches": {
"method" : "GET",
"path" : "repos/:owner/:repo/branches"
}
}
`
. Provide the base url for the API and the JSON object. will create a client object with all the necessary functions.`js
const endpoints = require('./github.api.json');
const wrapi = require('wrapi');
const client = new wrapi('https://api.github.com/', // base url for the API
endpoints // your json object
);
// client object contains functions to call the API
`
`js`
client.register('zen',
{
method : 'GET',
path: 'zen'
}
);
`js
// This will make GET request to 'https://api.github.com/repos/nodejs/node/contributors'
client.contributors('nodejs', 'node', function(err, contributors) {
if (!err) {
console.log(contributors);
}
});
client.zen(function(err, response) {
if (!err) {
console.log('Chris says "' + response + '"');
}
});
`
wrapi is an open ended framework. It is not restricted any specific or a set of APIs.
All APIs providing HTTP interface to access the endpoints can be wrapped by wrapi, so that you can quickly build your client application.
Note: method & path/url are required.
* method - Any one of the HTTP methods (default: "GET")path
* - route path to API Endpoint. Supports express style path paramsquery
* - an object consists of name-value pairs. This is _optional_. This is useful where resources are identified via query string parametersoptions
* - options to override or to add specific to the API endpoint. E.g. {encoding:null} returns the response data as Bufferurl
* - fully qualified uri string to override. This is useful in cases where an API call connects to a different endpoint
The wrapi object conveniently provides the client interface to the API. Create the object by calling new wrapi().
The constructor takes the following arguments:
1. baseURL - The base url for the API. E.g. https://api.github.com/endpoints
2. - The JSON object listing the API endpoints. Provide {} - empty object or a partial list and then register (additional) endpoints lateroptions
3. - Optional parameter. wrapi uses request module to connect to API server. The options parameter is the same options parameter used in request
#### Custom options
1. catchHTTP4xx5xx - Set this option to true to treat HTTP status 4xx & 5xx as errors. Default value is false. If set, the err argument in your callback function will contain the response body for 4xx & 5xx errors.
Add endpoints to client object.
``
register(functionName, endpointDefinition)
1. functionName - Alias for the endpoint, also the name of the function to call.endpointDefinition
2. - JSON object defining the endpoint.
Call API endpoints via the function in the client object. Arguments to the function depend on the API declaration in the JSON.
Provide the arguments in the following order:
1. named params in the url path of the endpoint. eg. client.contributors('nodejs', 'node', // nodejs & node are path paramsquery string
2. as an object with name-value pairs. eg. client.repositories({since:364} // ?since=364body
3. - JSON content for POST or PUT methods. Skip this argument if not required for the call.multipart/form-data
* To POST , set this argument as {"formData" : multipartContent }callback(err, data)
4. - a callback function for the results to be returned. The callback is called when the response is fetched or if there is an error. This callback function gets the results of the response.
> To pipe the results, pass a writable stream as the callback.error` events on outputstream to catch streaming errors. See example.
Listen to
In examples folder.
* Slack Web API
* Square Connect API
* Medium
* Twitter REST APIs
* Instagram API
* Genius API
* GIPHY API
* Riffsy's API
* Pokémon API