jsforce2 1.11.1

package/lib/browser/client.js

@@ -0,0 +1,241 @@
+/**
+ * @file Browser client connection management class
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+var events = require('events'),
+    inherits = require('inherits'),
+    qs = require('querystring'),
+    _ = require('lodash/core'),
+    Connection = require('../connection'),
+    OAuth2 = require('../oauth2');
+
+/**
+ * @private
+ */
+function popupWin(url, w, h) {
+  var left = (screen.width/2)-(w/2);
+  var top = (screen.height/2)-(h/2);
+  return window.open(url, null, 'location=yes,toolbar=no,status=no,menubar=no,width='+w+',height='+h+',top='+top+',left='+left);
+}
+
+function handleCallbackResponse() {
+  var res = checkCallbackResponse();
+  var state = localStorage.getItem('jsforce_state');
+  if (res && state && res.body.state === state) {
+    localStorage.removeItem('jsforce_state');
+    var states = state.split('.');
+    var prefix = states[0], promptType = states[1];
+    var cli = new Client(prefix);
+    if (res.success) {
+      cli._storeTokens(res.body);
+      location.hash = '';
+    } else {
+      cli._storeError(res.body);
+    }
+    if (promptType === 'popup') { window.close(); }
+    return true;
+  }
+}
+
+/**
+ * @private
+ */
+function checkCallbackResponse() {
+  var params;
+  if (window.location.hash) {
+    params = qs.parse(window.location.hash.substring(1));
+    if (params.access_token) {
+      return { success: true, body: params };
+    }
+  } else if (window.location.search) {
+    params = qs.parse(window.location.search.substring(1));
+    if (params.error) {
+      return { success: false, body: params };
+    }
+  }
+}
+
+/** @private **/
+var clientIdx = 0;
+
+
+/**
+ * @class
+ * @todo add document
+ */
+var Client = function(prefix) {
+  this._prefix = prefix || 'jsforce' + clientIdx++;
+  this.connection = null;
+};
+
+inherits(Client, events.EventEmitter);
+
+/**
+ *
+ */
+Client.prototype.init = function(config) {
+  if (handleCallbackResponse()) { return; }
+  this.config = config;
+  this.connection = new Connection(config);
+  var tokens = this._getTokens();
+  if (tokens) {
+    this.connection.initialize(tokens);
+    var self = this;
+    setTimeout(function() {
+      self.emit('connect', self.connection);
+    }, 10);
+  }
+};
+
+/**
+ *
+ */
+Client.prototype.login = function(options, callback) {
+  if (_.isFunction(options)) {
+    callback = options;
+    options = {};
+  }
+  options = options || {};
+  callback = callback || function(){ };
+  _.extend(options, this.config);
+  var self = this;
+  this._prompt(options, callback);
+};
+
+
+Client.prototype._prompt = function(options, callback) {
+  var self = this;
+  var oauth2 = new OAuth2(options);
+  var rand = Math.random().toString(36).substring(2);
+  var state = [ this._prefix, "popup", rand ].join('.');
+  localStorage.setItem("jsforce_state", state);
+  var authzUrl = oauth2.getAuthorizationUrl({
+    response_type: 'token',
+    scope : options.scope,
+    state: state
+  });
+  var size = options.size || {};
+  var pw = popupWin(authzUrl, size.width || 912, size.height || 513);
+  if (!pw) {
+    state = [ this._prefix, "redirect", rand ].join('.');
+    localStorage.setItem("jsforce_state", state);
+    authzUrl = oauth2.getAuthorizationUrl({
+      response_type: 'token',
+      scope : options.scope,
+      state: state
+    });
+    location.href = authzUrl;
+    return;
+  }
+  self._removeTokens();
+  var pid = setInterval(function() {
+    try {
+      if (!pw || pw.closed) {
+        clearInterval(pid);
+        var tokens = self._getTokens();
+        if (tokens) {
+          self.connection.initialize(tokens);
+          self.emit('connect', self.connection);
+          callback(null, { status: 'connect' });
+        } else {
+          var err = self._getError();
+          if (err) {
+            callback(new Error(err.error + ": " + err.error_description));
+          } else {
+            callback(null, { status: 'cancel' });
+          }
+        }
+      }
+    } catch(e) {}
+  }, 1000);
+};
+
+/**
+ *
+ */
+Client.prototype.isLoggedIn = function() {
+  return !!(this.connection && this.connection.accessToken);
+};
+
+/**
+ *
+ */
+Client.prototype.logout = function() {
+  this.connection.logout();
+  this._removeTokens();
+  this.emit('disconnect');
+};
+
+/**
+ * @private
+ */
+Client.prototype._getTokens = function() {
+  var regexp = new RegExp("(^|;\\s*)"+this._prefix+"_loggedin=true(;|$)");
+  if (document.cookie.match(regexp)) {
+    var issuedAt = Number(localStorage.getItem(this._prefix+'_issued_at'));
+    if (Date.now() < issuedAt + 2 * 60 * 60 * 1000) { // 2 hours
+      var userInfo;
+      var idUrl = localStorage.getItem(this._prefix + '_id');
+      if (idUrl) {
+        var ids = idUrl.split('/');
+        userInfo = { id: ids.pop(), organizationId: ids.pop(), url: idUrl };
+      }
+      return {
+        accessToken: localStorage.getItem(this._prefix + '_access_token'),
+        instanceUrl: localStorage.getItem(this._prefix + '_instance_url'),
+        userInfo: userInfo
+      };
+    }
+  }
+  return null;
+};
+
+/**
+ * @private
+ */
+Client.prototype._storeTokens = function(params) {
+  localStorage.setItem(this._prefix + '_access_token', params.access_token);
+  localStorage.setItem(this._prefix + '_instance_url', params.instance_url);
+  localStorage.setItem(this._prefix + '_issued_at', params.issued_at);
+  localStorage.setItem(this._prefix + '_id', params.id);
+  document.cookie = this._prefix + '_loggedin=true;';
+};
+
+/**
+ * @private
+ */
+Client.prototype._removeTokens = function() {
+  localStorage.removeItem(this._prefix + '_access_token');
+  localStorage.removeItem(this._prefix + '_instance_url');
+  localStorage.removeItem(this._prefix + '_issued_at');
+  localStorage.removeItem(this._prefix + '_id');
+  document.cookie = this._prefix + '_loggedin=';
+};
+
+/**
+ * @private
+ */
+Client.prototype._getError = function() {
+  try {
+    var err = JSON.parse(localStorage.getItem(this._prefix + '_error'));
+    localStorage.removeItem(this._prefix + '_error');
+    return err;
+  } catch(e) {}
+};
+
+/**
+ * @private
+ */
+Client.prototype._storeError = function(err) {
+  localStorage.setItem(this._prefix + '_error', JSON.stringify(err));
+};
+
+/**
+ *
+ */
+module.exports = new Client();
+
+module.exports.Client = Client;

