jsforce2 1.11.1

package/lib/quick-action.js

@@ -0,0 +1,90 @@
+/**
+ * @file Represents Salesforce QuickAction
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+
+/**
+ * A class for quick action
+ *
+ * @protected
+ * @constructor
+ */
+var QuickAction = module.exports = function(conn, path) {
+  this._conn = conn;
+  this._path = path;
+};
+
+/**
+ * @typedef {Object} QuickAction~QuickActionInfo
+ * @prop {String} type - Type of the action (e.g. Create, Update, Post, LogACall)
+ * @prop {String} name - Name of the action
+ * @prop {String} label - Label of the action
+ * @prop {Object} urls - Endpoint URL information of the action
+ */
+/**
+ * @typedef {QuickAction~QuickActionInfo} QuickAction~QuickActionDescriveInfo
+ * @prop {String} contextSobjectType - Object type used for the action
+ * @prop {String} targetSobjectType - Object type of the action to target
+ * @prop {String} targetParentField - Field name in the target object which refers parent(context) object record ID.
+ * @prop {String} targetRecordTypeId - Record type of the targeted record
+ * @prop {Object} layout - Layout sections that comprise an action
+ */
+
+/**
+ * Describe the action's information (including layout, etc.)
+ *
+ * @param {Callback.<QuickAction~QuickActionDescriveInfo>} [callback] - Callback function
+ * @returns {Promise.<QuickAction~QuickActionDescriveInfo>}
+ */
+QuickAction.prototype.describe = function(callback) {
+  var url = this._path + "/describe";
+  return this._conn.request(url).thenCall(callback);
+};
+
+/**
+ * Retrieve default field values in the action (for given record, if specified)
+ *
+ * @param {String} [contextId] - ID of record to get default values specific to the record
+ * @param {Callback.<Record>} [callback] - Callback function
+ * @returns {Promise.<Record>}
+ */
+QuickAction.prototype.defaultValues = function(contextId, callback) {
+  if (typeof contextId === 'function') {
+    callback = contextId;
+    contextId = null;
+  }
+  var url = this._path + "/defaultValues";
+  if (contextId) {
+    url += "/" + contextId;
+  }
+  return this._conn.request(url).thenCall(callback);
+};
+
+/**
+ * @typedef {Object} QuickAction~QuickActionResult
+ * @param {String} id - Record id of the action result
+ * @param {Array.<String>} feedItemIds - List of IDs for feed item
+ * @param {Boolean} success - True if the action successfully completed
+ * @param {Boolean} created - True if the action yields a new record
+ * @param {String} contextId - Context record ID of the action
+ * @param {Array.<Object>} errors - Errors if the action failed
+ */
+
+/**
+ * Execute the action for given context Id and record information
+ * 
+ * @param {String} contextId - Context record ID of the action
+ * @param {Record} record - Input record information for the action
+ * @param {Callback.<QuickAction~QuickActionResult>} [callback] - Callback function
+ * @returns {Promise.<QuickAction~QuickActionResult>}
+ */
+QuickAction.prototype.execute = function(contextId, record, callback) {
+  var body = {
+    contextId: contextId,
+    record: record
+  };
+  return this._conn.requestPost(this._path, body).thenCall(callback);
+};

package/lib/record-stream.js

