hivetaxi-sdk
Version:
HiveTaxi SDK for JavaScript
1,965 lines (1,796 loc) • 440 kB
JavaScript
// HiveTaxi SDK for JavaScript v1.0.0
// Copyright HiveTaxi.com, Inc. or its affiliates. All Rights Reserved.
// License at https://sdk.hivetaxi.com/js/BUNDLE_LICENSE.txt
(function e(t,n,r){function s(o,u){if(!n[o]){if(!t[o]){var a=typeof require=="function"&&require;if(!u&&a)return a(o,!0);if(i)return i(o,!0);var f=new Error("Cannot find module '"+o+"'");throw f.code="MODULE_NOT_FOUND",f}var l=n[o]={exports:{}};t[o][0].call(l.exports,function(e){var n=t[o][1][e];return s(n?n:e)},l,l.exports,e,t,n,r)}return n[o].exports}var i=typeof require=="function"&&require;for(var o=0;o<r.length;o++)s(r[o]);return s})({1:[function(require,module,exports){
module.exports={
"version": "1.0",
"metadata": {
"apiVersion": "1.0",
"endpointPrefix": "cartography",
"protocol": "rest-json",
"serviceFullName": "HiveTaxi Cartographer Service",
"signatureVersion": "v1",
"targetPrefix": "Cartographer_1.0"
},
"operations": {
"ListPointTypes": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.0/address/points/types"
},
"output": {
"type": "list",
"member": {
"type": "structure",
"required": [
"id",
"value"
],
"members": {
"id": {},
"value": {}
}
}
},
"alias": "GetPointTypes"
},
"FindSettlements": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.0/address/settlements"
},
"input": {
"type": "structure",
"required": [
"pattern"
],
"members": {
"pattern": {
"location": "querystring"
}
}
},
"output": {
"shape": "S3"
}
},
"FindAddresses": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.0/address/addresses"
},
"input": {
"type": "structure",
"required": [
"pattern",
"parent"
],
"members": {
"pattern": {
"location": "querystring"
},
"parent": {
"type": "long",
"location": "querystring"
}
}
},
"output": {
"shape": "S3"
},
"alias": "FindStreets"
},
"GetAddressPoints": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.0/address/points"
},
"input": {
"type": "structure",
"required": [
"parent"
],
"members": {
"parent": {
"type": "long",
"location": "querystring"
}
}
},
"output": {
"type": "list",
"member": {
"type": "structure",
"required": [
"id",
"info",
"coordinates"
],
"members": {
"id": {
"type": "long"
},
"info": {
"type": "structure",
"members": {
"house": {},
"housing": {},
"building": {},
"lit": {}
}
},
"coordinates": {
"shape": "Sd"
}
}
}
}
},
"ListTimezones": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.0/timezones"
},
"output": {
"type": "list",
"member": {
"type": "structure",
"required": [
"id",
"value"
],
"members": {
"id": {
"type": "integer"
},
"value": {
"type": "string"
}
}
}
},
"alias": "GetTimezones"
},
"ListObjectLevels": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.0/address/objects/levels"
},
"output": {
"type": "list",
"member": {
"type": "structure",
"required": [
"id",
"name"
],
"members": {
"id": {},
"name": {}
}
}
},
"alias": "GetObjectLevels"
},
"FindObjects": {
"http": {
"method": "GET",
"requestUri": "/api/cartography/1.1/address/objects/find"
},
"input": {
"type": "structure",
"members": {
"id": {
"type": "integer",
"location": "querystring"
},
"existence": {
"type": "string",
"location": "querystring"
},
"formalName": {
"type": "string",
"location": "querystring"
},
"shortName": {
"type": "string",
"location": "querystring"
},
"levelIds": {
"type": "string",
"location": "querystring"
},
"guid": {
"type": "string",
"location": "querystring"
},
"parentGuid": {
"type": "string",
"location": "querystring"
},
"limit": {
"type": "integer",
"location": "querystring"
},
"offset": {
"type": "integer",
"location": "querystring"
},
"orderBy": {
"type": "string",
"location": "querystring"
}
}
},
"output": {
"type": "list",
"member": {
"type": "structure",
"required": [
"id",
"formalName",
"shortName",
"levelId",
"guid",
"removed"
],
"members": {
"id": {
"type": "integer"
},
"formalName": {
"type": "string"
},
"shortName": {
"type": "string"
},
"levelId": {
"type": "integer"
},
"guid": {
"type": "string"
},
"parentGuid": {
"type": "string"
},
"parentFormalName": {
"type": "string"
},
"parentShortName": {
"type": "string"
},
"parentLevelId": {
"type": "integer"
},
"timezoneId": {
"type": "integer"
},
"center": {
"shape": "Sd"
},
"removed": {
"type": "boolean"
}
}
}
},
"alias": "GetObjects"
},
"AddObject": {
"http": {
"requestUri": "/api/cartography/1.0/address/objects/add"
},
"input": {
"type": "structure",
"required": [
"formalName",
"levelId",
"shortName",
"parentGuid"
],
"members": {
"formalName": {},
"shortName": {},
"levelId": {
"type": "integer"
},
"parentGuid": {},
"timezoneId": {
"type": "integer"
},
"center": {
"shape": "Sd"
}
}
},
"output": {
"type": "structure",
"required": [
"id"
],
"members": {
"id": {
"type": "long"
}
}
},
"alias": "CreateObject"
},
"EditObject": {
"http": {
"requestUri": "/api/cartography/1.0/address/objects/edit"
},
"input": {
"type": "structure",
"required": [
"id",
"formalName",
"shortName",
"levelId",
"parentGuid"
],
"members": {
"id": {
"type": "long"
},
"formalName": {},
"shortName": {},
"levelId": {
"type": "integer"
},
"parentGuid": {},
"timezoneId": {
"type": "integer"
},
"center": {
"shape": "Sd"
}
}
},
"output": {},
"alias": "UpdateObject"
},
"MoveObjects": {
"http": {
"requestUri": "/api/cartography/1.0/address/objects/edit-parent"
},
"input": {
"type": "structure",
"required": [
"ids",
"parentGuid"
],
"members": {
"ids": {
"type": "list",
"member": {
"type": "long"
}
},
"parentGuid": {}
}
},
"output": {},
"alias": "ChangeParent"
},
"RemoveObjects": {
"http": {
"requestUri": "/api/cartography/1.0/address/objects/remove"
},
"input": {
"type": "structure",
"required": [
"ids"
],
"members": {
"ids": {
"type": "list",
"member": {
"type": "long"
}
}
}
},
"output": {},
"alias": "DeleteObjects"
},
"RestoreObjects": {
"http": {
"requestUri": "/api/cartography/1.0/address/objects/restore"
},
"input": {
"type": "structure",
"required": [
"ids"
],
"members": {
"ids": {
"type": "list",
"member": {
"type": "long"
}
}
}
},
"output": {},
"alias": "UndeleteObjects"
}
},
"shapes": {
"S3": {
"type": "list",
"member": {
"type": "structure",
"required": [
"levels"
],
"members": {
"levels": {
"type": "list",
"member": {
"type": "structure",
"members": {
"id": {
"type": "integer"
},
"type": {
"type": "integer"
},
"name": {},
"prefix": {}
}
}
},
"priority": {
"type": "integer"
},
"center": {
"type": "structure",
"required": [
"coordinates"
],
"members": {
"coordinates": {
"type": "list",
"member": {
"type": "float"
}
}
}
}
}
}
},
"Sd": {
"type": "structure",
"required": [
"lon",
"lat"
],
"members": {
"lon": {
"type": "float"
},
"lat": {
"type": "float"
}
}
}
},
"paginators": {},
"waiters": {}
}
},{}],2:[function(require,module,exports){
module.exports={
"version": "1.0",
"metadata": {
"apiVersion": "1.0",
"endpointPrefix": "client",
"protocol": "rest-json",
"serviceFullName": "HiveTaxi Client Service",
"signatureVersion": "v1"
},
"operations": {
"GetOrderStatus": {
"http": {
"method": "GET",
"requestUri": "/1.0/order/status"
},
"input": {
"type": "structure",
"required": [
"id"
],
"members": {
"id": {
"type": "integer"
}
}
},
"output": {
"type": "structure",
"required": [
"state"
],
"members": {
"state": {
"type": "integer"
},
"assignee": {
"share": "Assignee"
}
}
},
"alias": "orderStatus"
}
},
"shapes": {}
}
},{}],3:[function(require,module,exports){
module.exports={
"versiob": 2,
"waiters": {
"OrderAccepted": {
"delay": 5,
"operation": "GetOrderStatus",
"maxAttempts": 25,
"acceptors": [
{
"expected": 1,
"matcher": "path",
"state": "success",
"argument": "state"
},
{
"expected": "ResourceNotFoundException",
"matcher": "error",
"state": "retry"
}
]
},
"OrderAssigned": {
"delay": 20,
"operation": "GetOrderStatus",
"maxAttempts": 25,
"acceptors": [
{
"expected": 2,
"matcher": "path",
"state": "success",
"argument": "state"
},
{
"expected": "ResourceNotFoundException",
"matcher": "error",
"state": "retry"
}
]
},
"OrderWaiting": {
"delay": 15,
"operation": "GetOrderStatus",
"maxAttempts": 240,
"acceptors": [
{
"expected": 3,
"matcher": "path",
"state": "success",
"argument": "state"
},
{
"expected": "ResourceNotFoundException",
"matcher": "error",
"state": "retry"
}
]
},
"OrderCompleted": {
"delay": 20,
"operation": "GetOrderStatus",
"maxAttempts": 25,
"acceptors": [
{
"expected": 4,
"matcher": "path",
"state": "success",
"argument": "state"
},
{
"expected": "ResourceNotFoundException",
"matcher": "error",
"state": "retry"
}
]
},
"OrderExists": {
"delay": 5,
"operation": "GetOrderStatus",
"maxAttempts": 20,
"acceptors": [
{
"expected": 200,
"matcher": "status",
"state": "success"
},
{
"expected": 301,
"matcher": "status",
"state": "success"
},
{
"expected": 403,
"matcher": "status",
"state": "success"
},
{
"expected": 404,
"matcher": "status",
"state": "retry"
}
]
},
"OrderNotExists": {
"delay": 5,
"operation": "GetOrderStatus",
"maxAttempts": 20,
"acceptors": [
{
"expected": 404,
"matcher": "status",
"state": "success"
},
{
"expected": "ResourceNotFoundException",
"matcher": "error",
"state": "success"
}
]
}
}
}
},{}],4:[function(require,module,exports){
module.exports={
"version": "1.0",
"metadata": {
"apiVersion": "1.0",
"endpointPrefix": "contractor",
"protocol": "json-rpc",
"serviceFullName": "HiveTaxi Contractor Service",
"signatureVersion": "v1",
"targetPrefix": "Contractor"
},
"operations": {
"AddEmployeePhone": {
"http": {
"target": "Employees.addEmployeePhone",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId",
"phone"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"phone": {
"type": "string"
}
}
}
},
"RemoveEmployeePhone": {
"http": {
"target": "Employees.removeEmployeePhone",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId",
"phone"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"phone": {
"type": "string"
}
}
}
},
"GetGroups": {
"http": {
"target": "Contractor.getGroups",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"requestId": {
"type": "integer"
}
}
},
"output": {
"type": "structure",
"required": [
"result"
],
"members": {
"result": {
"type": "list",
"member": {
"type": "structure",
"required": [
"groupId",
"name",
"locked"
],
"members": {
"groupId": {
"type": "integer"
},
"name": {},
"locked": {
"type": "boolean"
}
}
}
}
}
}
},
"AddEmployee": {
"http": {
"target": "Employees.addEmployee",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"firstName",
"lastName"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"firstName": {},
"lastName": {},
"middleName": {},
"requestId": {
"type": "integer"
}
}
}
},
"EditEmployee": {
"http": {
"target": "Employees.editEmployee",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId",
"firstName",
"lastName"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"firstName": {},
"lastName": {},
"middleName": {},
"requestId": {
"type": "integer"
}
}
}
},
"GetEmployee": {
"http": {
"target": "Employees.getEmployee",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"requestId": {
"type": "integer"
}
}
},
"output": {
"type": "structure",
"required": [
"result"
],
"members": {
"result": {
"type": "structure",
"required": [
"groupId",
"employeeId",
"firstName",
"lastName",
"locked",
"phones"
],
"members": {
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"firstName": {},
"lastName": {},
"middleName": {},
"locked": {
"type": "boolean"
},
"phones": {
"type": "list",
"member": {
"type": "string"
}
}
}
}
}
}
},
"GetEmployees": {
"http": {
"target": "Employees.getEmployees",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"requestId": {
"type": "integer"
}
}
},
"output": {
"type": "structure",
"required": [
"result"
],
"members": {
"result": {
"type": "list",
"member": {
"type": "structure",
"required": [
"groupId",
"employeeId",
"firstName",
"lastName",
"locked"
],
"members": {
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"firstName": {},
"lastName": {},
"middleName": {},
"locked": {
"type": "boolean"
}
}
}
}
}
}
},
"LockEmployee": {
"http": {
"target": "Employees.lockEmployee",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"requestId": {
"type": "integer"
}
}
}
},
"RemoveEmployee": {
"http": {
"target": "Employees.removeEmployee",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"requestId": {
"type": "integer"
}
}
}
},
"UnlockEmployee": {
"http": {
"target": "Employees.unlockEmployee",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor",
"groupId",
"employeeId"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"groupId": {
"type": "integer"
},
"employeeId": {
"type": "integer"
},
"requestId": {
"type": "integer"
}
}
}
},
"GetUserInfo": {
"http": {
"target": "User.getInfo",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
},
"requestId": {
"type": "integer"
}
}
},
"output": {
"type": "structure",
"required": [
"result"
],
"members": {
"result": {
"type": "structure",
"required": [
"name"
],
"members": {
"name": {}
}
}
}
}
},
"GetAccountState": {
"http": {
"target": "Contractor.getAccountState",
"requestUri": "/api/contractors/{contractor}"
},
"input": {
"type": "structure",
"required": [
"contractor"
],
"members": {
"contractor": {
"type": "integer",
"location": "uri"
}
}
},
"output": {
"type": "structure",
"required": [
"result"
],
"members": {
"result": {
"type": "structure",
"required": [
"balance"
],
"members": {
"balance": {
"type": "float"
}
}
}
}
}
}
},
"shapes": {},
"paginators": {},
"waiters": {}
}
},{}],5:[function(require,module,exports){
module.exports={
"version": "1.0",
"metadata": {
"apiVersion": "1.0",
"endpointPrefix": "driver",
"protocol": "rest-json",
"serviceFullName": "HiveTaxi Driver Service",
"signatureVersion": "v1",
"targetPrefix": "Driver_1.0"
},
"operations": {
"ResubmitActivationCode": {
"http": {
"method": "GET",
"requestUri": "/1.0/driver/resubmit"
},
"input": {
"type": "structure",
"required": [
"id"
],
"members": {
"id": {
"type": "integer",
"location": "querystring",
"locationName": "id"
},
"confirmationType": {
"type": "string",
"location": "querystring",
"locationName": "confirmationType"
}
}
},
"output": {}
}
},
"shapes": {},
"waiters": {}
}
},{}],6:[function(require,module,exports){
require('../lib/node_loader');
var HiveTaxi = require('../lib/core');
module.exports = {
Cartographer: require('./cartographer'),
Client: require('./client'),
Driver: require('./driver'),
Contractor: require('./contractor')
};
},{"../lib/core":14,"../lib/node_loader":12,"./cartographer":7,"./client":8,"./contractor":9,"./driver":10}],7:[function(require,module,exports){
require('../lib/node_loader');
var HiveTaxi = require('../lib/core');
var Service = require('../lib/service');
var apiLoader = require('../lib/api_loader');
apiLoader.services['cartographer'] = {};
HiveTaxi.Cartographer = Service.defineService('cartographer', ['1.0']);
Object.defineProperty(apiLoader.services['cartographer'], '1.0', {
get: function get() {
var model = require('../apis/cartographer-1.0.min.json');
return model;
},
enumerable: true,
configurable: true
});
module.exports = HiveTaxi.Cartographer;
},{"../apis/cartographer-1.0.min.json":1,"../lib/api_loader":11,"../lib/core":14,"../lib/node_loader":12,"../lib/service":42}],8:[function(require,module,exports){
require('../lib/node_loader');
var HiveTaxi = require('../lib/core');
var Service = require('../lib/service');
var apiLoader = require('../lib/api_loader');
apiLoader.services['client'] = {};
HiveTaxi.Client = Service.defineService('client', ['1.0']);
Object.defineProperty(apiLoader.services['client'], '1.0', {
get: function get() {
var model = require('../apis/client-1.0.min.json');
model.waiters = require('../apis/client-1.0.waiters2.json').waiters;
return model;
},
enumerable: true,
configurable: true
});
module.exports = HiveTaxi.Client;
},{"../apis/client-1.0.min.json":2,"../apis/client-1.0.waiters2.json":3,"../lib/api_loader":11,"../lib/core":14,"../lib/node_loader":12,"../lib/service":42}],9:[function(require,module,exports){
require('../lib/node_loader');
var HiveTaxi = require('../lib/core');
var Service = require('../lib/service');
var apiLoader = require('../lib/api_loader');
apiLoader.services['contractor'] = {};
HiveTaxi.Contractor = Service.defineService('contractor', ['1.0']);
Object.defineProperty(apiLoader.services['contractor'], '1.0', {
get: function get() {
var model = require('../apis/contractor-1.0.min.json');
return model;
},
enumerable: true,
configurable: true
});
module.exports = HiveTaxi.Contractor;
},{"../apis/contractor-1.0.min.json":4,"../lib/api_loader":11,"../lib/core":14,"../lib/node_loader":12,"../lib/service":42}],10:[function(require,module,exports){
require('../lib/node_loader');
var HiveTaxi = require('../lib/core');
var Service = require('../lib/service');
var apiLoader = require('../lib/api_loader');
apiLoader.services['driver'] = {};
HiveTaxi.Driver = Service.defineService('driver', ['1.0']);
Object.defineProperty(apiLoader.services['driver'], '1.0', {
get: function get() {
var model = require('../apis/driver-1.0.min.json');
return model;
},
enumerable: true,
configurable: true
});
module.exports = HiveTaxi.Driver;
},{"../apis/driver-1.0.min.json":5,"../lib/api_loader":11,"../lib/core":14,"../lib/node_loader":12,"../lib/service":42}],11:[function(require,module,exports){
var HiveTaxi = require('./core');
HiveTaxi.apiLoader = function(svc, version) {
if (!HiveTaxi.apiLoader.services.hasOwnProperty(svc)) {
throw new Error('InvalidService: Failed to load api for ' + svc);
}
return HiveTaxi.apiLoader.services[svc][version];
};
HiveTaxi.apiLoader.services = {};
module.exports = HiveTaxi.apiLoader;
},{"./core":14}],12:[function(require,module,exports){
(function (process){
var util = require('./util');
util.crypto.lib = require('crypto-browserify');
util.Buffer = require('buffer/').Buffer;
util.url = require('url/');
util.querystring = require('querystring/');
var HiveTaxi = require('./core');
require('./api_loader');
HiveTaxi.XML.Parser = require('./xml/browser_parser');
require('./http/xhr');
if (typeof process === 'undefined') {
process = {
browser: true
};
}
}).call(this,require('_process'))
},{"./api_loader":11,"./core":14,"./http/xhr":19,"./util":48,"./xml/browser_parser":49,"_process":112,"buffer/":53,"crypto-browserify":55,"querystring/":119,"url/":120}],13:[function(require,module,exports){
var HiveTaxi = require('./core');
require('./credentials');
require('./credentials/credential_provider_chain');
var PromisesDependency;
HiveTaxi.Config = HiveTaxi.util.inherit({
constructor: function Config(options) {
if (options === undefined) options = {};
options = this.extractCredentials(options);
HiveTaxi.util.each.call(this, this.keys, function (key, value) {
this.set(key, options[key], value);
});
},
getCredentials: function getCredentials(callback) {
var self = this;
function finish(err) {
callback(err, err ? null : self.credentials);
}
function credError(msg, err) {
return new HiveTaxi.util.error(err || new Error(), {
code: 'CredentialsError', message: msg
});
}
function getAsyncCredentials() {
self.credentials.get(function(err) {
if (err) {
var msg = 'Could not load credentials from ' +
self.credentials.constructor.name;
err = credError(msg, err);
}
finish(err);
});
}
function getStaticCredentials() {
var err = null;
if (!self.credentials.accessKeyId || !self.credentials.secretAccessKey) {
err = credError('Missing credentials');
}
finish(err);
}
if (self.credentials) {
if (typeof self.credentials.get === 'function') {
getAsyncCredentials();
} else { // static credentials
getStaticCredentials();
}
} else if (self.credentialProvider) {
self.credentialProvider.resolve(function(err, creds) {
if (err) {
err = credError('Could not load credentials from any providers', err);
}
self.credentials = creds;
finish(err);
});
} else {
finish(credError('No credentials to load'));
}
},
update: function update(options, allowUnknownKeys) {
allowUnknownKeys = allowUnknownKeys || false;
options = this.extractCredentials(options);
HiveTaxi.util.each.call(this, options, function (key, value) {
if (allowUnknownKeys || Object.prototype.hasOwnProperty.call(this.keys, key) ||
HiveTaxi.Service.hasService(key)) {
this.set(key, value);
}
});
},
loadFromPath: function loadFromPath(path) {
this.clear();
var options = JSON.parse(HiveTaxi.util.readFileSync(path));
var fileSystemCreds = new HiveTaxi.FileSystemCredentials(path);
var chain = new HiveTaxi.CredentialProviderChain();
chain.providers.unshift(fileSystemCreds);
chain.resolve(function (err, creds) {
if (err) throw err;
else options.credentials = creds;
});
this.constructor(options);
return this;
},
clear: function clear() {
HiveTaxi.util.each.call(this, this.keys, function (key) {
delete this[key];
});
this.set('credentials', undefined);
this.set('credentialProvider', undefined);
},
set: function set(property, value, defaultValue) {
if (value === undefined) {
if (defaultValue === undefined) {
defaultValue = this.keys[property];
}
if (typeof defaultValue === 'function') {
this[property] = defaultValue.call(this);
} else {
this[property] = defaultValue;
}
} else if (property === 'httpOptions' && this[property]) {
this[property] = HiveTaxi.util.merge(this[property], value);
} else {
this[property] = value;
}
},
keys: {
credentials: null,
credentialProvider: null,
region: null,
logger: null,
apiVersions: {},
apiVersion: null,
endpoint: undefined,
httpOptions: {
timeout: 120000
},
maxRetries: undefined,
maxRedirects: 10,
paramValidation: true,
sslEnabled: true,
convertResponseTypes: true,
correctClockSkew: false,
customUserAgent: null,
systemClockOffset: 0,
signatureVersion: null,
signatureCache: true,
retryDelayOptions: {
base: 100
}
},
extractCredentials: function extractCredentials(options) {
if (options.accessKeyId && options.secretAccessKey) {
options = HiveTaxi.util.copy(options);
options.credentials = new HiveTaxi.Credentials(options);
}
return options;
},
setPromisesDependency: function setPromisesDependency(dep) {
PromisesDependency = dep;
var constructors = [HiveTaxi.Request, HiveTaxi.Credentials, HiveTaxi.CredentialProviderChain];
HiveTaxi.util.addPromises(constructors, dep);
},
getPromisesDependency: function getPromisesDependency() {
return PromisesDependency;
}
});
HiveTaxi.config = new HiveTaxi.Config();
},{"./core":14,"./credentials":15,"./credentials/credential_provider_chain":16}],14:[function(require,module,exports){
var HiveTaxi = { util: require('./util') };
var _hidden = {}; _hidden.toString(); // hack to parse macro
module.exports = HiveTaxi;
HiveTaxi.util.update(HiveTaxi, {
VERSION: '1.0.0',
Signers: {},
Protocol: {
Json: require('./protocol/json'),
Query: require('./protocol/query'),
Rest: require('./protocol/rest'),
RestJson: require('./protocol/rest_json'),
RestXml: require('./protocol/rest_xml'),
JsonRpc: require('./protocol/json_rpc')
},
XML: {
Builder: require('./xml/builder'),
Parser: null // conditionally set based on environment
},
JSON: {
Builder: require('./json/builder'),
Parser: require('./json/parser')
},
Model: {
Api: require('./model/api'),
Operation: require('./model/operation'),
Shape: require('./model/shape'),
Paginator: require('./model/paginator'),
ResourceWaiter: require('./model/resource_waiter')
},
util: require('./util'),
apiLoader: function() { throw new Error('No API loader set'); }
});
require('./service');
require('./credentials');
require('./credentials/credential_provider_chain');
require('./config');
require('./http');
require('./sequential_executor');
require('./event_listeners');
require('./request');
require('./response');
require('./resource_waiter');
require('./signers/request_signer');
require('./param_validator');
HiveTaxi.events = new HiveTaxi.SequentialExecutor();
},{"./config":13,"./credentials":15,"./credentials/credential_provider_chain":16,"./event_listeners":17,"./http":18,"./json/builder":20,"./json/parser":21,"./model/api":22,"./model/operation":24,"./model/paginator":25,"./model/resource_waiter":26,"./model/shape":27,"./param_validator":28,"./protocol/json":29,"./protocol/json_rpc":30,"./protocol/query":31,"./protocol/rest":32,"./protocol/rest_json":33,"./protocol/rest_xml":34,"./request":38,"./resource_waiter":39,"./response":40,"./sequential_executor":41,"./service":42,"./signers/request_signer":45,"./util":48,"./xml/builder":50}],15:[function(require,module,exports){
var HiveTaxi = require('./core');
HiveTaxi.Credentials = HiveTaxi.util.inherit({
constructor: function Credentials() {
HiveTaxi.util.hideProperties(this, ['secretAccessKey']);
this.expired = false;
this.expireTime = null;
if (arguments.length === 1 && typeof arguments[0] === 'object') {
var creds = arguments[0].credentials || arguments[0];
this.accessKeyId = creds.accessKeyId;
this.secretAccessKey = creds.secretAccessKey;
this.sessionToken = creds.sessionToken;
} else {
this.accessKeyId = arguments[0];
this.secretAccessKey = arguments[1];
this.sessionToken = arguments[2];
}
},
expiryWindow: 15,
needsRefresh: function needsRefresh() {
var currentTime = HiveTaxi.util.date.getDate().getTime();
var adjustedTime = new Date(currentTime + this.expiryWindow * 1000);
if (this.expireTime && adjustedTime > this.expireTime) {
return true;
} else {
return this.expired || !this.accessKeyId || !this.secretAccessKey;
}
},
get: function get(callback) {
var self = this;
if (this.needsRefresh()) {
this.refresh(function(err) {
if (!err) self.expired = false; // reset expired flag
if (callback) callback(err);
});
} else if (callback) {
callback();
}
},
refresh: function refresh(callback) {
this.expired = false;
callback();
}
});
HiveTaxi.Credentials.addPromisesToClass = function addPromisesToClass(PromiseDependency) {
this.prototype.getPromise = HiveTaxi.util.promisifyMethod('get', PromiseDependency);
this.prototype.refreshPromise = HiveTaxi.util.promisifyMethod('refresh', PromiseDependency);
};
HiveTaxi.Credentials.deletePromisesFromClass = function deletePromisesFromClass() {
delete this.prototype.getPromise;
delete this.prototype.refreshPromise;
};
HiveTaxi.util.addPromises(HiveTaxi.Credentials);
},{"./core":14}],16:[function(require,module,exports){
var HiveTaxi = require('../core');
HiveTaxi.CredentialProviderChain = HiveTaxi.util.inherit(HiveTaxi.Credentials, {
constructor: function CredentialProviderChain(providers) {
if (providers) {
this.providers = providers;
} else {
this.providers = HiveTaxi.CredentialProviderChain.defaultProviders.slice(0);
}
},
resolve: function resolve(callback) {
if (this.providers.length === 0) {
callback(new Error('No providers'));
return this;
}
var index = 0;
var providers = this.providers.slice(0);
function resolveNext(err, creds) {
if ((!err && creds) || index === providers.length) {
callback(err, creds);
return;
}
var provider = providers[index++];
if (typeof provider === 'function') {
creds = provider.call();
} else {
creds = provider;
}
if (creds.get) {
creds.get(function(getErr) {
resolveNext(getErr, getErr ? null : creds);
});
} else {
resolveNext(null, creds);
}
}
resolveNext();
return this;
}
});
HiveTaxi.CredentialProviderChain.defaultProviders = [];
HiveTaxi.CredentialProviderChain.addPromisesToClass = function addPromisesToClass(PromiseDependency) {
this.prototype.resolvePromise = HiveTaxi.util.promisifyMethod('resolve', PromiseDependency);
};
HiveTaxi.CredentialProviderChain.deletePromisesFromClass = function deletePromisesFromClass() {
delete this.prototype.resolvePromise;
};
HiveTaxi.util.addPromises(HiveTaxi.CredentialProviderChain);
},{"../core":14}],17:[function(require,module,exports){
var HiveTaxi = require('./core');
var SequentialExecutor = require('./sequential_executor');
HiveTaxi.EventListeners = {
Core: {} /* doc hack */
};
HiveTaxi.EventListeners = {
Core: new SequentialExecutor().addNamedListeners(function(add, addAsync) {
addAsync('VALIDATE_CREDENTIALS', 'validate',
function VALIDATE_CREDENTIALS(req, done) {
if (!req.service.api.signatureVersion) return done(); // none
req.service.config.getCredentials(function(err) {
if (err) {
req.response.error = HiveTaxi.util.error(err,
{code: 'CredentialsError', message: 'Missing credentials in config'});
}
done();
});
});
add('VALIDATE_REGION', 'validate', function VALIDATE_REGION(req) {
if (!req.service.config.region && !req.service.isGlobalEndpoint) {
req.response.error = HiveTaxi.util.error(new Error(),
{code: 'ConfigError', message: 'Missing region in config'});
}
});
add('VALIDATE_PARAMETERS', 'validate', function VALIDATE_PARAMETERS(req) {
var rules = req.service.api.operations[req.operation].input;
var validation = req.service.config.paramValidation;
new HiveTaxi.ParamValidator(validation).validate(rules, req.params);
});
addAsync('COMPUTE_SHA256', 'afterBuild', function COMPUTE_SHA256(req, done) {
req.haltHandlersOnError();
if (!req.service.api.signatureVersion) return done(); // none
if (req.service.getSignerClass(req) === HiveTaxi.Signers.V1) {
var body = req.httpRequest.body || '';
HiveTaxi.util.computeSha256(body, function(err, sha) {
if (err) {
done(err);
}
else {
req.httpRequest.headers['X-Hive-Content-Sha256'] = sha;
done();
}
});
} else {
done();
}
});
add('SET_CONTENT_LENGTH', 'afterBuild', function SET_CONTENT_LENGTH(req) {
if (req.httpRequest.headers['Content-Length'] === undefined) {
var length = HiveTaxi.util.string.byteLength(req.httpRequest.body);
req.httpRequest.headers['Content-Length'] = length;
}
});
add('SET_HTTP_HOST', 'afterBuild', function SET_HTTP_HOST(req) {
req.httpRequest.headers['Host'] = req.httpRequest.endpoint.host;
});
add('RESTART', 'restart', function RESTART() {
var err = this.response.error;
if (!err || !err.retryable) return;
this.httpRequest = new HiveTaxi.HttpRequest(
this.service.endpoint
);
if (this.response.retryCount < this.service.config.maxRetries) {
this.response.retryCount++;
} else {
this.response.error = null;
}
});
addAsync('SIGN', 'sign', function SIGN(req, done) {
var service = req.service;
if (!service.api.signatureVersion) return done(); // none
service.config.getCredentials(function (err, credentials) {
if (err) {
req.response.error = err;
return done();
}
try {
var date = HiveTaxi.util.date.getDate();
var SignerClass = service.getSignerClass(req);
var signer = new SignerClass(req.httpRequest,
service.api.signingName || service.api.endpointPrefix,
service.config.signatureCache);
signer.setServiceClientId(service._clientId);
delete req.httpRequest.headers['Authorization'];
delete req.httpRequest.headers['Date'];
delete req.httpRequest.headers['X-Hive-Date'];
signer.addAuthorization(credentials, date);
req.signedAt = date;
} catch (e) {
req.response.error = e;
}
done();
});
});
add('VALIDATE_RESPONSE', 'validateResponse', function VALIDATE_RESPONSE(resp) {
if (this.service.successfulResponse(resp, this)) {
resp.data = {};
resp.error = null;
} else {
resp.data = null;
resp.error = HiveTaxi.util.error(new Error(),
{code: 'UnknownError', message: 'An unknown error occurred.'});
}
});
addAsync('SEND', 'send', function SEND(resp, done) {
resp.httpResponse._abortCallback = done;
resp.error = null;
resp.data = null;
function callback(httpResp) {
resp.httpResponse.stream = httpResp;
httpResp.on('headers', function onHeaders(statusCode, headers) {
resp.request.emit('httpHeaders', [statusCode, headers, resp]);
if (!resp.httpResponse.streaming) {
if (HiveTaxi.HttpClient.streamsApiVersion === 2) { // streams2 API check
httpResp.on('readable', function onReadable() {
var data = httpResp.read();
if (data !== null) {
resp.request.emit('httpData', [data, resp]);
}
});
} else { // legacy streams API
httpResp.on('data', function onData(data) {
resp.request.emit('httpData', [data, resp]);
});
}
}
});
httpResp.on('end', function onEnd() {
resp.request.emit('httpDone');
done();
});
}
function progress(httpResp) {
httpResp.on('sendProgress', function onSendProgress(value) {
resp.request.emit('httpUploadProgress', [value, resp]);
});
httpResp.on('receiveProgress', function onReceiveProgress(value) {
resp.request.emit('httpDownloadProgress', [value, resp]);
});
}
function error(err) {
resp.error = HiveTaxi.util.error(err, {
code: 'NetworkingError',
region: resp.request.httpRequest.region,
hostname: resp.request.httpRequest.endpoint.hostname,
retryable: true
});
resp.request.emit('httpError', [resp.error, resp], function() {
done();
});
}
function executeSend() {
var http = HiveTaxi.HttpClient.getInstance();
var httpOptions = resp.request.service.config.httpOptions || {};
try {
var stream = http.handleRequest(resp.request.httpRequest, httpOptions,
callback, error);
progress(stream);
} catch (err) {
error(err);
}
}
var timeDiff = (HiveTaxi.util.date.getDate() - this.signedAt) / 1000;
if (timeDiff >= 60 * 10) { // if we signed 10min ago, re-sign
this.emit('sign', [this], function(err) {
if (err) done(err);
else executeSend();
});
} else {
executeSend();
}
});
add('HTTP_HEADERS', 'httpHeaders',
function HTTP_HEADERS(statusCode, headers, resp) {
resp.httpResponse.statusCode = statusCode;
resp.httpResponse.headers = headers;
resp.httpResponse.body = new HiveTaxi.util.Buffer('');
resp.httpResponse.buffers = [];
resp.httpResponse.numBytes = 0;
var dateHeader = headers.date || headers.Date;
if (dateHeader) {
var serverTime = Date.parse(dateHeader);
if (resp.request.service.config.correctClockSkew
&& HiveTaxi.util.isClockSkewed(serverTime)) {
HiveTaxi.util.applyClockOffset(serverTime);
}
}
});
add('HTTP_DATA', 'httpData', function HTTP_DATA(chunk, resp) {
if (chunk) {
if (HiveTaxi.util.isNode()) {
resp.httpResponse.numBytes += chunk.length;
var total = resp.httpResponse.headers['content-length'];
var progress = { loaded: resp.httpResponse.numBytes, total: total };
resp.request.emit('httpDownloadProgress', [progress, resp]);
}
resp.httpResponse.buffers.push(new HiveTaxi.util.Buffer(chunk));
}
});
add('HTTP_DONE', 'httpDone', function HTTP_DONE(resp) {
if (resp.httpResponse.buffers && resp.httpResponse.buffers.length > 0) {
var body = HiveTaxi.util.buffer.concat(resp.httpResponse.buffers);
resp.httpResponse.body = body;
}
delete resp.httpResponse.numBytes;
delete resp.httpResponse.buffers;
});
add('FINALIZE_ERROR', 'retry', function FINALIZE_ERROR(resp) {
if (resp.httpResponse.statusCode) {
resp.error.statusCode = resp.httpResponse.statusCode;
if (resp.error.retryable === undefined) {
resp.error.retryable = this.service.retryableError(resp.error, this);
}
}
});
add('INVALIDATE_CREDENTIALS', 'retry', function INVALIDATE_CREDENTIALS(resp) {
if (!resp.error) return;
switch (resp.error.code) {
case 'RequestExpired': // EC2 only
case 'ExpiredTokenException':
case 'ExpiredToken':
resp.error.retryable = true;
resp.request.service.config.credentials.expired = true;
}
});
add('EXPIRED_SIGNATURE', 'retry', function EXPIRED_SIGNATURE(resp) {
var err = resp.error;
if (!err) return;
if (typeof err.code === 'string' && typeof err.message === 'string') {
if (err.code.mat