package/lib/browser/core.js

@@ -0,0 +1,5 @@
+'use strict';
+
+var jsforce = require('../core');
+jsforce.browser = require('./client');
+module.exports = jsforce;

package/lib/browser/jsforce.js

@@ -0,0 +1,6 @@
+'use strict';
+
+var jsforce = require('../core');
+jsforce.browser = require('./client');
+require('../api');
+module.exports = jsforce;

package/lib/browser/jsonp.js

@@ -0,0 +1,52 @@
+/*global window, document */
+'use strict';
+
+var _index = 0;
+
+module.exports = {
+
+  supported: typeof window !== 'undefined' && typeof document !== 'undefined',
+
+  createRequest: function(jsonpParam, timeout) {
+    jsonpParam = jsonpParam || 'callback';
+    timeout = timeout || 10000;
+
+    return function(params, callback) {
+      if (params.method.toUpperCase() !== 'GET') {
+        return callback(new Error('JSONP only supports GET request.'));
+      }
+      var cbFuncName = '_jsforce_jsonpCallback_' + (++_index);
+      var callbacks = window;
+      var url = params.url;
+      url += url.indexOf('?')>0 ? '&' : '?';
+      url += jsonpParam + '=' + cbFuncName;
+
+      var script = document.createElement('script');
+      script.type = 'text/javascript';
+      script.src = url;
+      document.documentElement.appendChild(script);
+
+      var pid = setTimeout(function() {
+        cleanup();
+        callback(new Error("JSONP call time out."));
+      }, timeout);
+
+      callbacks[cbFuncName] = function(res) {
+        cleanup();
+        callback(null, {
+          statusCode: 200,
+          headers: { "content-type": "application/json" },
+          body: JSON.stringify(res)
+        });
+      };
+
+      var cleanup = function() {
+        clearTimeout(pid);
+        document.documentElement.removeChild(script);
+        delete callbacks[cbFuncName];
+      };
+    };
+
+  }
+
+};

package/lib/browser/request.js