@@ -0,0 +1,305 @@
+/**
+ * @file Represents stream that handles Salesforce record as stream data
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+var events = require('events'),
+    stream = require('readable-stream'),
+    Duplex = stream.Duplex,
+    Transform = stream.Transform,
+    PassThrough = stream.PassThrough,
+    inherits = require('inherits'),
+    _      = require('lodash/core'),
+    CSV    = require('./csv');
+
+
+/**
+ * Class for Record Stream
+ *
+ * @class
+ * @constructor
+ * @extends stream.Transform
+ */
+var RecordStream = module.exports = function() {
+  RecordStream.super_.call(this, { objectMode: true });
+};
+
+inherits(RecordStream, Transform);
+
+
+/*
+ * @override
+ */
+RecordStream.prototype._transform = function(record, enc, callback) {
+  this.emit('record', record);
+  this.push(record);
+  callback();
+};
+
+/**
+ * Get record stream of queried records applying the given mapping function
+ *
+ * @param {RecordMapFunction} fn - Record mapping function
+ * @returns {RecordStream}
+ */
+RecordStream.prototype.map = function(fn) {
+  return this.pipe(RecordStream.map(fn));
+};
+
+/**
+ * Get record stream of queried records, applying the given filter function
+ *
+ * @param {RecordFilterFunction} fn - Record filtering function
+ * @returns {RecordStream}
+ */
+RecordStream.prototype.filter = function(fn) {
+  return this.pipe(RecordStream.filter(fn));
+};
+
+
+/**
+ * @class RecordStream.Serializable
+ * @extends {RecordStream}
+ */
+var Serializable = RecordStream.Serializable = function() {
+  Serializable.super_.call(this);
+  this._dataStream = null;
+};
+
+inherits(Serializable, RecordStream);
+
+/**
+ * Create readable data stream which emits serialized record data
+ *
+ * @param {String} [type] - Type of outgoing data format. Currently 'csv' is default value and the only supported.
+ * @param {Object} [options] - Options passed to converter
+ * @returns {stream.Readable}
+*/
+Serializable.prototype.stream = function(type, options) {
+  type = type || 'csv';
+  var converter = DataStreamConverters[type];
+  if (!converter) {
+    throw new Error('Converting [' + type + '] data stream is not supported.');
+  }
+  if (!this._dataStream) {
+    this._dataStream = new PassThrough();
+    this.pipe(converter.serialize(options))
+      .pipe(this._dataStream);
+  }
+  return this._dataStream;
+};
+
+
+/**
+ * @class RecordStream.Parsable
+ * @extends {RecordStream}
+ */
+var Parsable = RecordStream.Parsable = function() {
+  Parsable.super_.call(this);
+  this._dataStream = null;
+};
+
+inherits(Parsable, RecordStream);
+
+/**
+ * Create writable data stream which accepts serialized record data
+ *
+ * @param {String} [type] - Type of outgoing data format. Currently 'csv' is default value and the only supported.
+ * @param {Object} [options] - Options passed to converter
+ * @returns {stream.Readable}
+*/
+Parsable.prototype.stream = function(type, options) {
+  type = type || 'csv';
+  var converter = DataStreamConverters[type];
+  var self = this;
+  if (!converter) {
+    throw new Error('Converting [' + type + '] data stream is not supported.');
+  }
+  if (!this._dataStream) {
+    this._dataStream = new PassThrough();
+    this._parserStream = converter.parse(options).on('error', function(error) { self.emit('error', error); });
+    this._parserStream.pipe(this).pipe(new PassThrough({ objectMode: true, highWaterMark: ( 500 * 1000 ) }));
+  }
+  return this._dataStream;
+};
+
+
+/* @override */
+Parsable.prototype.on = function(ev, fn) {
+  if (ev === 'readable' || ev === 'record') {
+    this._dataStream.pipe(this._parserStream);
+  }
+  return Parsable.super_.prototype.on.call(this, ev, fn);
+};
+
+/* @override */
+Parsable.prototype.addListener = Parsable.prototype.on;
+
+/* --------------------------------------------------- */
+
+/**
+ * @callback RecordMapFunction
+ * @param {Record} record - Source record to map
+ * @returns {Record}
+ */
+
+/**
+ * Create a record stream which maps records and pass them to downstream
+ *
+ * @param {RecordMapFunction} fn - Record mapping function
+ * @returns {RecordStream.Serializable}
+ */
+RecordStream.map = function(fn) {
+  var mapStream = new RecordStream.Serializable();
+  mapStream._transform = function(record, enc, callback) {
+    var rec = fn(record) || record; // if not returned record, use same record
+    this.push(rec);
+    callback();
+  };
+  return mapStream;
+};
+
+/**
+ * Create mapping stream using given record template
+ *
+ * @param {Record} record - Mapping record object. In mapping field value, temlate notation can be used to refer field value in source record, if noeval param is not true.
+ * @param {Boolean} [noeval] - Disable template evaluation in mapping record.
+ * @returns {RecordStream.Serializable}
+ */
+RecordStream.recordMapStream = function(record, noeval) {
+  return RecordStream.map(function(rec) {
+    var mapped = { Id: rec.Id };
+    for (var prop in record) {
+      mapped[prop] = noeval ? record[prop] : evalMapping(record[prop], rec);
+    }
+    return mapped;
+  });
+
+  function evalMapping(value, mapping) {
+    if (_.isString(value)) {
+      var m = /^\$\{(\w+)\}$/.exec(value);
+      if (m) { return mapping[m[1]]; }
+      return value.replace(/\$\{(\w+)\}/g, function($0, prop) {
+        var v = mapping[prop];
+        return _.isNull(v) || _.isUndefined(v) ? "" : String(v);
+      });
+    } else {
+      return value;
+    }
+  }
+};
+
+/**
+ * @callback RecordFilterFunction
+ * @param {Record} record - Source record to filter
+ * @returns {Boolean}
+ */
+
+/**
+ * Create a record stream which filters records and pass them to downstream
+ *
+ * @param {RecordFilterFunction} fn - Record filtering function
+ * @returns {RecordStream.Serializable}
+ */
+RecordStream.filter = function(fn) {
+  var filterStream = new RecordStream.Serializable();
+  filterStream._transform = function(record, enc, callback) {
+    if (fn(record)) { this.push(record); }
+    callback();
+  };
+  return filterStream;
+};
+
+/**
+ * @private
+ */
+function convertRecordForSerialization(record, options) {
+  const opts = options || {};
+
+  function isBuffer(obj) {
+    return (
+      obj &&
+      obj.constructor &&
+      typeof obj.constructor.isBuffer === "function" &&
+      obj.constructor.isBuffer(obj)
+    );
+  }
+
+  function keyIdentity(key) {
+    return key;
+  }
+
+  const delimiter = ".";
+  const transformKey = keyIdentity;
+  const output = {};
+
+  function step(object, prev) {
+    Object.keys(object).forEach(function (key) {
+      if (key === "attributes") {
+        return;
+      }
+      const value = object[key];
+      const isbuffer = isBuffer(value);
+      const isobject = typeof value === "object";
+      const isnull = value === null;
+
+      const newKey = prev
+        ? prev + delimiter + transformKey(key)
+        : transformKey(key);
+
+      if (!isnull && !isbuffer && isobject && Object.keys(value).length) {
+        step(value, newKey);
+      }
+
+      output[newKey] = isnull && opts.nullValue ? opts.nullValue : value;
+    });
+  }
+
+  step(record);
+
+  return output;
+}
+
+/**
+ * @private
+ */
+function createPipelineStream(s1, s2) {
+  var pipeline = new PassThrough();
+  pipeline.on('pipe', function(source) {
+    source.unpipe(pipeline);
+    source.pipe(s1).pipe(s2);
+  });
+  pipeline.pipe = function(dest, options) {
+    return s2.pipe(dest, options);
+  };
+  return pipeline;
+}
+
+/** ---------------------------------------------------------------------- **/
+
+/**
+ * @private
+ */
+var CSVStreamConverter = {
+  serialize: function(options) {
+    options = options || {};
+    return createPipelineStream(
+      RecordStream.map(function(record) {
+        return convertRecordForSerialization(record, options);
+      }),
+      CSV.serializeCSVStream(options)
+    );
+  },
+  parse: function(options) {
+    return CSV.parseCSVStream(options);
+  }
+};
+
+/**
+ * @private
+ */
+var DataStreamConverters = RecordStream.DataStreamConverters = {
+  csv: CSVStreamConverter
+};

