Source: connection.js

  1. /*global Buffer */
  2. /**
  3.  * @file Connection class to keep the API session information and manage requests
  4.  * @author Shinichi Tomita <shinichi.tomita@gmail.com>
  5.  */
  7. 'use strict';
  9. var events  = require('events'),
  10.     inherits = require('inherits'),
  11.     _       = require('lodash/core'),
  12.     Promise = require('./promise'),
  13.     Logger  = require('./logger'),
  14.     OAuth2  = require('./oauth2'),
  15.     Query   = require('./query'),
  16.     SObject = require('./sobject'),
  17.     QuickAction = require('./quick-action'),
  18.     HttpApi = require('./http-api'),
  19.     Transport = require('./transport'),
  20.     Process = require('./process'),
  21.     Cache   = require('./cache');
  23. var defaults = {
  24.   loginUrl: "https://login.salesforce.com",
  25.   instanceUrl: "",
  26.   version: "36.0"
  27. };
  29. /**
  30.  * Connection class to keep the API session information and manage requests
  31.  *
  32.  * @constructor
  33.  * @extends events.EventEmitter
  34.  * @param {Object} [options] - Connection options
  35.  * @param {OAuth2|Object} [options.oauth2] - OAuth2 instance or options to be passed to OAuth2 constructor
  36.  * @param {String} [options.logLevel] - Output logging level (DEBUG|INFO|WARN|ERROR|FATAL)
  37.  * @param {String} [options.version] - Salesforce API Version (without "v" prefix)
  38.  * @param {Number} [options.maxRequest] - Max number of requests allowed in parallel call
  39.  * @param {String} [options.loginUrl] - Salesforce Login Server URL (e.g. https://login.salesforce.com/)
  40.  * @param {String} [options.instanceUrl] - Salesforce Instance URL (e.g. https://na1.salesforce.com/)
  41.  * @param {String} [options.serverUrl] - Salesforce SOAP service endpoint URL (e.g. https://na1.salesforce.com/services/Soap/u/28.0)
  42.  * @param {String} [options.accessToken] - Salesforce OAuth2 access token
  43.  * @param {String} [options.sessionId] - Salesforce session ID
  44.  * @param {String} [options.refreshToken] - Salesforce OAuth2 refresh token
  45.  * @param {String|Object} [options.signedRequest] - Salesforce Canvas signed request (Raw Base64 string, JSON string, or deserialized JSON)
  46.  * @param {String} [options.proxyUrl] - Cross-domain proxy server URL, used in browser client, non Visualforce app.
  47.  * @param {Object} [options.callOptions] - Call options used in each SOAP/REST API request. See manual.
  48.  */
  49. var Connection = module.exports = function(options) {
  50.   options = options || {};
  52.   this._logger = new Logger(options.logLevel);
  54.   var oauth2 = options.oauth2 || {
  55.     loginUrl : options.loginUrl,
  56.     clientId : options.clientId,
  57.     clientSecret : options.clientSecret,
  58.     redirectUri : options.redirectUri
  59.   };
  61.   /**
  62.    * OAuth2 object
  63.    * @member {OAuth2} Connection#oauth2
  64.    */
  65.   this.oauth2 = oauth2 = oauth2 instanceof OAuth2 ? oauth2 : new OAuth2(oauth2);
  67.   this.loginUrl = options.loginUrl || oauth2.loginUrl || defaults.loginUrl;
  68.   this.version = options.version || defaults.version;
  69.   this.maxRequest = options.maxRequest || this.maxRequest || 10;
  71.   /** @private */
  72.   this._transport =
  73.     options.proxyUrl ? new Transport.ProxyTransport(options.proxyUrl) : new Transport();
  75.   this.callOptions = options.callOptions;
  77.   /*
  78.    * Fire connection:new event to notify jsforce plugin modules
  79.    */
  80.   var jsforce = require('./core');
  81.   jsforce.emit('connection:new', this);
  83.   /**
  84.    * Streaming API object
  85.    * @member {Streaming} Connection#streaming
  86.    */
  87.   // this.streaming = new Streaming(this);
  88.   /**
  89.    * Bulk API object
  90.    * @member {Bulk} Connection#bulk
  91.    */
  92.   // this.bulk = new Bulk(this);
  93.   /**
  94.    * Tooling API object
  95.    * @member {Tooling} Connection#tooling
  96.    */
  97.   // this.tooling = new Tooling(this);
  98.   /**
  99.    * Analytics API object
  100.    * @member {Analytics} Connection#analytics
  101.    */
  102.   // this.analytics = new Analytics(this);
  103.   /**
  104.    * Chatter API object
  105.    * @member {Chatter} Connection#chatter
  106.    */
  107.   // this.chatter = new Chatter(this);
  108.   /**
  109.    * Metadata API object
  110.    * @member {Metadata} Connection#metadata
  111.    */
  112.   // this.metadata = new Metadata(this);
  114.   /**
  115.    * SOAP API object
  116.    * @member {SoapApi} Connection#soap
  117.    */
  118.   // this.soap = new SoapApi(this);
  120.   /**
  121.    * Apex REST API object
  122.    * @member {Apex} Connection#apex
  123.    */
  124.   // this.apex = new Apex(this);
  126.   /**
  127.    * @member {Process} Connection#process
  128.    */
  129.   this.process = new Process(this);
  131.   /**
  132.    * Cache object for result
  133.    * @member {Cache} Connection#cache
  134.    */
  135.   this.cache = new Cache();
  137.   // Allow to delegate connection refresh to outer function
  138.   var self = this;
  139.   var refreshFn = options.refreshFn;
  140.   if (!refreshFn && this.oauth2.clientId && this.oauth2.clientSecret) {
  141.     refreshFn = oauthRefreshFn;
  142.   }
  143.   if (refreshFn) {
  144.     this._refreshDelegate = new HttpApi.SessionRefreshDelegate(this, refreshFn);
  145.   }
  147.   var cacheOptions = {
  148.     key: function(type) { return type ? "describe." + type : "describe"; }
  149.   };
  150.   this.describe$ = this.cache.makeCacheable(this.describe, this, cacheOptions);
  151.   this.describe = this.cache.makeResponseCacheable(this.describe, this, cacheOptions);
  152.   this.describeSObject$ = this.describe$;
  153.   this.describeSObject = this.describe;
  155.   cacheOptions = { key: 'describeGlobal' };
  156.   this.describeGlobal$ = this.cache.makeCacheable(this.describeGlobal, this, cacheOptions);
  157.   this.describeGlobal = this.cache.makeResponseCacheable(this.describeGlobal, this, cacheOptions);
  159.   this.initialize(options);
  160. };
  162. inherits(Connection, events.EventEmitter);
  164. /**
  165.  * Initialize connection.
  166.  *
  167.  * @protected
  168.  * @param {Object} options - Initialization options
  169.  * @param {String} [options.instanceUrl] - Salesforce Instance URL (e.g. https://na1.salesforce.com/)
  170.  * @param {String} [options.serverUrl] - Salesforce SOAP service endpoint URL (e.g. https://na1.salesforce.com/services/Soap/u/28.0)
  171.  * @param {String} [options.accessToken] - Salesforce OAuth2 access token
  172.  * @param {String} [options.sessionId] - Salesforce session ID
  173.  * @param {String} [options.refreshToken] - Salesforce OAuth2 refresh token
  174.  * @param {String|Object} [options.signedRequest] - Salesforce Canvas signed request (Raw Base64 string, JSON string, or deserialized JSON)
  175.  * @param {UserInfo} [options.userInfo] - Logged in user information
  176.  */
  177. Connection.prototype.initialize = function(options) {
  178.   if (!options.instanceUrl && options.serverUrl) {
  179.     options.instanceUrl = options.serverUrl.split('/').slice(0, 3).join('/');
  180.   }
  181.   this.instanceUrl = options.instanceUrl || options.serverUrl || this.instanceUrl || defaults.instanceUrl;
  183.   this.accessToken = options.sessionId || options.accessToken || this.accessToken;
  184.   this.refreshToken = options.refreshToken || this.refreshToken;
  185.   if (this.refreshToken && !this._refreshDelegate) {
  186.     throw new Error("Refresh token is specified without oauth2 client information or refresh function");
  187.   }
  189.   this.signedRequest = options.signedRequest && parseSignedRequest(options.signedRequest);
  190.   if (this.signedRequest) {
  191.     this.accessToken = this.signedRequest.client.oauthToken;
  192.   }
  194.   if (options.userInfo) {
  195.     this.userInfo = options.userInfo;
  196.   }
  198.   this.limitInfo = {};
  200.   this.sobjects = {};
  201.   this.cache.clear();
  202.   this.cache.get('describeGlobal').on('value', _.bind(function(res) {
  203.     if (res.result) {
  204.       var types = _.map(res.result.sobjects, function(so) { return so.name; });
  205.       types.forEach(this.sobject, this);
  206.     }
  207.   }, this));
  209.   if (this.tooling) {
  210.     this.tooling.initialize();
  211.   }
  213.   this._sessionType = options.sessionId ? "soap" : "oauth2";
  215. };
  217. /** @private **/
  218. function oauthRefreshFn(conn, callback) {
  219.   conn.oauth2.refreshToken(conn.refreshToken, function(err, res) {
  220.     if (err) { return callback(err); }
  221.     var userInfo = parseIdUrl(res.id);
  222.     conn.initialize({
  223.       instanceUrl : res.instance_url,
  224.       accessToken : res.access_token,
  225.       userInfo : userInfo
  226.     });
  227.     callback(null, res.access_token, res);
  228.   });
  229. }
  231. /** @private **/
  232. function parseSignedRequest(sr) {
  233.   if (_.isString(sr)) {
  234.     if (sr[0] === '{') { // might be JSON
  235.       return JSON.parse(sr);
  236.     } else { // might be original base64-encoded signed request
  237.       var msg = sr.split('.').pop(); // retrieve latter part
  238.       var json = new Buffer(msg, 'base64').toString('utf-8');
  239.       return JSON.parse(json);
  240.     }
  241.     return null;
  242.   }
  243.   return sr;
  244. }
  247. /** @private **/
  248. Connection.prototype._baseUrl = function() {
  249.   return [ this.instanceUrl, "services/data", "v" + this.version ].join('/');
  250. };
  252. /**
  253.  * Convert path to absolute url
  254.  * @private
  255.  */
  256. Connection.prototype._normalizeUrl = function(url) {
  257.   if (url[0] === '/') {
  258.     if (url.indexOf('/services/') === 0) {
  259.       return this.instanceUrl + url;
  260.     } else {
  261.       return this._baseUrl() + url;
  262.     }
  263.   } else {
  264.     return url;
  265.   }
  266. };
  268. /**
  269.  * Send REST API request with given HTTP request info, with connected session information.
  270.  *
  271.  * Endpoint URL can be absolute URL ('https://na1.salesforce.com/services/data/v32.0/sobjects/Account/describe')
  272.  * , relative path from root ('/services/data/v32.0/sobjects/Account/describe')
  273.  * , or relative path from version root ('/sobjects/Account/describe').
  274.  *
  275.  * @param {String|Object} request - HTTP request object or URL to GET request
  276.  * @param {String} request.method - HTTP method URL to send HTTP request
  277.  * @param {String} request.url - URL to send HTTP request
  278.  * @param {Object} [request.headers] - HTTP request headers in hash object (key-value)
  279.  * @param {Object} [options] - HTTP API request options
  280.  * @param {Callback.<Object>} [callback] - Callback function
  281.  * @returns {Promise.<Object>}
  282.  */
  283. Connection.prototype.request = function(request, options, callback) {
  284.   if (typeof options === 'function') {
  285.     callback = options;
  286.     options = null;
  287.   }
  288.   options = options || {};
  289.   var self = this;
  291.   // if request is simple string, regard it as url in GET method
  292.   if (_.isString(request)) {
  293.     request = { method: 'GET', url: request };
  294.   }
  295.   // if url is given in relative path, prepend base url or instance url before.
  296.   request.url = this._normalizeUrl(request.url);
  298.   var httpApi = new HttpApi(this, options);
  300.   // log api usage and its quota
  301.   httpApi.on('response', function(response) {
  302.     if (response.headers && response.headers["sforce-limit-info"]) {
  303.       var apiUsage = response.headers["sforce-limit-info"].match(/api\-usage=(\d+)\/(\d+)/);
  304.       if (apiUsage) {
  305.         self.limitInfo = {
  306.           apiUsage: {
  307.             used: parseInt(apiUsage[1], 10),
  308.             limit: parseInt(apiUsage[2], 10)
  309.           }
  310.         };
  311.       }
  312.     }
  313.   });
  314.   return httpApi.request(request).thenCall(callback);
  315. };
  317. /**
  318.  * Send HTTP GET request
  319.  *
  320.  * Endpoint URL can be absolute URL ('https://na1.salesforce.com/services/data/v32.0/sobjects/Account/describe')
  321.  * , relative path from root ('/services/data/v32.0/sobjects/Account/describe')
  322.  * , or relative path from version root ('/sobjects/Account/describe').
  323.  *
  324.  * @param {String} url - Endpoint URL to request HTTP GET
  325.  * @param {Object} [options] - HTTP API request options
  326.  * @param {Callback.<Object>} [callback] - Callback function
  327.  * @returns {Promise.<Object>}
  328.  */
  329. Connection.prototype.requestGet = function(url, options, callback) {
  330.   var request = {
  331.     method: "GET",
  332.     url: url
  333.   };
  334.   return this.request(request, options, callback);
  335. };
  338. /**
  339.  * Send HTTP POST request with JSON body, with connected session information
  340.  *
  341.  * Endpoint URL can be absolute URL ('https://na1.salesforce.com/services/data/v32.0/sobjects/Account/describe')
  342.  * , relative path from root ('/services/data/v32.0/sobjects/Account/describe')
  343.  * , or relative path from version root ('/sobjects/Account/describe').
  344.  *
  345.  * @param {String} url - Endpoint URL to request HTTP POST
  346.  * @param {Object} body - Any JS object which can be serialized to JSON
  347.  * @param {Object} [options] - HTTP API request options
  348.  * @param {Callback.<Object>} [callback] - Callback function
  349.  * @returns {Promise.<Object>}
  350.  */
  351. Connection.prototype.requestPost = function(url, body, options, callback) {
  352.   var request = {
  353.     method: "POST",
  354.     url: url,
  355.     body: JSON.stringify(body),
  356.     headers: { "content-type": "application/json" }
  357.   };
  358.   return this.request(request, options, callback);
  359. };
  361. /**
  362.  * Send HTTP PUT request with JSON body, with connected session information
  363.  *
  364.  * Endpoint URL can be absolute URL ('https://na1.salesforce.com/services/data/v32.0/sobjects/Account/describe')
  365.  * , relative path from root ('/services/data/v32.0/sobjects/Account/describe')
  366.  * , or relative path from version root ('/sobjects/Account/describe').
  367.  *
  368.  * @param {String} url - Endpoint URL to request HTTP PUT
  369.  * @param {Object} body - Any JS object which can be serialized to JSON
  370.  * @param {Object} [options] - HTTP API request options
  371.  * @param {Callback.<Object>} [callback] - Callback function
  372.  * @returns {Promise.<Object>}
  373.  */
  374. Connection.prototype.requestPut = function(url, body, options, callback) {
  375.   var request = {
  376.     method: "PUT",
  377.     url: url,
  378.     body: JSON.stringify(body),
  379.     headers: { "content-type": "application/json" }
  380.   };
  381.   return this.request(request, options, callback);
  382. };
  384. /**
  385.  * Send HTTP PATCH request with JSON body
  386.  *
  387.  * Endpoint URL can be absolute URL ('https://na1.salesforce.com/services/data/v32.0/sobjects/Account/describe')
  388.  * , relative path from root ('/services/data/v32.0/sobjects/Account/describe')
  389.  * , or relative path from version root ('/sobjects/Account/describe').
  390.  *
  391.  * @param {String} url - Endpoint URL to request HTTP PATCH
  392.  * @param {Object} body - Any JS object which can be serialized to JSON
  393.  * @param {Object} [options] - HTTP API request options
  394.  * @param {Callback.<Object>} [callback] - Callback function
  395.  * @returns {Promise.<Object>}
  396.  */
  397. Connection.prototype.requestPatch = function(url, body, options, callback) {
  398.   var request = {
  399.     method: "PATCH",
  400.     url: url,
  401.     body: JSON.stringify(body),
  402.     headers: { "content-type": "application/json" }
  403.   };
  404.   return this.request(request, options, callback);
  405. };
  407. /**
  408.  * Send HTTP DELETE request
  409.  *
  410.  * Endpoint URL can be absolute URL ('https://na1.salesforce.com/services/data/v32.0/sobjects/Account/describe')
  411.  * , relative path from root ('/services/data/v32.0/sobjects/Account/describe')
  412.  * , or relative path from version root ('/sobjects/Account/describe').
  413.  *
  414.  * @param {String} url - Endpoint URL to request HTTP DELETE
  415.  * @param {Object} [options] - HTTP API request options
  416.  * @param {Callback.<Object>} [callback] - Callback function
  417.  * @returns {Promise.<Object>}
  418.  */
  419. Connection.prototype.requestDelete = function(url, options, callback) {
  420.   var request = {
  421.     method: "DELETE",
  422.     url: url
  423.   };
  424.   return this.request(request, options, callback);
  425. };
  428. /** @private */
  429. function formatDate(date) {
  430.   function pad(number) {
  431.     if (number < 10) {
  432.       return '0' + number;
  433.     }
  434.     return number;
  435.   }
  437.   return date.getUTCFullYear() +
  438.     '-' + pad(date.getUTCMonth() + 1) +
  439.     '-' + pad(date.getUTCDate()) +
  440.     'T' + pad(date.getUTCHours()) +
  441.     ':' + pad(date.getUTCMinutes()) +
  442.     ':' + pad(date.getUTCSeconds()) +
  443.     '+00:00';
  444. }
  447. /** @private **/
  448. function parseIdUrl(idUrl) {
  449.   var idUrls = idUrl.split("/");
  450.   var userId = idUrls.pop(), orgId = idUrls.pop();
  451.   return {
  452.     id: userId,
  453.     organizationId: orgId,
  454.     url: idUrl
  455.   };
  456. }
  458. /**
  459.  * @callback Callback
  460.  * @type {Function}
  461.  * @param {Error} err - Callback error
  462.  * @param {T} response - Callback response
  463.  * @template T
  464.  */
  466. /**
  467.  * @typedef {Object} QueryResult
  468.  * @prop {Boolean} done - Flag if the query is fetched all records or not
  469.  * @prop {String} [nextRecordsUrl] - URL locator for next record set, (available when done = false)
  470.  * @prop {Number} totalSize - Total size for query
  471.  * @prop {Array.<Record>} [records] - Array of records fetched
  472.  */
  474. /**
  475.  * Execute query by using SOQL
  476.  *
  477.  * @param {String} soql - SOQL string
  478.  * @param {Callback.<QueryResult>} [callback] - Callback function
  479.  * @returns {Query.<QueryResult>}
  480.  */
  481. Connection.prototype.query = function(soql, callback) {
  482.   var query = new Query(this, soql);
  483.   if (callback) {
  484.     query.run(callback);
  485.   }
  486.   return query;
  487. };
  489. /**
  490.  * Execute query by using SOQL, including deleted records
  491.  *
  492.  * @param {String} soql - SOQL string
  493.  * @param {Callback.<QueryResult>} [callback] - Callback function
  494.  * @returns {Query.<QueryResult>}
  495.  */
  496. Connection.prototype.queryAll = function(soql, callback) {
  497.   var query = new Query(this, soql);
  498.   query.scanAll(true);
  499.   if (callback) {
  500.     query.run(callback);
  501.   }
  502.   return query;
  503. };
  505. /**
  506.  * Query next record set by using query locator
  507.  *
  508.  * @param {String} locator - Next record set locator
  509.  * @param {Callback.<QueryResult>} [callback] - Callback function
  510.  * @returns {Query.<QueryResult>}
  511.  */
  512. Connection.prototype.queryMore = function(locator, callback) {
  513.   var query = new Query(this, null, locator);
  514.   if (callback) {
  515.     query.run(callback);
  516.   }
  517.   return query;
  518. };
  520. /**
  521.  * Retrieve specified records
  522.  *
  523.  * @param {String} type - SObject Type
  524.  * @param {String|Array.<String>} ids - A record ID or array of record IDs
  525.  * @param {Object} [options] - Options for rest api.
  526.  * @param {Callback.<Record|Array.<Record>>} [callback] - Callback function
  527.  * @returns {Promise.<Record|Array.<Record>>}
  528.  */
  529. Connection.prototype.retrieve = function(type, ids, options, callback) {
  530.   if (typeof options === 'function') {
  531.     callback = options;
  532.     options = {};
  533.   }
  534.   var self = this;
  535.   var isArray = _.isArray(ids);
  536.   ids = isArray ? ids : [ ids ];
  537.   if (ids.length > self.maxRequest) {
  538.     return Promise.reject(new Error("Exceeded max limit of concurrent call")).thenCall(callback);
  539.   }
  540.   return Promise.all(
  541.     _.map(ids, function(id) {
  542.       if (!id) { return Promise.reject(new Error('Invalid record ID. Specify valid record ID value')).thenCall(callback); }
  543.       var url = [ self._baseUrl(), "sobjects", type, id ].join('/');
  544.       return self.request(url);
  545.     })
  546.   ).then(function(results) {
  547.     return !isArray && _.isArray(results) ? results[0] : results;
  548.   }).thenCall(callback);
  549. };
  552. /**
  553.  * @typedef RecordResult
  554.  * @prop {Boolean} success - The result is succeessful or not
  555.  * @prop {String} [id] - Record ID
  556.  * @prop {Array.<String>} [errors] - Errors (available when success = false)
  557.  */
  559. /**
  560.  * Synonym of Connection#create()
  561.  *
  562.  * @method Connection#insert
  563.  * @param {String} type - SObject Type
  564.  * @param {Object|Array.<Object>} records - A record or array of records to create
  565.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function
  566.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  567.  */
  568. /**
  569.  * Create records
  570.  *
  571.  * @method Connection#create
  572.  * @param {String} type - SObject Type
  573.  * @param {Record|Array.<Record>} records - A record or array of records to create
  574.  * @param {Object} [options] - Options for rest api.
  575.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function
  576.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  577.  */
  578. Connection.prototype.insert =
  579. Connection.prototype.create = function(type, records, options, callback) {
  580.   if (!_.isString(type)) {
  581.     // reverse order
  582.     callback = options;
  583.     options = records;
  584.     records = type;
  585.     type = null;
  586.   }
  587.   if (typeof options === 'function') {
  588.     callback = options;
  589.     options = {};
  590.   }
  591.   options = options || {};
  592.   var self = this;
  593.   var isArray = _.isArray(records);
  594.   records = isArray ? records : [ records ];
  595.   if (records.length > self.maxRequest) {
  596.     return Promise.reject(new Error("Exceeded max limit of concurrent call")).thenCall(callback);
  597.   }
  598.   return Promise.all(
  599.     _.map(records, function(record) {
  600.       var sobjectType = type || (record.attributes && record.attributes.type) || record.type;
  601.       if (!sobjectType) {
  602.         throw new Error('No SObject Type defined in record');
  603.       }
  604.       record = _.clone(record);
  605.       delete record.Id;
  606.       delete record.type;
  607.       delete record.attributes;
  609.       var url = [ self._baseUrl(), "sobjects", sobjectType ].join('/');
  610.       return self.request({
  611.         method : 'POST',
  612.         url : url,
  613.         body : JSON.stringify(record),
  614.         headers : _.defaults(options.headers || {}, {
  615.           "Content-Type" : "application/json"
  616.         })
  617.       });
  618.     })
  619.   ).then(function(results) {
  620.     return !isArray && _.isArray(results) ? results[0] : results;
  621.   }).thenCall(callback);
  622. };
  624. /**
  625.  * Update records
  626.  *
  627.  * @param {String} type - SObject Type
  628.  * @param {Record|Array.<Record>} records - A record or array of records to update
  629.  * @param {Object} [options] - Options for rest api.
  630.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function
  631.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  632.  */
  633. Connection.prototype.update = function(type, records, options, callback) {
  634.   if (!_.isString(type)) {
  635.     // reverse order
  636.     callback = options;
  637.     options = records;
  638.     records = type;
  639.     type = null;
  640.   }
  641.   if (typeof options === 'function') {
  642.     callback = options;
  643.     options = {};
  644.   }
  645.   options = options || {};
  646.   var self = this;
  647.   var isArray = _.isArray(records);
  648.   records = isArray ? records : [ records ];
  649.   if (records.length > self.maxRequest) {
  650.     return Promise.reject(new Error("Exceeded max limit of concurrent call")).thenCall(callback);
  651.   }
  652.   return Promise.all(
  653.     _.map(records, function(record) {
  654.       var id = record.Id;
  655.       if (!id) {
  656.         throw new Error('Record id is not found in record.');
  657.       }
  658.       var sobjectType = type || (record.attributes && record.attributes.type) || record.type;
  659.       if (!sobjectType) {
  660.         throw new Error('No SObject Type defined in record');
  661.       }
  662.       record = _.clone(record);
  663.       delete record.Id;
  664.       delete record.type;
  665.       delete record.attributes;
  667.       var url = [ self._baseUrl(), "sobjects", sobjectType, id ].join('/');
  668.       return self.request({
  669.         method : 'PATCH',
  670.         url : url,
  671.         body : JSON.stringify(record),
  672.         headers : _.defaults(options.headers || {}, {
  673.           "Content-Type" : "application/json"
  674.         })
  675.       }, {
  676.         noContentResponse: { id : id, success : true, errors : [] }
  677.       });
  678.     })
  679.   ).then(function(results) {
  680.     return !isArray && _.isArray(results) ? results[0] : results;
  681.   }).thenCall(callback);
  682. };
  684. /**
  685.  * Upsert records
  686.  *
  687.  * @param {String} type - SObject Type
  688.  * @param {Record|Array.<Record>} records - Record or array of records to upsert
  689.  * @param {String} extIdField - External ID field name
  690.  * @param {Object} [options] - Options for rest api.
  691.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
  692.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  693.  */
  694. Connection.prototype.upsert = function(type, records, extIdField, options, callback) {
  695.   // You can omit "type" argument, when the record includes type information.
  696.   if (!_.isString(type)) {
  697.     // reverse order
  698.     callback = options;
  699.     options = extIdField;
  700.     extIdField = records;
  701.     records = type;
  702.     type = null;
  703.   }
  704.   if (typeof options === 'function') {
  705.     callback = options;
  706.     options = {};
  707.   }
  708.   options = options || {};
  709.   var self = this;
  710.   var isArray = _.isArray(records);
  711.   records = isArray ? records : [ records ];
  712.   if (records.length > self.maxRequest) {
  713.     return Promise.reject(new Error("Exceeded max limit of concurrent call")).thenCall(callback);
  714.   }
  715.   return Promise.all(
  716.     _.map(records, function(record) {
  717.       var sobjectType = type || (record.attributes && record.attributes.type) || record.type;
  718.       var extId = record[extIdField];
  719.       if (!extId) {
  720.         return Promise.reject(new Error('External ID is not defined in the record'));
  721.       }
  722.       record = _.clone(record);
  723.       delete record[extIdField];
  724.       delete record.type;
  725.       delete record.attributes;
  727.       var url = [ self._baseUrl(), "sobjects", sobjectType, extIdField, extId ].join('/');
  728.       return self.request({
  729.         method : 'PATCH',
  730.         url : url,
  731.         body : JSON.stringify(record),
  732.         headers : _.defaults(options.headers || {}, {
  733.           "Content-Type" : "application/json"
  734.         })
  735.       }, {
  736.         noContentResponse: { success : true, errors : [] }
  737.       });
  738.     })
  739.   ).then(function(results) {
  740.     return !isArray && _.isArray(results) ? results[0] : results;
  741.   }).thenCall(callback);
  742. };
  744. /**
  745.  * Synonym of Connection#destroy()
  746.  *
  747.  * @method Connection#delete
  748.  * @param {String} type - SObject Type
  749.  * @param {String|Array.<String>} ids - A ID or array of IDs to delete
  750.  * @param {Object} [options] - Options for rest api.
  751.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
  752.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  753.  */
  754. /**
  755.  * Synonym of Connection#destroy()
  756.  *
  757.  * @method Connection#del
  758.  * @param {String} type - SObject Type
  759.  * @param {String|Array.<String>} ids - A ID or array of IDs to delete
  760.  * @param {Object} [options] - Options for rest api.
  761.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
  762.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  763.  */
  764. /**
  765.  * Delete records
  766.  *
  767.  * @method Connection#destroy
  768.  * @param {String} type - SObject Type
  769.  * @param {String|Array.<String>} ids - A ID or array of IDs to delete
  770.  * @param {Object} [options] - Options for rest api.
  771.  * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
  772.  * @returns {Promise.<RecordResult|Array.<RecordResult>>}
  773.  */
  774. Connection.prototype["delete"] =
  775. Connection.prototype.del =
  776. Connection.prototype.destroy = function(type, ids, options, callback) {
  777.   if (typeof options === 'function') {
  778.     callback = options;
  779.     options = {};
  780.   }
  781.   options = options || {};
  782.   var self = this;
  783.   var isArray = _.isArray(ids);
  784.   ids = isArray ? ids : [ ids ];
  785.   if (ids.length > self.maxRequest) {
  786.     return Promise.reject(new Error("Exceeded max limit of concurrent call")).thenCall(callback);
  787.   }
  788.   return Promise.all(
  789.     _.map(ids, function(id) {
  790.       var url = [ self._baseUrl(), "sobjects", type, id ].join('/');
  791.       return self.request({
  792.         method : 'DELETE',
  793.         url : url,
  794.         headers: options.headers || null
  795.       }, {
  796.         noContentResponse: { id : id, success : true, errors : [] }
  797.       });
  798.     })
  799.   ).then(function(results) {
  800.     return !isArray && _.isArray(results) ? results[0] : results;
  801.   }).thenCall(callback);
  802. };
  804. /**
  805.  * Execute search by SOSL
  806.  *
  807.  * @param {String} sosl - SOSL string
  808.  * @param {Callback.<Array.<RecordResult>>} [callback] - Callback function
  809.  * @returns {Promise.<Array.<RecordResult>>}
  810.  */
  811. Connection.prototype.search = function(sosl, callback) {
  812.   var url = this._baseUrl() + "/search?q=" + encodeURIComponent(sosl);
  813.   return this.request(url).thenCall(callback);
  814. };
  816. /**
  817.  * Result returned by describeSObject call
  818.  *
  819.  * @typedef {Object} DescribeSObjectResult
  820.  */
  821. /**
  822.  * Synonym of Connection#describe()
  823.  *
  824.  * @method Connection#describeSObject
  825.  * @param {String} type - SObject Type
  826.  * @param {Callback.<DescribeSObjectResult>} [callback] - Callback function
  827.  * @returns {Promise.<DescribeSObjectResult>}
  828.  */
  829. /**
  830.  * Describe SObject metadata
  831.  *
  832.  * @method Connection#describe
  833.  * @param {String} type - SObject Type
  834.  * @param {Callback.<DescribeSObjectResult>} [callback] - Callback function
  835.  * @returns {Promise.<DescribeSObjectResult>}
  836.  */
  837. Connection.prototype.describe =
  838. Connection.prototype.describeSObject = function(type, callback) {
  839.   var url = [ this._baseUrl(), "sobjects", type, "describe" ].join('/');
  840.   return this.request(url).thenCall(callback);
  841. };
  844. /**
  845.  * Result returned by describeGlobal call
  846.  *
  847.  * @typedef {Object} DescribeGlobalResult
  848.  */
  849. /**
  850.  * Describe global SObjects
  851.  *
  852.  * @param {Callback.<DescribeGlobalResult>} [callback] - Callback function
  853.  * @returns {Promise.<DescribeGlobalResult>}
  854.  */
  855. Connection.prototype.describeGlobal = function(callback) {
  856.   var url = this._baseUrl() + "/sobjects";
  857.   return this.request(url).thenCall(callback);
  858. };
  861. /**
  862.  * Get SObject instance
  863.  *
  864.  * @param {String} type - SObject Type
  865.  * @returns {SObject}
  866.  */
  867. Connection.prototype.sobject = function(type) {
  868.   this.sobjects = this.sobjects || {};
  869.   var sobject = this.sobjects[type] =
  870.     this.sobjects[type] || new SObject(this, type);
  871.   return sobject;
  872. };
  874. /**
  875.  * Get identity information of current user
  876.  *
  877.  * @param {Callback.<IdentityInfo>} [callback] - Callback function
  878.  * @returns {Promise.<IdentityInfo>}
  879.  */
  880. Connection.prototype.identity = function(callback) {
  881.   var self = this;
  882.   var idUrl = this.userInfo && this.userInfo.url;
  883.   return Promise.resolve(
  884.     idUrl ?
  885.     { identity: idUrl } :
  886.     this.request(this._baseUrl())
  887.   ).then(function(res) {
  888.     var url = res.identity;
  889.     url += '?format=json&oauth_token=' + encodeURIComponent(self.accessToken);
  890.     return self.request(url, null, { jsonp : 'callback' });
  891.   }).then(function(res) {
  892.     self.userInfo = {
  893.       id: res.user_id,
  894.       organizationId: res.organization_id,
  895.       url: res.id
  896.     };
  897.     return res;
  898.   }).thenCall(callback);
  899. };
  901. /**
  902.  * @typedef UserInfo
  903.  * @prop {String} id - User ID
  904.  * @prop {String} organizationId - Organization ID
  905.  * @prop {String} url - Identity URL of the user
  906.  */
  908. /**
  909.  * Authorize (using oauth2 web server flow)
  910.  *
  911.  * @param {String} code - Authorization code
  912.  * @param {Callback.<UserInfo>} [callback] - Callback function
  913.  * @returns {Promise.<UserInfo>}
  914.  */
  915. Connection.prototype.authorize = function(code, callback) {
  916.   var self = this;
  917.   var logger = this._logger;
  919.   return this.oauth2.requestToken(code).then(function(res) {
  920.     logger.debug("OAuth2 token response = " + JSON.stringify(res));
  921.     var userInfo = parseIdUrl(res.id);
  922.     self.initialize({
  923.       instanceUrl : res.instance_url,
  924.       accessToken : res.access_token,
  925.       refreshToken : res.refresh_token,
  926.       userInfo: userInfo
  927.     });
  928.     logger.debug("<login> completed. user id = " + userInfo.id + ", org id = " + userInfo.organizationId);
  929.     return userInfo;
  931.   }).thenCall(callback);
  933. };
  936. /**
  937.  * Login to Salesforce
  938.  *
  939.  * @param {String} username - Salesforce username
  940.  * @param {String} password - Salesforce password (and security token, if required)
  941.  * @param {Callback.<UserInfo>} [callback] - Callback function
  942.  * @returns {Promise.<UserInfo>}
  943.  */
  944. Connection.prototype.login = function(username, password, callback) {
  945.   // register refreshDelegate for session expiration
  946.   this._refreshDelegate = new HttpApi.SessionRefreshDelegate(this, createUsernamePasswordRefreshFn(username, password));
  947.   if (this.oauth2 && this.oauth2.clientId && this.oauth2.clientSecret) {
  948.     return this.loginByOAuth2(username, password, callback);
  949.   } else {
  950.     return this.loginBySoap(username, password, callback);
  951.   }
  952. };
  954. /** @private **/
  955. function createUsernamePasswordRefreshFn(username, password) {
  956.   return function(conn, callback) {
  957.     conn.login(username, password, function(err) {
  958.       if (err) { return callback(err); }
  959.       callback(null, conn.accessToken);
  960.     });
  961.   };
  962. }
  964. /**
  965.  * Login by OAuth2 username & password flow
  966.  *
  967.  * @param {String} username - Salesforce username
  968.  * @param {String} password - Salesforce password (and security token, if required)
  969.  * @param {Callback.<UserInfo>} [callback] - Callback function
  970.  * @returns {Promise.<UserInfo>}
  971.  */
  972. Connection.prototype.loginByOAuth2 = function(username, password, callback) {
  973.   var self = this;
  974.   var logger = this._logger;
  975.   return this.oauth2.authenticate(username, password).then(function(res) {
  976.     logger.debug("OAuth2 token response = " + JSON.stringify(res));
  977.     var userInfo = parseIdUrl(res.id);
  978.     self.initialize({
  979.       instanceUrl : res.instance_url,
  980.       accessToken : res.access_token,
  981.       userInfo: userInfo
  982.     });
  983.     logger.debug("<login> completed. user id = " + userInfo.id + ", org id = " + userInfo.organizationId);
  984.     return userInfo;
  986.   }).thenCall(callback);
  988. };
  990. /**
  991.  * @private
  992.  */
  993. function esc(str) {
  994.   return str && String(str).replace(/&/g, '&amp;').replace(/</g, '&lt;')
  995.                            .replace(/>/g, '&gt;').replace(/"/g, '&quot;');
  996. }
  998. /**
  999.  * Login by SOAP web service API
  1000.  *
  1001.  * @param {String} username - Salesforce username
  1002.  * @param {String} password - Salesforce password (and security token, if required)
  1003.  * @param {Callback.<UserInfo>} [callback] - Callback function
  1004.  * @returns {Promise.<UserInfo>}
  1005.  */
  1006. Connection.prototype.loginBySoap = function(username, password, callback) {
  1007.   var self = this;
  1008.   var logger = this._logger;
  1009.   var body = [
  1010.     '<se:Envelope xmlns:se="http://schemas.xmlsoap.org/soap/envelope/">',
  1011.       '<se:Header/>',
  1012.       '<se:Body>',
  1013.         '<login xmlns="urn:partner.soap.sforce.com">',
  1014.           '<username>' + esc(username) + '</username>',
  1015.           '<password>' + esc(password) + '</password>',
  1016.         '</login>',
  1017.       '</se:Body>',
  1018.     '</se:Envelope>'
  1019.   ].join('');
  1021.   var soapLoginEndpoint = [ this.loginUrl, "services/Soap/u", this.version ].join('/');
  1023.   return this._transport.httpRequest({
  1024.     method : 'POST',
  1025.     url : soapLoginEndpoint,
  1026.     body : body,
  1027.     headers : {
  1028.       "Content-Type" : "text/xml",
  1029.       "SOAPAction" : '""'
  1030.     }
  1031.   }).then(function(response) {
  1032.     var m;
  1033.     if (response.statusCode >= 400) {
  1034.       m = response.body.match(/<faultstring>([^<]+)<\/faultstring>/);
  1035.       var faultstring = m && m[1];
  1036.       throw new Error(faultstring || response.body);
  1037.     }
  1038.     logger.debug("SOAP response = " + response.body);
  1039.     m = response.body.match(/<serverUrl>([^<]+)<\/serverUrl>/);
  1040.     var serverUrl = m && m[1];
  1041.     m = response.body.match(/<sessionId>([^<]+)<\/sessionId>/);
  1042.     var sessionId = m && m[1];
  1043.     m = response.body.match(/<userId>([^<]+)<\/userId>/);
  1044.     var userId = m && m[1];
  1045.     m = response.body.match(/<organizationId>([^<]+)<\/organizationId>/);
  1046.     var orgId = m && m[1];
  1047.     var idUrl = soapLoginEndpoint.split('/').slice(0, 3).join('/');
  1048.     idUrl += "/id/" + orgId + "/" + userId;
  1049.     var userInfo = {
  1050.       id: userId,
  1051.       organizationId: orgId,
  1052.       url: idUrl
  1053.     };
  1054.     self.initialize({
  1055.       serverUrl: serverUrl.split('/').slice(0, 3).join('/'),
  1056.       sessionId: sessionId,
  1057.       userInfo: userInfo
  1058.     });
  1059.     logger.debug("<login> completed. user id = " + userId + ", org id = " + orgId);
  1060.     return userInfo;
  1062.   }).thenCall(callback);
  1064. };
  1066. /**
  1067.  * Logout the current session
  1068.  *
  1069.  * @param {Callback.<undefined>} [callback] - Callback function
  1070.  * @returns {Promise.<undefined>}
  1071.  */
  1072. Connection.prototype.logout = function(callback) {
  1073.   if (this._sessionType === "oauth2") {
  1074.     return this.logoutByOAuth2(callback);
  1075.   } else {
  1076.     return this.logoutBySoap(callback);
  1077.   }
  1078. };
  1080. /**
  1081.  * Logout the current session by revoking access token via OAuth2 session revoke
  1082.  *
  1083.  * @param {Callback.<undefined>} [callback] - Callback function
  1084.  * @returns {Promise.<undefined>}
  1085.  */
  1086. Connection.prototype.logoutByOAuth2 = function(callback) {
  1087.   var self = this;
  1088.   var logger = this._logger;
  1090.   return this.oauth2.revokeToken(this.accessToken).then(function() {
  1091.     // Destroy the session bound to this connection
  1092.     self.accessToken = null;
  1093.     self.userInfo = null;
  1094.     self.refreshToken = null;
  1095.     self.instanceUrl = null;
  1096.     self.cache.clear();
  1098.     // nothing useful returned by logout API, just return
  1099.     return undefined;
  1100.   }).thenCall(callback);
  1101. };
  1104. /**
  1105.  * Logout the session by using SOAP web service API
  1106.  *
  1107.  * @param {Callback.<undefined>} [callback] - Callback function
  1108.  * @returns {Promise.<undefined>}
  1109.  */
  1110. Connection.prototype.logoutBySoap = function(callback) {
  1111.   var self = this;
  1112.   var logger = this._logger;
  1114.   var body = [
  1115.     '<se:Envelope xmlns:se="http://schemas.xmlsoap.org/soap/envelope/">',
  1116.       '<se:Header>',
  1117.         '<SessionHeader xmlns="urn:partner.soap.sforce.com">',
  1118.           '<sessionId>' + esc(this.accessToken) + '</sessionId>',
  1119.         '</SessionHeader>',
  1120.       '</se:Header>',
  1121.       '<se:Body>',
  1122.         '<logout xmlns="urn:partner.soap.sforce.com"/>',
  1123.       '</se:Body>',
  1124.     '</se:Envelope>'
  1125.   ].join('');
  1127.   return this._transport.httpRequest({
  1128.     method : 'POST',
  1129.     url : [ this.instanceUrl, "services/Soap/u", this.version ].join('/'),
  1130.     body : body,
  1131.     headers : {
  1132.       "Content-Type" : "text/xml",
  1133.       "SOAPAction" : '""'
  1134.     }
  1135.   }).then(function(response) {
  1136.     logger.debug("SOAP statusCode = " + response.statusCode + ", response = " + response.body);
  1137.     if (response.statusCode >= 400) {
  1138.       var m = response.body.match(/<faultstring>([^<]+)<\/faultstring>/);
  1139.       var faultstring = m && m[1];
  1140.       throw new Error(faultstring || response.body);
  1141.     }
  1143.     // Destroy the session bound to this connection
  1144.     self.accessToken = null;
  1145.     self.userInfo = null;
  1146.     self.refreshToken = null;
  1147.     self.instanceUrl = null;
  1148.     self.cache.clear();
  1150.     // nothing useful returned by logout API, just return
  1151.     return undefined;
  1153.   }).thenCall(callback);
  1154. };
  1156. /**
  1157.  * List recently viewed records
  1158.  *
  1159.  * @param {String} [type] - SObject type
  1160.  * @param {Number} [limit] - Limit num to fetch
  1161.  * @param {Callback.<Array.<RecordResult>>} [callback] - Callback function
  1162.  * @returns {Promise.<Array.<RecordResult>>}
  1163.  */
  1164. Connection.prototype.recent = function(type, limit, callback) {
  1165.   if (!_.isString(type)) {
  1166.     callback = limit;
  1167.     limit = type;
  1168.     type = undefined;
  1169.   }
  1170.   if (!_.isNumber(limit)) {
  1171.     callback = limit;
  1172.     limit = undefined;
  1173.   }
  1174.   var url;
  1175.   if (type) {
  1176.     url = [ this._baseUrl(), "sobjects", type ].join('/');
  1177.     return this.request(url).then(function(res) {
  1178.       return limit ? res.recentItems.slice(0, limit) : res.recentItems;
  1179.     }).thenCall(callback);
  1180.   } else {
  1181.     url = this._baseUrl() + "/recent";
  1182.     if (limit) {
  1183.       url += "?limit=" + limit;
  1184.     }
  1185.     return this.request(url).thenCall(callback);
  1186.   }
  1188. };
  1190. /**
  1191.  * @typedef {Object} UpdatedRecordsInfo
  1192.  * @prop {String} latestDateCovered - The timestamp of the last date covered.
  1193.  * @prop {Array.<String>} ids - Updated record IDs.
  1194.  */
  1196. /**
  1197.  * Retrieve updated records
  1198.  *
  1199.  * @param {String} type - SObject Type
  1200.  * @param {String|Date} start - start date or string representing the start of the interval
  1201.  * @param {String|Date} end - start date or string representing the end of the interval must be > start
  1202.  * @param {Callback.<UpdatedRecordsInfo>} [callback] - Callback function
  1203.  * @returns {Promise.<UpdatedRecordsInfo>}
  1204.  */
  1205. Connection.prototype.updated = function (type, start, end, callback) {
  1206.   var url = [ this._baseUrl(), "sobjects", type, "updated" ].join('/');
  1208.   if (typeof start === 'string') {
  1209.     start = new Date(start);
  1210.   }
  1212.   if (start instanceof Date) {
  1213.     start = formatDate(start);
  1214.   }
  1216.   if (start) {
  1217.     url += "?start=" + encodeURIComponent(start);
  1218.   }
  1220.   if (typeof end === 'string') {
  1221.     end = new Date(end);
  1222.   }
  1224.   if (end instanceof Date) {
  1225.     end = formatDate(end);
  1226.   }
  1228.   if (end) {
  1229.     url += "&end=" + encodeURIComponent(end);
  1230.   }
  1232.   return this.request(url).thenCall(callback);
  1233. };
  1235. /**
  1236.  * @typedef {Object} DeletedRecordsInfo
  1237.  * @prop {String} earliestDateAvailable - The timestamp of the earliest date available
  1238.  * @prop {String} latestDateCovered - The timestamp of the last date covered
  1239.  * @prop {Array.<Object>} deletedRecords - Updated records
  1240.  * @prop {String} deletedRecords.id - Record ID
  1241.  * @prop {String} deletedRecords.deletedDate - The timestamp when this record was deleted
  1242.  */
  1244. /**
  1245.  * Retrieve deleted records
  1246.  *
  1247.  * @param {String} type - SObject Type
  1248.  * @param {String|Date} start - start date or string representing the start of the interval
  1249.  * @param {String|Date} end - start date or string representing the end of the interval
  1250.  * @param {Callback.<DeletedRecordsInfo>} [callback] - Callback function
  1251.  * @returns {Promise.<DeletedRecordsInfo>}
  1252.  */
  1253. Connection.prototype.deleted = function (type, start, end, callback) {
  1254.   var url = [ this._baseUrl(), "sobjects", type, "deleted" ].join('/');
  1256.   if (typeof start === 'string') {
  1257.     start = new Date(start);
  1258.   }
  1260.   if (start instanceof Date) {
  1261.     start = formatDate(start);
  1262.   }
  1264.   if (start) {
  1265.     url += "?start=" + encodeURIComponent(start);
  1266.   }
  1268.   if (typeof end === 'string') {
  1269.     end = new Date(end);
  1270.   }
  1272.   if (end instanceof Date) {
  1273.     end = formatDate(end);
  1274.   }
  1276.   if (end) {
  1277.     url += "&end=" + encodeURIComponent(end);
  1278.   }
  1280.   return this.request(url).thenCall(callback);
  1281. };
  1284. /**
  1285.  * @typedef {Object} TabsInfo - See the API document for detail structure
  1286.  */
  1288. /**
  1289.  * Returns a list of all tabs
  1290.  *
  1291.  * @param {Callback.<TabsInfo>} [callback] - Callback function
  1292.  * @returns {Promise.<TabsInfo>}
  1293.  */
  1294. Connection.prototype.tabs = function(callback) {
  1295.   var url = [ this._baseUrl(), "tabs" ].join('/');
  1296.   return this.request(url).thenCall(callback);
  1297. };
  1300. /**
  1301.  * @typedef {Object} LimitsInfo - See the API document for detail structure
  1302.  */
  1304. /**
  1305.  * Returns curren system limit in the organization
  1306.  *
  1307.  * @param {Callback.<LimitsInfo>} [callback] - Callback function
  1308.  * @returns {Promise.<LimitsInfo>}
  1309.  */
  1310. Connection.prototype.limits = function(callback) {
  1311.   var url = [ this._baseUrl(), "limits" ].join('/');
  1312.   return this.request(url).thenCall(callback);
  1313. };
  1316. /**
  1317.  * @typedef {Object} ThemeInfo - See the API document for detail structure
  1318.  */
  1320. /**
  1321.  * Returns a theme info
  1322.  *
  1323.  * @param {Callback.<ThemeInfo>} [callback] - Callback function
  1324.  * @returns {Promise.<ThemeInfo>}
  1325.  */
  1326. Connection.prototype.theme = function(callback) {
  1327.   var url = [ this._baseUrl(), "theme" ].join('/');
  1328.   return this.request(url).thenCall(callback);
  1329. };
  1331. /**
  1332.  * Returns all registered global quick actions
  1333.  *
  1334.  * @param {Callback.<Array.<QuickAction~QuickActionInfo>>} [callback] - Callback function
  1335.  * @returns {Promise.<Array.<QuickAction~QuickActionInfo>>}
  1336.  */
  1337. Connection.prototype.quickActions = function(callback) {
  1338.   return this.request("/quickActions").thenCall(callback);
  1339. };
  1341. /**
  1342.  * Get reference for specified global quick aciton
  1343.  *
  1344.  * @param {String} actionName - Name of the global quick action
  1345.  * @returns {QuickAction}
  1346.  */
  1347. Connection.prototype.quickAction = function(actionName) {
  1348.   return new QuickAction(this, "/quickActions/" + actionName);
  1349. };