@@ -0,0 +1,70 @@
+'use strict';
+
+var Duplex = require('readable-stream').Duplex;
+var _ = require('lodash/core');
+
+module.exports = function(params, callback) {
+  var xhr = new XMLHttpRequest();
+  xhr.open(params.method, params.url);
+  if (params.headers) {
+    for (var header in params.headers) {
+      xhr.setRequestHeader(header, params.headers[header]);
+    }
+  }
+  xhr.setRequestHeader("Accept", "*/*");
+  var response;
+  var str = new Duplex();
+  str._read = function(size) {
+    if (response) {
+      str.push(response.body);
+    }
+  };
+  var bufs = [];
+  var sent = false;
+  str._write = function(chunk, encoding, callback) {
+    bufs.push(chunk.toString(encoding === "buffer" ? "binary" : encoding));
+    callback();
+  };
+  str.on('finish', function() {
+    if (!sent) {
+      xhr.send(bufs.join(''));
+      sent = true;
+    }
+  });
+  if (params.body || params.body === "" || !/^(put|post|patch)$/i.test(params.method)) {
+    xhr.send(params.body);
+    sent = true;
+  }
+  xhr.onreadystatechange = function() {
+    if (xhr.readyState === 4) {
+      var headerNames = getResponseHeaderNames(xhr);
+      var headers = {};
+      _.forEach(headerNames, function(headerName) {
+        if (headerName) {
+          headers[headerName] = xhr.getResponseHeader(headerName);
+        }
+      });
+      response = {
+        statusCode: xhr.status,
+        headers: headers,
+        body: xhr.response
+      };
+      if (!response.statusCode) {
+        response.statusCode = 400;
+        response.body = "Access Declined";
+      }
+      if (callback) {
+        callback(null, response, response.body);
+      }
+      str.end();
+    }
+  };
+  return str;
+};
+
+function getResponseHeaderNames(xhr) {
+  var headerLines = (xhr.getAllResponseHeaders() || "").split(/[\r\n]+/);
+  return _.map(headerLines, function(headerLine) {
+    return headerLine.split(/\s*:/)[0].toLowerCase();
+  });
+}

package/lib/cache.js