package/lib/record.js

@@ -0,0 +1,107 @@
+/**
+ * @file Represents Salesforce record information
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+var _ = require('lodash/core');
+
+/**
+ * A simple hash object including record field information
+ *
+ * @typedef {Object} Record
+ */
+
+/**
+ * Remote reference to record information
+ *
+ * @protected
+ * @class
+ * @constructor
+ * @param {Connection} conn - Connection object
+ * @param {String} type - SObject type
+ * @param {String} id - Record ID
+ */
+var RecordReference = module.exports = function(conn, type, id) {
+  this._conn = conn;
+  this.type = type;
+  this.id = id;
+};
+
+/**
+ * Retrieve record field information
+ *
+ * @param {Object} [options] - Options for rest api.
+ * @param {Callback.<Record>} [callback] - Callback function
+ * @returns {Promise.<Record>}
+ */
+RecordReference.prototype.retrieve = function(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  return this._conn.retrieve(this.type, this.id, options, callback);
+};
+
+/**
+ * Update record field information
+ *
+ * @param {Record} record - A Record which includes fields to update
+ * @param {Object} [options] - Options for rest api.
+ * @param {Callback.<RecordResult>} [callback] - Callback function
+ * @returns {Promise.<RecordResult>}
+ */
+RecordReference.prototype.update = function(record, options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  record = _.clone(record);
+  record.Id = this.id;
+  return this._conn.update(this.type, record, options, callback);
+};
+
+/**
+ * Synonym of Record#destroy()
+ *
+ * @method RecordReference#delete
+ * @param {Object} [options] - Options for rest api.
+ * @param {Callback.<RecordResult>} [callback] - Callback function
+ * @returns {Promise.<RecordResult>}
+ */
+RecordReference.prototype["delete"] =
+/**
+ * Synonym of Record#destroy()
+ *
+ * @method RecordReference#del
+ * @param {Callback.<RecordResult>} [callback] - Callback function
+ * @returns {Promise.<RecordResult>}
+ */
+RecordReference.prototype.del =
+/**
+ * Delete record field
+ *
+ * @method RecordReference#destroy
+ * @param {Object} [options] - Options for rest api.
+ * @param {Callback.<RecordResult>} [callback] - Callback function
+ * @returns {Promise.<RecordResult>}
+ */
+RecordReference.prototype.destroy = function(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+  return this._conn.destroy(this.type, this.id, options, callback);
+};
+
+/**
+ * Get blob field as stream
+ *
+ * @param {String} fieldName - Blob field name
+ * @returns {stream.Stream}
+ */
+RecordReference.prototype.blob = function(fieldName) {
+  var url = [ this._conn._baseUrl(), 'sobjects', this.type, this.id, fieldName ].join('/');
+  return this._conn.request(url).stream();
+};

