jsforce2/build/jsforce-api-tooling.js

Salesforce API Library for JavaScript

(function(f){if(typeof exports==="object"&&typeof module!=="undefined"){module.exports=f()}else if(typeof define==="function"&&define.amd){define([],f)}else{var g;if(typeof window!=="undefined"){g=window}else if(typeof global!=="undefined"){g=global}else if(typeof self!=="undefined"){g=self}else{g=this}g=(g.jsforce||(g.jsforce = {}));g=(g.modules||(g.modules = {}));g=(g.api||(g.api = {}));g.Tooling = f()}})(function(){var define,module,exports;return (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
/**
 * @file Manages Tooling APIs
 * @author Shinichi Tomita <shinichi.tomita@gmail.com>
 */

'use strict';

var jsforce = window.jsforce.require('./core'),
    _     = window.jsforce.require('lodash/core'),
    Cache = window.jsforce.require('./cache');

/**
 * API class for Tooling API call
 *
 * @class
 * @param {Connection} conn - Connection
 */
var Tooling = function(conn) {
  this._conn = conn;
  this._logger = conn._logger;
  var delegates = [
    "query",
    "queryMore",
    "_toRecordResult",
    "create",
    "_createSingle",
    "_createParallel",
    "_createMany",
    "insert",
    "retrieve",
    "_retrieveSingle",
    "_retrieveParallel",
    "_retrieveMany",
    "update",
    "_updateSingle",
    "_updateParallel",
    "_updateMany",
    "upsert",
    "del",
    "delete",
    "destroy",
    "_destroySingle",
    "_destroyParallel",
    "_destroyMany",
    "describe",
    "describeGlobal",
    "sobject"
  ];
  delegates.forEach(function(method) {
    this[method] = conn.constructor.prototype[method];
  }, this);

  this.cache = new Cache();

  var cacheOptions = {
    key: function(type) { return type ? "describe." + type : "describe"; }
  };
  this.describe$ = this.cache.makeCacheable(this.describe, this, cacheOptions);
  this.describe = this.cache.makeResponseCacheable(this.describe, this, cacheOptions);
  this.describeSObject$ = this.describe$;
  this.describeSObject = this.describe;

  cacheOptions = { key: 'describeGlobal' };
  this.describeGlobal$ = this.cache.makeCacheable(this.describeGlobal, this, cacheOptions);
  this.describeGlobal = this.cache.makeResponseCacheable(this.describeGlobal, this, cacheOptions);

  this.initialize();
};

/**
 * Initialize tooling API
 * @protected
 */
Tooling.prototype.initialize = function() {
  this.sobjects = {};
  this.cache.clear();
  this.cache.get('describeGlobal').removeAllListeners('value');
  this.cache.get('describeGlobal').on('value', _.bind(function(res) {
    if (res.result) {
      var types = _.map(res.result.sobjects, function(so) { return so.name; });
      types.forEach(this.sobject, this);
    }
  }, this));
};

/**
 * @private
 */
Tooling.prototype._baseUrl = function() {
  return this._conn._baseUrl() + "/tooling";
};

/**
 * @private
 */
Tooling.prototype._supports = function(feature) {
  // should return false in order not to use compsite collection
  if (feature === 'sobject-collection') {
    return false;
  }
  return this._conn._supports.apply(this._conn, arguments);
};

/**
 * @private
 */
Tooling.prototype.request = function() {
  return this._conn.request.apply(this._conn, arguments);
};

/**
 * Execute query by using SOQL
 *
 * @param {String} soql - SOQL string
 * @param {Callback.<QueryResult>} [callback] - Callback function
 * @returns {Query.<QueryResult>}
 */
/**
 * Query next record set by using query locator
 *
 * @method Tooling#query
 * @param {String} locator - Next record set locator
 * @param {Callback.<QueryResult>} [callback] - Callback function
 * @returns {Query.<QueryResult>}
 */
/**
 * Retrieve specified records
 *
 * @method Tooling#queryMore
 * @param {String} type - SObject Type
 * @param {String|Array.<String>} ids - A record ID or array of record IDs
 * @param {Callback.<Record|Array.<Record>>} [callback] - Callback function
 * @returns {Promise.<Record|Array.<Record>>}
 */

/**
 * Synonym of Tooling#create()
 *
 * @method Tooling#insert
 * @param {String} type - SObject Type
 * @param {Object|Array.<Object>} records - A record or array of records to create
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */
/**
 * Create records
 *
 * @method Tooling#create
 * @param {String} type - SObject Type
 * @param {Record|Array.<Record>} records - A record or array of records to create
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */

/**
 * Update records
 *
 * @method Tooling#update
 * @param {String} type - SObject Type
 * @param {Record|Array.<Record>} records - A record or array of records to update
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */

/**
 * Upsert records
 *
 * @method Tooling#upsert
 * @param {String} type - SObject Type
 * @param {Record|Array.<Record>} records - Record or array of records to upsert
 * @param {String} extIdField - External ID field name
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */

/**
 * Synonym of Tooling#destroy()
 *
 * @method Tooling#delete
 * @param {String} type - SObject Type
 * @param {String|Array.<String>} ids - A ID or array of IDs to delete
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */
/**
 * Synonym of Tooling#destroy()
 *
 * @method Tooling#del
 * @param {String} type - SObject Type
 * @param {String|Array.<String>} ids - A ID or array of IDs to delete
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */
/**
 * Delete records
 *
 * @method Tooling#destroy
 * @param {String} type - SObject Type
 * @param {String|Array.<String>} ids - A ID or array of IDs to delete
 * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback
 * @returns {Promise.<RecordResult|Array.<RecordResult>>}
 */

/**
 * Synonym of Tooling#describe()
 *
 * @method Tooling#describeSObject
 * @param {String} type - SObject Type
 * @param {Callback.<DescribeSObjectResult>} [callback] - Callback function
 * @returns {Promise.<DescribeSObjectResult>}
 */
/**
 * Describe SObject metadata
 *
 * @method Tooling#describe
 * @param {String} type - SObject Type
 * @param {Callback.<DescribeSObjectResult>} [callback] - Callback function
 * @returns {Promise.<DescribeSObjectResult>}
 */

/**
 * Describe global SObjects
 *
 * @method Tooling#describeGlobal
 * @param {Callback.<DescribeGlobalResult>} [callback] - Callback function
 * @returns {Promise.<DescribeGlobalResult>}
 */

/**
 * Get SObject instance
 *
 * @method Tooling#sobject
 * @param {String} type - SObject Type
 * @returns {SObject}
 */

/**
 * @typedef {Object} Tooling~ExecuteAnonymousResult
 * @prop {Boolean} compiled - Flag if the query is compiled successfully
 * @prop {String} compileProblem - Error reason in compilation
 * @prop {Boolean} success - Flag if the code is executed successfully
 * @prop {Number} line - Line number for the error
 * @prop {Number} column - Column number for the error
 * @prop {String} exceptionMessage - Exception message
 * @prop {String} exceptionStackTrace - Exception stack trace
 */
/**
 * Executes Apex code anonymously
 *
 * @param {String} body - Anonymous Apex code
 * @param {Callback.<Tooling~ExecuteAnonymousResult>} [callback] - Callback function
 * @returns {Promise.<Tooling~ExecuteAnonymousResult>}
 */
Tooling.prototype.executeAnonymous = function(body, callback) {
  var url = this._baseUrl() + "/executeAnonymous?anonymousBody=" + encodeURIComponent(body);
  return this.request(url).thenCall(callback);
};

/**
 * Executes Apex tests asynchronously
 *
 * @param {Array.<String>} classids - Comma separated list of class IDs
 * @param {Callback.<Tooling~ExecuteAnonymousResult>} [callback] - Callback function
 * @returns {Promise.<Tooling~ExecuteAnonymousResult>}
 */
Tooling.prototype.runTestsAsynchronous = function(classids, callback) {
  var url = this._baseUrl() + "/runTestsAsynchronous/";
  return this._conn.requestPost(url, {classids : classids.join(',')}, undefined, callback);
};

/**
 * Executes Apex tests synchronously
 *
 * @param {Array.<String>} classnames - Comma separated list of class Names
 * @param {Callback.<Tooling~ExecuteAnonymousResult>} [callback] - Callback function
 * @returns {Promise.<Tooling~ExecuteAnonymousResult>}
 */
Tooling.prototype.runTestsSynchronous = function(classnames, callback) {
  var url = this._baseUrl() + "/runTestsSynchronous/";
  return this._conn.requestPost(url, {classnames : classnames.join(',')}, undefined, callback);
};

/**
 * @typedef {Object} Tooling~CompletionsResult
 * @prop {Object} publicDeclarations
 */
/**
 * Retrieves available code completions of the referenced type
 *
 * @param {String} [type] - completion type (default 'apex')
 * @param {Callback.<Tooling~CompletionsResult>} [callback] - Callback function
 * @returns {Promise.<Tooling~CompletionsResult>}
 */
Tooling.prototype.completions = function(type, callback) {
  if (!_.isString(type)) {
    callback = type;
    type = 'apex';
  }
  var url = this._baseUrl() + "/completions?type=" + encodeURIComponent(type);
  return this.request(url).thenCall(callback);
};


/*--------------------------------------------*/
/*
 * Register hook in connection instantiation for dynamically adding this API module features
 */
jsforce.on('connection:new', function(conn) {
  conn.tooling = new Tooling(conn);
});


module.exports = Tooling;

},{}]},{},[1])(1)
});

