DTS API client

Installation

`npm i --save dts-api-client

Package can be consumed in Webpack and Node.js environments.

Webpack setup

If you need to use the upload client in a Webpack application, use the following configuration:

`
config.resolve = {
alias: {
'aws-sdk': 'aws-sdk/dist/aws-sdk.min.js'
}
};
`

Ignore the packages that you don't need completely to reduce the footprint:

`
config.plugins = [
new webpack.IgnorePlugin(/^(aws-sdk)$/), //If you don't use the upload client
new webpack.IgnorePlugin(/^(jquery)$/), //If you don't use the legacy client
new webpack.IgnorePlugin(/^(socketcluster-client)$/), //If you don't use the socket client
];
`

Configuration

If you don't use some of the clients (e.g. the upload client), set the related configuration section to a false key.

Not set configuration properties will use the default configuration.

`
import DtsApi from 'dts-api-client';

/ Application configuration /
const application = {
"client_id": "d04ad813dac443b28a490ddca27b9178",
"security": "oauth",
"redirect_uri": "https://web.snap.menu/"
};

/ Client configuration /
const client = new DtsApi.Client({
/ All client configs and keys are optional /

//API client configuration
api: {
host: 'api.managesnap.com',
secure: true,
path: '/frontend/',
application: application //Optional, defaults to { security: 'oauth' }
},

//Alternative API configuration (with Swagger object):
/*
api: {
spec: require('./swagger.json')
},
*/

//CDN client configuration
cdn: {
host: 'cdn.snap.menu',
secure: false,
path: '/',
application: application
},

//Socket client configuration
socket: {
host: 'socket.managesnap.com',
secure: true,
path: '/snap/',
application: application
},

//Partial configuration example:
//Legacy client configuration
legacy: {
host: 'api-jwt.managesnap.com'
//See? No secure or path here
},

//Exclude client example:
//Upload client configuration
upload: false
});

/ Manager configuration /
const manager = new DtsApi.Manager([
application
])
`

Usage Example

`
class Application {
constructor(mainApplication, client, manager) {
this._mainApplication = mainApplication;
this._client = client;
this._manager = manager;
}

//An OAuth callback is received (i.e. check current URL on application launch)
oauthCallback(application, data) {
//Create new token to save
let token = {
access_token: data.access_token,
refresh_token: data.refresh_token,
expires_in: data.expires_in
};

this._saveToken(token, application);
}

//Watch for API token events
watchAuthentication() {
this._manager.tokenExpiring.add((token, application) => this._refreshToken(token, application));
this._manager.tokenExpired.add((token, application) => this._refreshToken(token, application));
}

_refreshToken(token, application) {
return this.client.api.request('oauth2', 'grantToken', {
grant_type: 'refresh_token',
client_id: application.client_id,
refresh_token: token.refresh_token
})
.then(token => {
console.log('OAuth token refreshed', token);
this._saveToken(token, application);
})
.catch(e => {
console.error('Unable to refresh an OAuth token.', e);

if (this._manager.isAccessValid(application)) {
console.warn('Falling back to an existing OAuth token.');
return Promise.resolve();
}

return Promise.reject(e);
});
}

_saveToken(token, application) {
this._client.authorize(application, token);
this._manager.saveToken(application, token);
}

//Enable WebSocket connections and listen to client events
configureWebSocket() {
this._client.socket.isEnabled = true; //Explicitly indicate when you need a WebSocket connection

console.log('WebSocket is connected:', this._client.socket.isConnected);
this._client.socket.isConnectedChanged.add(isConnected => console.log('WebSocket is connected:', isConnected));
this._client.socket.onError.add(err => console.error('WebSocket error:', err));
}

//Restore authentication on application startup
startup() {
return this._manager.applications.reduce((promise, application) => {
let token = this._manager.getToken(application); //Read active token

//Check if refresh token has not expired
if (!this._manager.isAccessValid(application)) {
//No refresh token found
if (!token || !token.refresh_token) {
return promise;
}

return promise.then(() => {
console.log(Refreshing access for '${application.client_id}'...);

return this.refreshAccess(application)
.then(() => console.log(Access for '${application.client_id}' has been refreshed.))
.catch(e => {
console.warn(Unable to refresh access for '${application.client_id}', e);
return Promise.resolve();
});
});
}

// Optional: authenticate Raygun with the current API user
//
// if (application === this._mainApplication) {
// let metadata = this._manager.getTokenMetadata(token);
// Raygun.setUser(metadata.location, false, undefined, undefined, undefined, metadata.device);
// }

return promise.then(() => this._client.authorize(application, token));
}, Promise.resolve());
}

//Check if API token is valid
get isAccessValid() {
let token = this._manager.getToken(this._mainApplication);

if (!token || !token.refresh_token) {
return false;
}

return this._manager.isAccessValid(this._mainApplication);
}

//Get an OAuth authorization URL to redirect when an API token is not valid
authorize() {
return this._client.api.getAuthorizationUrl(this._mainApplication)
.then(url => window.location = url);
}

//Call API
loadLocationInfo(id) {
return this._client.api.request('asset', 'assetLocationRead', { token: id });
}

//Load data from CDN
loadData() {
return this._client.cdn.load('deployment/847429c4-bb61-40b5-b3fa-a4a50151030c/4a69171b-9b85-416f-af2e-71739ed865e2.json');
}

//Load data from CDN as a binary blob
loadBinary() {
return this._client.cdn.loadBinary('version/2b8cd287-d93c-455e-a1ef-a4b100f06550_470_410.jpg');
}

//Subscribe to a WebSocket topic
listenToTopic() {
this._client.socket.subscribe('location_847429c4-bb61-40b5-b3fa-a4a50151030c', message => {
console.log(message);
});
}

//Send a WebSocket message to a topic
publishToTopic(message) {
this._client.socket.publish('location_847429c4-bb61-40b5-b3fa-a4a50151030c', message);
}

//Send a WebSocket event
sendEvent(message) {
this._client.socket.emit('some_event', message);
}
}

``