jsforce2 1.11.1

package/lib/soql-builder.js

@@ -0,0 +1,236 @@
+/**
+ * @file Create and build SOQL string from configuration
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+var _      = require('lodash/core'),
+    SfDate = require("./date");
+
+
+/**
+ * Create SOQL
+ * @private
+ */
+function createSOQL(query) {
+  var soql = [
+    "SELECT ",
+    createFieldsClause(query.fields, query.includes),
+    " FROM ",
+    query.table
+  ].join("");
+  var cond = createConditionClause(query.conditions);
+  if (cond) {
+    soql += " WHERE " + cond;
+  }
+  var orderby = createOrderByClause(query.sort);
+  if (orderby) {
+    soql += " ORDER BY " + orderby;
+  }
+  if (query.limit) {
+    soql += " LIMIT " + query.limit;
+  }
+  if (query.offset) {
+    soql += " OFFSET " + query.offset;
+  }
+  return soql;
+}
+
+/** @private **/
+function createFieldsClause(fields, childQueries) {
+  childQueries = _.map(_.values(childQueries || {}), function(cquery) {
+    return '(' + createSOQL(cquery) + ')';
+  });
+  return (fields || [ "Id" ]).concat(childQueries).join(', ');
+}
+
+/** @private **/
+function createConditionClause(conditions, operator, depth) {
+  if (_.isString(conditions)) {
+    return conditions;
+  }
+  conditions = conditions || [];
+  operator = operator || "AND";
+  depth = depth || 0;
+  if (!isArray(conditions)) { // if passed in hash object
+    conditions = _.keys(conditions).map(function(key) {
+      return {
+        key: key,
+        value: conditions[key]
+      };
+    });
+  } else {
+    conditions = conditions.map(function(cond) {
+      var conds = [];
+      for (var key in cond) {
+        conds.push({
+          key: key,
+          value: cond[key]
+        });
+      }
+      return conds.length>1 ? conds : conds[0];
+    });
+  }
+  conditions = conditions.map(function(cond) {
+    var d = depth+1, op;
+    switch (cond.key) {
+      case "$or" :
+      case "$and" :
+      case "$not" :
+        if (operator !== "NOT" && conditions.length === 1) {
+          d = depth; // not change tree depth
+        }
+        op = cond.key === "$or" ? "OR" :
+             cond.key === "$and" ? "AND" :
+             "NOT";
+        return createConditionClause(cond.value, op, d);
+      default:
+        return createFieldExpression(cond.key, cond.value);
+    }
+  }).filter(function(expr) { return expr; });
+
+  var paren;
+  if (operator === 'NOT') {
+    paren = depth > 0;
+    return (paren ? "(" : "") + "NOT " + conditions[0] + (paren ? ")" : "");
+  } else {
+    paren = depth > 0 && conditions.length > 1;
+    return (paren ? "(" : "") + conditions.join(" "+operator+" ") + (paren ? ")" : "");
+  }
+}
+
+var opMap = {
+  "="     : "=",
+  "$eq"   : "=",
+  "!="    : "!=",
+  "$ne"   : "!=",
+  ">"     : ">",
+  "$gt"   : ">",
+  "<"     : "<",
+  "$lt"   : "<",
+  ">="    : ">=",
+  "$gte"  : ">=",
+  "<="    : "<=",
+  "$lte"  : "<=",
+  "$like" : "LIKE",
+  "$nlike" : "NOT LIKE",
+  "$in"   : "IN",
+  "$nin"  : "NOT IN",
+  "$includes" : "INCLUDES",
+  "$excludes" : "EXCLUDES",
+  "$exists" : "EXISTS"
+};
+
+/** @private **/
+function createFieldExpression(field, value) {
+  // Assume the `$in` operator if value is an array and none was supplied.
+  if (_.isArray(value)) {
+    return createOpExpression(field, "$in", value);
+  }
+  // Otherwise, if an object was passed then process the supplied ops.
+  else if (_.isObject(value)) {
+    var expressions = _.map(value, function (v, k) {
+      if (k[0] === "$") return createOpExpression(field, k, v);
+    });
+    return expressions.join(' AND ');
+  }
+  // If the value is a scalar, it's an equality condition.
+  else return createOpExpression(field, "$eq", value);
+}
+
+/** @private **/
+function createOpExpression(field, op, value) {
+  var sfop = opMap[op];
+  if (!sfop || _.isUndefined(value)) { return null; }
+  var valueExpr = createValueExpression(value);
+  if (_.isUndefined(valueExpr)) { return null; }
+  switch (sfop) {
+    case "NOT LIKE":
+      return "(" + [ "NOT", field, 'LIKE', valueExpr ].join(" ") + ")";
+    case "EXISTS":
+      return [ field, value ? "!=" : "=", "null" ].join(" ");
+    default:
+      return [ field, sfop, valueExpr ].join(" ");
+  }
+}
+
+/** @private **/
+function createValueExpression(value) {
+  if (isArray(value)) {
+    return value.length > 0 ?
+           "(" + value.map(createValueExpression).join(", ") + ")" :
+           undefined;
+  }
+  if (value instanceof SfDate) {
+    return value.toString();
+  }
+  if (_.isString(value)) {
+    return "'" + escapeSOQLString(value) + "'";
+  }
+  if (_.isNumber(value)) {
+    return (value).toString();
+  }
+  if (_.isNull(value)) {
+    return "null";
+  }
+  return value;
+}
+
+/** @private **/
+function escapeSOQLString(str) {
+  return String(str || '').replace(/'/g, "\\'");
+}
+
+/** @private **/
+function isArray(a) {
+  return _.isObject(a) && _.isFunction(a.pop);
+}
+
+
+/** @private **/
+function createOrderByClause(sort) {
+  sort = sort || [];
+  if (_.isString(sort)) {
+    if (/,|\s+(asc|desc)\s*$/.test(sort)) {
+      // must be specified in pure "order by" clause. Return raw config.
+      return sort;
+    }
+    // sort order in mongoose-style expression.
+    // e.g. "FieldA -FieldB" => "ORDER BY FieldA ASC, FieldB DESC"
+    sort = sort.split(/\s+/).map(function(field) {
+      var dir = "ASC"; // ascending
+      var flag = field[0];
+      if (flag === '-') {
+        dir = "DESC";
+        field = field.substring(1);
+      } else if (flag === '+') {
+        field = field.substring(1);
+      }
+      return [ field, dir ];
+    });
+  } else if (!isArray(sort)) {
+    sort = _.keys(sort).map(function(field) {
+      var dir = sort[field];
+      return [ field, dir ];
+    });
+  }
+  return sort.map(function(s) {
+    var field = s[0], dir = s[1];
+    switch (String(dir)) {
+      case "DESC":
+      case "desc":
+      case "descending":
+      case "-":
+      case "-1":
+        dir = "DESC";
+        break;
+      default:
+        dir = "ASC";
+    }
+    return field + " " + dir;
+  }).join(", ");
+}
+
+
+exports.createSOQL = createSOQL;

package/lib/transport.js

@@ -0,0 +1,233 @@
+/*global process, Sfdc */
+
+'use strict';
+
+var inherits = require('inherits'),
+    Promise = require('./promise');
+
+/* */
+
+var request = require('request'),
+    canvas = require('./browser/canvas'),
+    jsonp = require('./browser/jsonp');
+
+// set options if defaults setting is available in request, which is not available in xhr module.
+if (request.defaults) {
+  var defaults = {
+    followAllRedirects: true
+  };
+  if (process.env.HTTP_PROXY) {
+    defaults.proxy = process.env.HTTP_PROXY;
+  }
+  if (parseInt(process.env.HTTP_TIMEOUT)) {
+    defaults.timeout = parseInt(process.env.HTTP_TIMEOUT);
+  }
+  request = request.defaults(defaults);
+}
+
+var baseUrl;
+if (typeof window === 'undefined') {
+  baseUrl = process.env.LOCATION_BASE_URL || "";
+} else {
+  var apiHost = normalizeApiHost(window.location.host);
+  baseUrl = apiHost ? "https://" + apiHost : "";
+}
+
+/**
+ * Add stream() method to promise (and following promise chain), to access original request stream.
+ * @private
+ */
+function streamify(promise, factory) {
+  var _then = promise.then;
+  promise.then = function() {
+    factory();
+    var newPromise = _then.apply(promise, arguments);
+    return streamify(newPromise, factory);
+  };
+  promise.stream = factory;
+  return promise;
+}
+
+/**
+ * Normarize Salesforce API host name
+ * @private
+ */
+function normalizeApiHost(apiHost) {
+  var m = /(\w+)\.(visual\.force|salesforce)\.com$/.exec(apiHost);
+  if (m) {
+    apiHost = m[1] + ".salesforce.com";
+  }
+  return apiHost;
+}
+
+/**
+ * Class for HTTP request transport
+ *
+ * @class
+ * @protected
+ */
+var Transport = module.exports = function() {};
+
+/**
+ * Make HTTP request, returns promise instead of stream
+ *
+ * @param {Object} params - HTTP request
+ * @param {Callback.<Object>} [callback] - Calback Function
+ * @returns {Promise.<Object>}
+ */
+Transport.prototype.httpRequest = function(params, callback) {
+  var deferred = Promise.defer();
+  var req;
+  var httpRequest = this._getHttpRequestModule();
+  var createRequest = function() {
+    if (!req) {
+      req = httpRequest(params, function(err, response) {
+        if (err) {
+          deferred.reject(err);
+        } else {
+          deferred.resolve(response);
+        }
+      });
+    }
+    return req;
+  };
+  return streamify(deferred.promise, createRequest).thenCall(callback);
+};
+
+/** @protected **/
+Transport.prototype._getHttpRequestModule = function() {
+  return request;
+};
+
+
+/**
+ * Class for JSONP request transport
+ * @class Transport~JsonpTransport
+ * @protected
+ * @extends Transport
+ * @param {String} jsonpParam - Callback parameter name for JSONP invokation.
+ */
+var JsonpTransport = Transport.JsonpTransport = function(jsonpParam) {
+  this._jsonpParam = jsonpParam;
+};
+
+inherits(JsonpTransport, Transport);
+
+/** @protected **/
+JsonpTransport.prototype._getHttpRequestModule = function() {
+  return jsonp.createRequest(this._jsonpParam);
+};
+
+JsonpTransport.supported = jsonp.supported;
+
+
+/**
+ * Class for Sfdc Canvas request transport
+ * @class Transport~CanvasTransport
+ * @protected
+ * @extends Transport
+ * @param {Object} signedRequest - Parsed signed request object
+ */
+var CanvasTransport = Transport.CanvasTransport = function(signedRequest) {
+  this._signedRequest = signedRequest;
+};
+
+inherits(CanvasTransport, Transport);
+
+/** @protected **/
+CanvasTransport.prototype._getHttpRequestModule = function() {
+  return canvas.createRequest(this._signedRequest);
+};
+
+CanvasTransport.supported = canvas.supported;
+
+
+/**
+ * Class for HTTP request transport using AJAX proxy service
+ *
+ * @class Transport~ProxyTransport
+ * @protected
+ * @extends Transport
+ * @param {String} proxyUrl - AJAX Proxy server URL
+ */
+var ProxyTransport = Transport.ProxyTransport = function(proxyUrl) {
+  this._proxyUrl = proxyUrl;
+};
+
+inherits(ProxyTransport, Transport);
+
+/**
+ * Make HTTP request via AJAX proxy
+ *
+ * @method Transport~ProxyTransport#httpRequest
+ * @param {Object} params - HTTP request
+ * @param {Callback.<Object>} [callback] - Calback Function
+ * @returns {Promise.<Object>}
+ */
+ProxyTransport.prototype.httpRequest = function(params, callback) {
+  var url = params.url;
+  if (url.indexOf("/") === 0) {
+    url = baseUrl + url;
+  }
+  var proxyParams = {
+    method: params.method,
+    url: this._proxyUrl + '?' + Date.now() + "." + ("" + Math.random()).substring(2),
+    headers: {
+      'salesforceproxy-endpoint': url
+    }
+  };
+  if (params.body || params.body === "") {
+    proxyParams.body = params.body;
+  }
+  if (params.headers) {
+    for (var name in params.headers) {
+      proxyParams.headers[name] = params.headers[name];
+    }
+  }
+  return ProxyTransport.super_.prototype.httpRequest.call(this, proxyParams, callback);
+};
+
+
+/**
+ * Class for HTTP request transport using a proxy server
+ *
+ * @class Transport~HttpProxyTransport
+ * @protected
+ * @extends Transport
+ * @param {String} httpProxy - URL of the HTTP proxy server
+ */
+var HttpProxyTransport = Transport.HttpProxyTransport = function(httpProxy) {
+  this._httpProxy = httpProxy;
+};
+
+inherits(HttpProxyTransport, Transport);
+
+/**
+ * Make HTTP request via proxy server
+ *
+ * @method Transport~HttpProxyTransport#httpRequest
+ * @param {Object} params - HTTP request
+ * @param {Callback.<Object>} [callback] - Callback Function
+ * @returns {Promise.<Object>}
+ */
+HttpProxyTransport.prototype.httpRequest = function(params, callback) {
+  var url = params.url;
+  if (url.indexOf("/") === 0) {
+    url = baseUrl + url;
+  }
+  var proxyParams = {
+    method: params.method,
+    url: params.url,
+    proxy: this._httpProxy,
+    headers: {}
+  };
+  if (params.body || params.body === "") {
+    proxyParams.body = params.body;
+  }
+  if (params.headers) {
+    for (var name in params.headers) {
+      proxyParams.headers[name] = params.headers[name];
+    }
+  }
+  return HttpProxyTransport.super_.prototype.httpRequest.call(this, proxyParams, callback);
+};

package/package.json

@@ -0,0 +1,110 @@
+{
+  "author": "Shinichi Tomita <shinichi.tomita@gmail.com>",
+  "name": "jsforce2",
+  "description": "Salesforce API Library for JavaScript",
+  "keywords": [
+    "salesforce",
+    "salesforce.com",
+    "sfdc",
+    "force.com",
+    "database.com"
+  ],
+  "homepage": "http://github.com/jsforce/jsforce",
+  "version": "1.11.1",
+  "repository": {
+    "type": "git",
+    "url": "git://github.com/jsforce/jsforce.git"
+  },
+  "license": "MIT",
+  "licenses": [
+    {
+      "type": "MIT",
+      "url": "http://github.com/jsforce/jsforce/raw/master/LICENSE"
+    }
+  ],
+  "main": "./index",
+  "scripts": {
+    "build": "gulp build",
+    "build:test": "gulp build:test",
+    "build:all": "gulp build:all",
+    "doc": "jsdoc lib -d doc --recurse --lenient",
+    "test": "npm run test:node",
+    "test:all": "npm run test:node && npm run test:browser",
+    "test:node": "mocha --retries 2 --reporter spec --require intelli-espower-loader --exit",
+    "test:browser": "testem",
+    "prepublish": "node -e \"if(process.env.npm_package_version!==require('./lib/VERSION')){console.error('The pacakge.json version is not matching to ./lib/VERSION.js');process.exit(1)}\""
+  },
+  "directories": {
+    "test": "test/"
+  },
+  "files": [
+    "README.md",
+    "bower.json",
+    "LICENSE",
+    "package.json",
+    "bin",
+    "build",
+    "lib",
+    "core.js",
+    "index.js"
+  ],
+  "engines": {
+    "node": ">=4.0"
+  },
+  "bin": {
+    "jsforce": "./bin/jsforce"
+  },
+  "dependencies": {
+    "base64-url": "^2.2.0",
+    "co-prompt": "^1.0.0",
+    "coffeescript": "^1.10.0",
+    "commander": "^2.9.0",
+    "csv-parse": "^4.10.1",
+    "csv-stringify": "^1.0.4",
+    "faye": "^1.4.0",
+    "inherits": "^2.0.1",
+    "lodash": "^4.17.19",
+    "multistream": "^2.0.5",
+    "opn": "^5.3.0",
+    "promise": "^7.1.1",
+    "readable-stream": "^2.1.0",
+    "request": "^2.72.0",
+    "xml2js": "^0.4.16"
+  },
+  "devDependencies": {
+    "archiver": "^1.3.0",
+    "async": "^1.5.2",
+    "babel": "^6.23.0",
+    "babel-core": "^6.26.3",
+    "babel-preset-env": "^1.7.0",
+    "babel-register": "^6.26.0",
+    "browserify": "^16.2.2",
+    "bufferutil": "^4.0.0",
+    "envify": "^3.4.1",
+    "espower-loader": "^1.2.2",
+    "espowerify": "^1.1.0",
+    "gulp": "^4.0.0",
+    "gulp-rename": "^1.4.0",
+    "gulp-sourcemaps": "^1.12.1",
+    "gulp-uglify": "^3.0.2",
+    "intelli-espower-loader": "^1.0.1",
+    "jsdoc": "^3.6.3",
+    "mocha": "^5.2.0",
+    "power-assert": "^1.6.0",
+    "puppeteer": "^1.18.1",
+    "require-swapper": "^0.1.7",
+    "testem": "^2.8.2",
+    "through2": "^2.0.3",
+    "utf-8-validate": "^5.0.1",
+    "vinyl-buffer": "^1.0.1",
+    "vinyl-source-stream": "^2.0.0"
+  },
+  "browser": {
+    "./index": "./lib/browser/jsforce",
+    "./index.js": "./lib/browser/jsforce",
+    "./core": "./lib/browser/core",
+    "./core.js": "./lib/browser/core",
+    "request": "./lib/browser/request.js"
+  },
+  "types": "types/index.d.ts"
+}