//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["node_modules/browser-pack/_prelude.js","lib/api/tooling.js"],"names":[],"mappings":"AAAA;ACAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA","file":"generated.js","sourceRoot":"","sourcesContent":["(function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c=\"function\"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error(\"Cannot find module '\"+i+\"'\");throw a.code=\"MODULE_NOT_FOUND\",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u=\"function\"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()","/**\n * @file Manages Tooling APIs\n * @author Shinichi Tomita <shinichi.tomita@gmail.com>\n */\n\n'use strict';\n\nvar jsforce = window.jsforce.require('./core'),\n    _     = window.jsforce.require('lodash/core'),\n    Cache = window.jsforce.require('./cache');\n\n/**\n * API class for Tooling API call\n *\n * @class\n * @param {Connection} conn - Connection\n */\nvar Tooling = function(conn) {\n  this._conn = conn;\n  this._logger = conn._logger;\n  var delegates = [\n    \"query\",\n    \"queryMore\",\n    \"_toRecordResult\",\n    \"create\",\n    \"_createSingle\",\n    \"_createParallel\",\n    \"_createMany\",\n    \"insert\",\n    \"retrieve\",\n    \"_retrieveSingle\",\n    \"_retrieveParallel\",\n    \"_retrieveMany\",\n    \"update\",\n    \"_updateSingle\",\n    \"_updateParallel\",\n    \"_updateMany\",\n    \"upsert\",\n    \"del\",\n    \"delete\",\n    \"destroy\",\n    \"_destroySingle\",\n    \"_destroyParallel\",\n    \"_destroyMany\",\n    \"describe\",\n    \"describeGlobal\",\n    \"sobject\"\n  ];\n  delegates.forEach(function(method) {\n    this[method] = conn.constructor.prototype[method];\n  }, this);\n\n  this.cache = new Cache();\n\n  var cacheOptions = {\n    key: function(type) { return type ? \"describe.\" + type : \"describe\"; }\n  };\n  this.describe$ = this.cache.makeCacheable(this.describe, this, cacheOptions);\n  this.describe = this.cache.makeResponseCacheable(this.describe, this, cacheOptions);\n  this.describeSObject$ = this.describe$;\n  this.describeSObject = this.describe;\n\n  cacheOptions = { key: 'describeGlobal' };\n  this.describeGlobal$ = this.cache.makeCacheable(this.describeGlobal, this, cacheOptions);\n  this.describeGlobal = this.cache.makeResponseCacheable(this.describeGlobal, this, cacheOptions);\n\n  this.initialize();\n};\n\n/**\n * Initialize tooling API\n * @protected\n */\nTooling.prototype.initialize = function() {\n  this.sobjects = {};\n  this.cache.clear();\n  this.cache.get('describeGlobal').removeAllListeners('value');\n  this.cache.get('describeGlobal').on('value', _.bind(function(res) {\n    if (res.result) {\n      var types = _.map(res.result.sobjects, function(so) { return so.name; });\n      types.forEach(this.sobject, this);\n    }\n  }, this));\n};\n\n/**\n * @private\n */\nTooling.prototype._baseUrl = function() {\n  return this._conn._baseUrl() + \"/tooling\";\n};\n\n/**\n * @private\n */\nTooling.prototype._supports = function(feature) {\n  // should return false in order not to use compsite collection\n  if (feature === 'sobject-collection') {\n    return false;\n  }\n  return this._conn._supports.apply(this._conn, arguments);\n};\n\n/**\n * @private\n */\nTooling.prototype.request = function() {\n  return this._conn.request.apply(this._conn, arguments);\n};\n\n/**\n * Execute query by using SOQL\n *\n * @param {String} soql - SOQL string\n * @param {Callback.<QueryResult>} [callback] - Callback function\n * @returns {Query.<QueryResult>}\n */\n/**\n * Query next record set by using query locator\n *\n * @method Tooling#query\n * @param {String} locator - Next record set locator\n * @param {Callback.<QueryResult>} [callback] - Callback function\n * @returns {Query.<QueryResult>}\n */\n/**\n * Retrieve specified records\n *\n * @method Tooling#queryMore\n * @param {String} type - SObject Type\n * @param {String|Array.<String>} ids - A record ID or array of record IDs\n * @param {Callback.<Record|Array.<Record>>} [callback] - Callback function\n * @returns {Promise.<Record|Array.<Record>>}\n */\n\n/**\n * Synonym of Tooling#create()\n *\n * @method Tooling#insert\n * @param {String} type - SObject Type\n * @param {Object|Array.<Object>} records - A record or array of records to create\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n/**\n * Create records\n *\n * @method Tooling#create\n * @param {String} type - SObject Type\n * @param {Record|Array.<Record>} records - A record or array of records to create\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n\n/**\n * Update records\n *\n * @method Tooling#update\n * @param {String} type - SObject Type\n * @param {Record|Array.<Record>} records - A record or array of records to update\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback function\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n\n/**\n * Upsert records\n *\n * @method Tooling#upsert\n * @param {String} type - SObject Type\n * @param {Record|Array.<Record>} records - Record or array of records to upsert\n * @param {String} extIdField - External ID field name\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n\n/**\n * Synonym of Tooling#destroy()\n *\n * @method Tooling#delete\n * @param {String} type - SObject Type\n * @param {String|Array.<String>} ids - A ID or array of IDs to delete\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n/**\n * Synonym of Tooling#destroy()\n *\n * @method Tooling#del\n * @param {String} type - SObject Type\n * @param {String|Array.<String>} ids - A ID or array of IDs to delete\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n/**\n * Delete records\n *\n * @method Tooling#destroy\n * @param {String} type - SObject Type\n * @param {String|Array.<String>} ids - A ID or array of IDs to delete\n * @param {Callback.<RecordResult|Array.<RecordResult>>} [callback] - Callback\n * @returns {Promise.<RecordResult|Array.<RecordResult>>}\n */\n\n/**\n * Synonym of Tooling#describe()\n *\n * @method Tooling#describeSObject\n * @param {String} type - SObject Type\n * @param {Callback.<DescribeSObjectResult>} [callback] - Callback function\n * @returns {Promise.<DescribeSObjectResult>}\n */\n/**\n * Describe SObject metadata\n *\n * @method Tooling#describe\n * @param {String} type - SObject Type\n * @param {Callback.<DescribeSObjectResult>} [callback] - Callback function\n * @returns {Promise.<DescribeSObjectResult>}\n */\n\n/**\n * Describe global SObjects\n *\n * @method Tooling#describeGlobal\n * @param {Callback.<DescribeGlobalResult>} [callback] - Callback function\n * @returns {Promise.<DescribeGlobalResult>}\n */\n\n/**\n * Get SObject instance\n *\n * @method Tooling#sobject\n * @param {String} type - SObject Type\n * @returns {SObject}\n */\n\n/**\n * @typedef {Object} Tooling~ExecuteAnonymousResult\n * @prop {Boolean} compiled - Flag if the query is compiled successfully\n * @prop {String} compileProblem - Error reason in compilation\n * @prop {Boolean} success - Flag if the code is executed successfully\n * @prop {Number} line - Line number for the error\n * @prop {Number} column - Column number for the error\n * @prop {String} exceptionMessage - Exception message\n * @prop {String} exceptionStackTrace - Exception stack trace\n */\n/**\n * Executes Apex code anonymously\n *\n * @param {String} body - Anonymous Apex code\n * @param {Callback.<Tooling~ExecuteAnonymousResult>} [callback] - Callback function\n * @returns {Promise.<Tooling~ExecuteAnonymousResult>}\n */\nTooling.prototype.executeAnonymous = function(body, callback) {\n  var url = this._baseUrl() + \"/executeAnonymous?anonymousBody=\" + encodeURIComponent(body);\n  return this.request(url).thenCall(callback);\n};\n\n/**\n * Executes Apex tests asynchronously\n *\n * @param {Array.<String>} classids - Comma separated list of class IDs\n * @param {Callback.<Tooling~ExecuteAnonymousResult>} [callback] - Callback function\n * @returns {Promise.<Tooling~ExecuteAnonymousResult>}\n */\nTooling.prototype.runTestsAsynchronous = function(classids, callback) {\n  var url = this._baseUrl() + \"/runTestsAsynchronous/\";\n  return this._conn.requestPost(url, {classids : classids.join(',')}, undefined, callback);\n};\n\n/**\n * Executes Apex tests synchronously\n *\n * @param {Array.<String>} classnames - Comma separated list of class Names\n * @param {Callback.<Tooling~ExecuteAnonymousResult>} [callback] - Callback function\n * @returns {Promise.<Tooling~ExecuteAnonymousResult>}\n */\nTooling.prototype.runTestsSynchronous = function(classnames, callback) {\n  var url = this._baseUrl() + \"/runTestsSynchronous/\";\n  return this._conn.requestPost(url, {classnames : classnames.join(',')}, undefined, callback);\n};\n\n/**\n * @typedef {Object} Tooling~CompletionsResult\n * @prop {Object} publicDeclarations\n */\n/**\n * Retrieves available code completions of the referenced type\n *\n * @param {String} [type] - completion type (default 'apex')\n * @param {Callback.<Tooling~CompletionsResult>} [callback] - Callback function\n * @returns {Promise.<Tooling~CompletionsResult>}\n */\nTooling.prototype.completions = function(type, callback) {\n  if (!_.isString(type)) {\n    callback = type;\n    type = 'apex';\n  }\n  var url = this._baseUrl() + \"/completions?type=\" + encodeURIComponent(type);\n  return this.request(url).thenCall(callback);\n};\n\n\n/*--------------------------------------------*/\n/*\n * Register hook in connection instantiation for dynamically adding this API module features\n */\njsforce.on('connection:new', function(conn) {\n  conn.tooling = new Tooling(conn);\n});\n\n\nmodule.exports = Tooling;\n"]}