@@ -0,0 +1,252 @@
+/**
+ * @file Manages asynchronous method response cache
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+var events = require('events'),
+    inherits = require('inherits'),
+    _      = require('lodash/core');
+
+/**
+ * Class for managing cache entry
+ *
+ * @private
+ * @class
+ * @constructor
+ * @template T
+ */
+var CacheEntry = function() {
+  this.fetching = false;
+};
+
+inherits(CacheEntry, events.EventEmitter);
+
+/**
+ * Get value in the cache entry
+ *
+ * @param {Callback.<T>} [callback] - Callback function callbacked the cache entry updated
+ * @returns {T|undefined}
+ */
+CacheEntry.prototype.get = function(callback) {
+  if (!callback) {
+    return this._value;
+  } else {
+    this.once('value', callback);
+    if (!_.isUndefined(this._value)) {
+      this.emit('value', this._value);
+    }
+  }
+};
+
+/**
+ * Set value in the cache entry
+ *
+ * @param {T} [value] - A value for caching
+ */
+CacheEntry.prototype.set = function(value) {
+  this._value = value;
+  this.emit('value', this._value);
+};
+
+/**
+ * Clear cached value
+ */
+CacheEntry.prototype.clear = function() {
+  this.fetching = false;
+  delete this._value;
+};
+
+
+/**
+ * Caching manager for async methods
+ *
+ * @class
+ * @constructor
+ */
+var Cache = function() {
+  this._entries = {};
+};
+
+/**
+ * retrive cache entry, or create if not exists.
+ *
+ * @param {String} [key] - Key of cache entry
+ * @returns {CacheEntry}
+ */
+Cache.prototype.get = function(key) {
+  if (key && this._entries[key]) {
+    return this._entries[key];
+  } else {
+    var entry = new CacheEntry();
+    this._entries[key] = entry;
+    return entry;
+  }
+};
+
+/**
+ * clear cache entries prefix matching given key
+ * @param {String} [key] - Key prefix of cache entry to clear
+ */
+Cache.prototype.clear = function(key) {
+  for (var k in this._entries) {
+    if (!key || k.indexOf(key) === 0) {
+      this._entries[k].clear();
+    }
+  }
+};
+
+/**
+ * create and return cache key from namespace and serialized arguments.
+ * @private
+ */
+function createCacheKey(namespace, args) {
+  args = Array.prototype.slice.apply(args);
+  return namespace + '(' + _.map(args, function(a){ return JSON.stringify(a); }).join(',') + ')';
+}
+
+/**
+ * Enable caching for async call fn to intercept the response and store it to cache.
+ * The original async calll fn is always invoked.
+ *
+ * @protected
+ * @param {Function} fn - Function to covert cacheable
+ * @param {Object} [scope] - Scope of function call
+ * @param {Object} [options] - Options
+ * @return {Function} - Cached version of function
+ */
+Cache.prototype.makeResponseCacheable = function(fn, scope, options) {
+  var cache = this;
+  options = options || {};
+  return function() {
+    var args = Array.prototype.slice.apply(arguments);
+    var callback = args.pop();
+    if (!_.isFunction(callback)) {
+      args.push(callback);
+      callback = null;
+    }
+    var keys = _.isString(options.key) ? options.key :
+               _.isFunction(options.key) ? options.key.apply(scope, args) :
+               createCacheKey(options.namespace, args);
+    if (!Array.isArray(keys)) { keys = [ keys ]; }
+    var entries = [];
+    keys.forEach(function (key) {
+      var entry = cache.get(key);
+      entry.fetching = true;
+      entries.push(entry);
+    })
+    if (callback) {
+      args.push(function(err, result) {
+        if (Array.isArray(result) && result.length == entries.length) {
+          entries.forEach(function (entry, index) {
+            entry.set({ error: err, result: result[index] });
+          })
+        } else {
+          entries.forEach(function (entry) {
+            entry.set({ error: err, result: result });
+          });
+        }
+        callback(err, result);
+      });
+    }
+    var ret, error;
+    try {
+      ret = fn.apply(scope || this, args);
+    } catch(e) {
+      error = e;
+    }
+    if (ret && _.isFunction(ret.then)) { // if the returned value is promise
+      if (!callback) {
+        return ret.then(function(result) {
+          if (Array.isArray(result) && result.length == entries.length) {
+            entries.forEach(function (entry, index) {
+              entry.set({ error: undefined, result: result[index] });
+            })
+          } else {
+            entries.forEach(function (entry) {
+              entry.set({ error: undefined, result: result });
+            });
+          }
+          return result;
+        }, function(err) {
+          if (Array.isArray(err) && err.length == entries.length) {
+            entries.forEach(function (entry, index) {
+              entry.set({ error: err[index], result: undefined });
+            })
+          } else {
+            entries.forEach(function (entry) {
+              entry.set({ error: err, result: undefined });
+            });
+          }
+          throw err;
+        });
+      } else {
+        return ret;
+      }
+    } else {
+      if (Array.isArray(ret) && ret.length == entries.length) {
+        entries.forEach(function (entry, index) {
+          entry.set({ error: error, result: ret[index] });
+        })
+      } else {
+        entries.forEach(function (entry) {
+          entry.set({ error: error, result: ret });
+        });
+      }
+      if (error) { throw error; }
+      return ret;
+    }
+  };
+};
+
+/**
+ * Enable caching for async call fn to lookup the response cache first, then invoke original if no cached value.
+ *
+ * @protected
+ * @param {Function} fn - Function to covert cacheable
+ * @param {Object} [scope] - Scope of function call
+ * @param {Object} [options] - Options
+ * @return {Function} - Cached version of function
+ */
+Cache.prototype.makeCacheable = function(fn, scope, options) {
+  var cache = this;
+  options = options || {};
+  var $fn = function() {
+    var args = Array.prototype.slice.apply(arguments);
+    var callback = args.pop();
+    if (!_.isFunction(callback)) {
+      args.push(callback);
+    }
+    var key = _.isString(options.key) ? options.key :
+              _.isFunction(options.key) ? options.key.apply(scope, args) :
+              createCacheKey(options.namespace, args);
+    var entry = cache.get(key);
+    if (!_.isFunction(callback)) { // if callback is not given in last arg, return cached result (immediate).
+      var value = entry.get();
+      if (!value) { throw new Error('Function call result is not cached yet.'); }
+      if (value.error) { throw value.error; }
+      return value.result;
+    }
+    entry.get(function(value) {
+      callback(value.error, value.result);
+    });
+    if (!entry.fetching) { // only when no other client is calling function
+      entry.fetching = true;
+      args.push(function(err, result) {
+        entry.set({ error: err, result: result });
+      });
+      fn.apply(scope || this, args);
+    }
+  };
+  $fn.clear = function() {
+    var key = _.isString(options.key) ? options.key :
+              _.isFunction(options.key) ? options.key.apply(scope, arguments) :
+              createCacheKey(options.namespace, arguments);
+    cache.clear(key);
+  };
+  return $fn;
+};
+
+
+module.exports = Cache;