package/lib/registry/file-registry.js

@@ -0,0 +1,48 @@
+var inherits = require('inherits');
+var fs = require('fs');
+var path = require('path');
+var Registry = require('./registry');
+
+/* ------------------------------------------------------------------------- */
+
+var FileRegistry = function(configFilePath) {
+  FileRegistry.super_.call(this);
+  this._configFilePath = configFilePath || this._getDefaultConfigFilePath();
+  try {
+    var data = fs.readFileSync(this._configFilePath, 'utf-8');
+    this._registryConfig = JSON.parse(data);
+  } catch(e) {}
+};
+
+inherits(FileRegistry, Registry);
+
+/**
+ *
+ */
+FileRegistry.prototype._getDefaultConfigFilePath = function() {
+  var homeDir = process.env[(process.platform === 'win32') ? 'USERPROFILE' : 'HOME'];
+  var configDir = homeDir + "/.jsforce";
+  return configDir + "/config.json";
+};
+
+/**
+ * @private
+ */
+FileRegistry.prototype._saveConfig = function() {
+  var data = JSON.stringify(this._registryConfig, null, 4);
+  try {
+    fs.writeFileSync(this._configFilePath, data);
+    fs.chmodSync(this._configFilePath, "600");
+  } catch(e) {
+    var configDir = path.dirname(this._configFilePath);
+    fs.mkdirSync(configDir);
+    fs.chmodSync(configDir, "700");
+    fs.writeFileSync(this._configFilePath, data);
+    fs.chmodSync(this._configFilePath, "600");
+  }
+};
+
+/**
+ *
+ */
+module.exports = FileRegistry;

package/lib/registry/index.js

@@ -0,0 +1,3 @@
+var jsforce = require('../core');
+var FileRegistry = require('./file-registry');
+jsforce.registry = new FileRegistry();

package/lib/registry/registry.js

@@ -0,0 +1,111 @@
+/*global process */
+/**
+ * @file Registry for connection information, cached in local file system
+ * @author Shinichi Tomita <shinichi.tomita@gmail.com>
+ */
+
+'use strict';
+
+var _  = require('lodash/core');
+var Connection = require('../connection');
+
+/*  */
+var Registry = function(configFilePath) {
+  this._registryConfig = {};
+};
+
+/**
+ * @private
+ * @override
+ */
+Registry.prototype._saveConfig = function() {
+  throw new Error('_saveConfig must be implemented in subclass');
+};
+
+Registry.prototype._getClients = function() {
+  return this._registryConfig.clients || (this._registryConfig.clients = {});
+};
+
+Registry.prototype._getConnections = function() {
+  return this._registryConfig.connections || (this._registryConfig.connections = {});
+};
+
+Registry.prototype.getConnectionNames = function() {
+  return Object.keys(this._getConnections());
+};
+
+Registry.prototype.getConnection = function(name) {
+  return new Connection(this.getConnectionConfig(name));
+};
+
+Registry.prototype.getConnectionConfig = function(name) {
+  if (!name) { name = this._registryConfig["default"]; }
+  var connections = this._getConnections();
+  var connConfig = connections[name];
+  if (connConfig) {
+    connConfig = _.clone(connConfig);
+    if (connConfig.client) {
+      connConfig.oauth2 = _.clone(this.getClient(connConfig.client));
+    }
+    delete connConfig.client;
+  }
+  return connConfig;
+};
+
+Registry.prototype.saveConnectionConfig = function(name, connConfig) {
+  var connections = this._getConnections();
+  connConfig = _.clone(connConfig);
+  if (connConfig.oauth2) {
+    var clientName = this._findClientName(connConfig.oauth2);
+    if (clientName) {
+      connConfig.client = clientName;
+    }
+    delete connConfig.oauth2;
+  }
+  connections[name] = connConfig;
+  this._saveConfig();
+};
+
+Registry.prototype._findClientName = function(clientConfig) {
+  var clients = this._getClients();
+  for (var name in clients) {
+    var client = clients[name];
+    if (client.clientId === clientConfig.clientId &&
+        (client.loginUrl || 'https://login.salesforce.com') === clientConfig.loginUrl) {
+      return name;
+    }
+  }
+  return null;
+};
+
+Registry.prototype.setDefaultConnection = function(name) {
+  this._registryConfig["default"] = name;
+  this._saveConfig();
+};
+
+Registry.prototype.removeConnectionConfig = function(name) {
+  var connections = this._getConnections();
+  delete connections[name];
+  this._saveConfig();
+};
+
+Registry.prototype.getClient = function(name) {
+  var clientConfig = this._getClients()[name];
+  return clientConfig && _.clone(clientConfig);
+};
+
+Registry.prototype.getClientNames = function() {
+  return Object.keys(this._getClients());
+};
+
+Registry.prototype.registerClient = function(name, clientConfig) {
+  var clients = this._getClients();
+  clients[name] = clientConfig;
+  this._saveConfig();
+};
+
+
+
+/* ------------------------------------------------------------------------- */
+
+module.exports = Registry;

package/lib/require.js

@@ -0,0 +1,14 @@
+'use strict';
+
+var required = require('./_required');
+
+module.exports = function(name) {
+  if (name === './jsforce' || name === 'jsforce') {
+    name = './core';
+  }
+  var m = required[name];
+  if (typeof m === 'undefined') {
+    throw new Error("Cannot find module '" + name + "'");
+  }
+  return m;
+};