@sanity/client 3.2.2 → 4.0.0-alpha.esm.2

package/lib/data/listen.js

@@ -1,35 +1,39 @@
 "use strict";
 
-function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.listen = listen;
 
-function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+var _observable = require("../util/observable");
 
-function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+var _eventsource = _interopRequireDefault(require("@sanity/eventsource"));
 
-var assign = require('object-assign');
+var _pick = require("../util/pick");
 
-var _require = require('../util/observable'),
-    Observable = _require.Observable;
+var _defaults = require("../util/defaults");
 
-var polyfilledEventSource = require('@sanity/eventsource');
+var _encodeQueryString = require("./encodeQueryString");
 
-var pick = require('../util/pick');
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
 
-var defaults = require('../util/defaults');
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
 
-var encodeQueryString = require('./encodeQueryString'); // Limit is 16K for a _request_, eg including headers. Have to account for an
-// unknown range of headers, but an average EventSource request from Chrome seems
-// to have around 700 bytes of cruft, so let us account for 1.2K to be "safe"
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
 
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+// Limit is 16K for a _request_, eg including headers. Have to account for an
+// unknown range of headers, but an average EventSource request from Chrome seems
+// to have around 700 bytes of cruft, so let us account for 1.2K to be "safe"
 var MAX_URL_LENGTH = 16000 - 1200;
-var EventSource = polyfilledEventSource;
+var EventSource = _eventsource.default;
 var possibleOptions = ['includePreviousRevision', 'includeResult', 'visibility', 'effectFormat', 'tag'];
 var defaultOptions = {
   includeResult: true
 };
 
-module.exports = function listen(query, params) {
+function listen(query, params) {
   var opts = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
   var _this$clientConfig = this.clientConfig,
       url = _this$clientConfig.url,
@@ -38,12 +42,12 @@ module.exports = function listen(query, params) {
       requestTagPrefix = _this$clientConfig.requestTagPrefix;
   var tag = opts.tag && requestTagPrefix ? [requestTagPrefix, opts.tag].join('.') : opts.tag;
 
-  var options = _objectSpread(_objectSpread({}, defaults(opts, defaultOptions)), {}, {
+  var options = _objectSpread(_objectSpread({}, (0, _defaults.defaults)(opts, defaultOptions)), {}, {
     tag: tag
   });
 
-  var listenOpts = pick(options, possibleOptions);
-  var qs = encodeQueryString({
+  var listenOpts = (0, _pick.pick)(options, possibleOptions);
+  var qs = (0, _encodeQueryString.encodeQueryString)({
     query: query,
     params: params,
     options: listenOpts,
@@ -52,7 +56,7 @@ module.exports = function listen(query, params) {
   var uri = "".concat(url).concat(this.getDataUrl('listen', qs));
 
   if (uri.length > MAX_URL_LENGTH) {
-    return new Observable(function (observer) {
+    return new _observable.Observable(function (observer) {
       return observer.error(new Error('Query too large for listener'));
     });
   }
@@ -71,7 +75,7 @@ module.exports = function listen(query, params) {
     };
   }
 
-  return new Observable(function (observer) {
+  return new _observable.Observable(function (observer) {
     var es = getEventSource();
     var reconnectTimer;
     var stopped = false;
@@ -154,12 +158,12 @@ module.exports = function listen(query, params) {
 
     return stop;
   });
-};
+}
 
 function parseEvent(event) {
   try {
     var data = event.data && JSON.parse(event.data) || {};
-    return assign({
+    return Object.assign({
       type: event.type
     }, data);
   } catch (err) {

package/lib/data/patch.js

@@ -1,123 +1,174 @@
 "use strict";
 
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Patch = void 0;
+
+var _getSelection = require("../util/getSelection");
+
+var _validators = require("../validators");
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-var assign = require('object-assign');
-
-var getSelection = require('../util/getSelection');
-
-var validate = require('../validators');
-
-var validateObject = validate.validateObject;
-var validateInsert = validate.validateInsert;
-
-function Patch(selection) {
-  var operations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-  var client = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
-  this.selection = selection;
-  this.operations = assign({}, operations);
-  this.client = client;
-}
-
-assign(Patch.prototype, {
-  clone: function clone() {
-    return new Patch(this.selection, assign({}, this.operations), this.client);
-  },
-  set: function set(props) {
-    return this._assign('set', props);
-  },
-  diffMatchPatch: function diffMatchPatch(props) {
-    validateObject('diffMatchPatch', props);
-    return this._assign('diffMatchPatch', props);
-  },
-  unset: function unset(attrs) {
-    if (!Array.isArray(attrs)) {
-      throw new Error('unset(attrs) takes an array of attributes to unset, non-array given');
-    }
-
-    this.operations = assign({}, this.operations, {
-      unset: attrs
-    });
-    return this;
-  },
-  setIfMissing: function setIfMissing(props) {
-    return this._assign('setIfMissing', props);
-  },
-  replace: function replace(props) {
-    validateObject('replace', props);
-    return this._set('set', {
-      $: props
-    }); // eslint-disable-line id-length
-  },
-  inc: function inc(props) {
-    return this._assign('inc', props);
-  },
-  dec: function dec(props) {
-    return this._assign('dec', props);
-  },
-  insert: function insert(at, selector, items) {
-    var _this$_assign;
-
-    validateInsert(at, selector, items);
-    return this._assign('insert', (_this$_assign = {}, _defineProperty(_this$_assign, at, selector), _defineProperty(_this$_assign, "items", items), _this$_assign));
-  },
-  append: function append(selector, items) {
-    return this.insert('after', "".concat(selector, "[-1]"), items);
-  },
-  prepend: function prepend(selector, items) {
-    return this.insert('before', "".concat(selector, "[0]"), items);
-  },
-  splice: function splice(selector, start, deleteCount, items) {
-    // Negative indexes doesn't mean the same in Sanity as they do in JS;
-    // -1 means "actually at the end of the array", which allows inserting
-    // at the end of the array without knowing its length. We therefore have
-    // to substract negative indexes by one to match JS. If you want Sanity-
-    // behaviour, just use `insert('replace', selector, items)` directly
-    var delAll = typeof deleteCount === 'undefined' || deleteCount === -1;
-    var startIndex = start < 0 ? start - 1 : start;
-    var delCount = delAll ? -1 : Math.max(0, start + deleteCount);
-    var delRange = startIndex < 0 && delCount >= 0 ? '' : delCount;
-    var rangeSelector = "".concat(selector, "[").concat(startIndex, ":").concat(delRange, "]");
-    return this.insert('replace', rangeSelector, items || []);
-  },
-  ifRevisionId: function ifRevisionId(rev) {
-    this.operations.ifRevisionID = rev;
-    return this;
-  },
-  serialize: function serialize() {
-    return assign(getSelection(this.selection), this.operations);
-  },
-  toJSON: function toJSON() {
-    return this.serialize();
-  },
-  commit: function commit() {
-    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
-
-    if (!this.client) {
-      throw new Error('No `client` passed to patch, either provide one or pass the ' + 'patch to a clients `mutate()` method');
-    }
-
-    var returnFirst = typeof this.selection === 'string';
-    var opts = assign({
-      returnFirst: returnFirst,
-      returnDocuments: true
-    }, options);
-    return this.client.mutate({
-      patch: this.serialize()
-    }, opts);
-  },
-  reset: function reset() {
-    this.operations = {};
-    return this;
-  },
-  _set: function _set(op, props) {
-    return this._assign(op, props, false);
-  },
-  _assign: function _assign(op, props) {
-    var merge = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
-    validateObject(op, props);
-    this.operations = assign({}, this.operations, _defineProperty({}, op, assign({}, merge && this.operations[op] || {}, props)));
-    return this;
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+var Patch = /*#__PURE__*/function () {
+  function Patch(selection) {
+    var operations = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var client = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;
+
+    _classCallCheck(this, Patch);
+
+    this.selection = selection;
+    this.operations = Object.assign({}, operations);
+    this.client = client;
   }
-});
-module.exports = Patch;
+
+  _createClass(Patch, [{
+    key: "clone",
+    value: function clone() {
+      return new Patch(this.selection, Object.assign({}, this.operations), this.client);
+    }
+  }, {
+    key: "set",
+    value: function set(props) {
+      return this._assign('set', props);
+    }
+  }, {
+    key: "diffMatchPatch",
+    value: function diffMatchPatch(props) {
+      (0, _validators.validateObject)('diffMatchPatch', props);
+      return this._assign('diffMatchPatch', props);
+    }
+  }, {
+    key: "unset",
+    value: function unset(attrs) {
+      if (!Array.isArray(attrs)) {
+        throw new Error('unset(attrs) takes an array of attributes to unset, non-array given');
+      }
+
+      this.operations = Object.assign({}, this.operations, {
+        unset: attrs
+      });
+      return this;
+    }
+  }, {
+    key: "setIfMissing",
+    value: function setIfMissing(props) {
+      return this._assign('setIfMissing', props);
+    }
+  }, {
+    key: "replace",
+    value: function replace(props) {
+      (0, _validators.validateObject)('replace', props);
+      return this._set('set', {
+        $: props
+      }); // eslint-disable-line id-length
+    }
+  }, {
+    key: "inc",
+    value: function inc(props) {
+      return this._assign('inc', props);
+    }
+  }, {
+    key: "dec",
+    value: function dec(props) {
+      return this._assign('dec', props);
+    }
+  }, {
+    key: "insert",
+    value: function insert(at, selector, items) {
+      var _this$_assign;
+
+      (0, _validators.validateInsert)(at, selector, items);
+      return this._assign('insert', (_this$_assign = {}, _defineProperty(_this$_assign, at, selector), _defineProperty(_this$_assign, "items", items), _this$_assign));
+    }
+  }, {
+    key: "append",
+    value: function append(selector, items) {
+      return this.insert('after', "".concat(selector, "[-1]"), items);
+    }
+  }, {
+    key: "prepend",
+    value: function prepend(selector, items) {
+      return this.insert('before', "".concat(selector, "[0]"), items);
+    }
+  }, {
+    key: "splice",
+    value: function splice(selector, start, deleteCount, items) {
+      // Negative indexes doesn't mean the same in Sanity as they do in JS;
+      // -1 means "actually at the end of the array", which allows inserting
+      // at the end of the array without knowing its length. We therefore have
+      // to substract negative indexes by one to match JS. If you want Sanity-
+      // behaviour, just use `insert('replace', selector, items)` directly
+      var delAll = typeof deleteCount === 'undefined' || deleteCount === -1;
+      var startIndex = start < 0 ? start - 1 : start;
+      var delCount = delAll ? -1 : Math.max(0, start + deleteCount);
+      var delRange = startIndex < 0 && delCount >= 0 ? '' : delCount;
+      var rangeSelector = "".concat(selector, "[").concat(startIndex, ":").concat(delRange, "]");
+      return this.insert('replace', rangeSelector, items || []);
+    }
+  }, {
+    key: "ifRevisionId",
+    value: function ifRevisionId(rev) {
+      this.operations.ifRevisionID = rev;
+      return this;
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return Object.assign((0, _getSelection.getSelection)(this.selection), this.operations);
+    }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return this.serialize();
+    }
+  }, {
+    key: "commit",
+    value: function commit() {
+      var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+      if (!this.client) {
+        throw new Error('No `client` passed to patch, either provide one or pass the ' + 'patch to a clients `mutate()` method');
+      }
+
+      var returnFirst = typeof this.selection === 'string';
+      var opts = Object.assign({
+        returnFirst: returnFirst,
+        returnDocuments: true
+      }, options);
+      return this.client.mutate({
+        patch: this.serialize()
+      }, opts);
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.operations = {};
+      return this;
+    }
+  }, {
+    key: "_set",
+    value: function _set(op, props) {
+      return this._assign(op, props, false);
+    }
+  }, {
+    key: "_assign",
+    value: function _assign(op, props) {
+      var merge = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+      (0, _validators.validateObject)(op, props);
+      this.operations = Object.assign({}, this.operations, _defineProperty({}, op, Object.assign({}, merge && this.operations[op] || {}, props)));
+      return this;
+    }
+  }]);
+
+  return Patch;
+}();
+
+exports.Patch = Patch;

package/lib/data/transaction.js

@@ -1,115 +1,161 @@
 "use strict";
 
+function _typeof(obj) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (obj) { return typeof obj; } : function (obj) { return obj && "function" == typeof Symbol && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }, _typeof(obj); }
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Transaction = void 0;
+
+var validators = _interopRequireWildcard(require("../validators"));
+
+var _patch = require("./patch");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || _typeof(obj) !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-var assign = require('object-assign');
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
 
-var validators = require('../validators');
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
 
-var Patch = require('./patch');
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
 
 var defaultMutateOptions = {
   returnDocuments: false
 };
 
-function Transaction() {
-  var operations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
-  var client = arguments.length > 1 ? arguments[1] : undefined;
-  var transactionId = arguments.length > 2 ? arguments[2] : undefined;
-  this.trxId = transactionId;
-  this.operations = operations;
-  this.client = client;
-}
-
-assign(Transaction.prototype, {
-  clone: function clone() {
-    return new Transaction(this.operations.slice(0), this.client, this.trxId);
-  },
-  create: function create(doc) {
-    validators.validateObject('create', doc);
-    return this._add({
-      create: doc
-    });
-  },
-  createIfNotExists: function createIfNotExists(doc) {
-    var op = 'createIfNotExists';
-    validators.validateObject(op, doc);
-    validators.requireDocumentId(op, doc);
-    return this._add(_defineProperty({}, op, doc));
-  },
-  createOrReplace: function createOrReplace(doc) {
-    var op = 'createOrReplace';
-    validators.validateObject(op, doc);
-    validators.requireDocumentId(op, doc);
-    return this._add(_defineProperty({}, op, doc));
-  },
-  delete: function _delete(documentId) {
-    validators.validateDocumentId('delete', documentId);
-    return this._add({
-      delete: {
-        id: documentId
-      }
-    });
-  },
-  patch: function patch(documentId, patchOps) {
-    var isBuilder = typeof patchOps === 'function';
-    var isPatch = documentId instanceof Patch; // transaction.patch(client.patch('documentId').inc({visits: 1}))
+var Transaction = /*#__PURE__*/function () {
+  function Transaction() {
+    var operations = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var client = arguments.length > 1 ? arguments[1] : undefined;
+    var transactionId = arguments.length > 2 ? arguments[2] : undefined;
 
-    if (isPatch) {
+    _classCallCheck(this, Transaction);
+
+    this.trxId = transactionId;
+    this.operations = operations;
+    this.client = client;
+  }
+
+  _createClass(Transaction, [{
+    key: "clone",
+    value: function clone() {
+      return new Transaction(this.operations.slice(0), this.client, this.trxId);
+    }
+  }, {
+    key: "create",
+    value: function create(doc) {
+      validators.validateObject('create', doc);
       return this._add({
-        patch: documentId.serialize()
+        create: doc
       });
-    } // patch => patch.inc({visits: 1}).set({foo: 'bar'})
+    }
+  }, {
+    key: "createIfNotExists",
+    value: function createIfNotExists(doc) {
+      var op = 'createIfNotExists';
+      validators.validateObject(op, doc);
+      validators.requireDocumentId(op, doc);
+      return this._add(_defineProperty({}, op, doc));
+    }
+  }, {
+    key: "createOrReplace",
+    value: function createOrReplace(doc) {
+      var op = 'createOrReplace';
+      validators.validateObject(op, doc);
+      validators.requireDocumentId(op, doc);
+      return this._add(_defineProperty({}, op, doc));
+    }
+  }, {
+    key: "delete",
+    value: function _delete(documentId) {
+      validators.validateDocumentId('delete', documentId);
+      return this._add({
+        delete: {
+          id: documentId
+        }
+      });
+    }
+  }, {
+    key: "patch",
+    value: function patch(documentId, patchOps) {
+      var isBuilder = typeof patchOps === 'function';
+      var isPatch = documentId instanceof _patch.Patch; // transaction.patch(client.patch('documentId').inc({visits: 1}))
+
+      if (isPatch) {
+        return this._add({
+          patch: documentId.serialize()
+        });
+      } // patch => patch.inc({visits: 1}).set({foo: 'bar'})
 
 
-    if (isBuilder) {
-      var patch = patchOps(new Patch(documentId, {}, this.client));
+      if (isBuilder) {
+        var patch = patchOps(new _patch.Patch(documentId, {}, this.client));
 
-      if (!(patch instanceof Patch)) {
-        throw new Error('function passed to `patch()` must return the patch');
+        if (!(patch instanceof _patch.Patch)) {
+          throw new Error('function passed to `patch()` must return the patch');
+        }
+
+        return this._add({
+          patch: patch.serialize()
+        });
       }
 
       return this._add({
-        patch: patch.serialize()
+        patch: Object.assign({
+          id: documentId
+        }, patchOps)
       });
     }
+  }, {
+    key: "transactionId",
+    value: function transactionId(id) {
+      if (!id) {
+        return this.trxId;
+      }
 
-    return this._add({
-      patch: assign({
-        id: documentId
-      }, patchOps)
-    });
-  },
-  transactionId: function transactionId(id) {
-    if (!id) {
-      return this.trxId;
+      this.trxId = id;
+      return this;
+    }
+  }, {
+    key: "serialize",
+    value: function serialize() {
+      return this.operations.slice();
     }
+  }, {
+    key: "toJSON",
+    value: function toJSON() {
+      return this.serialize();
+    }
+  }, {
+    key: "commit",
+    value: function commit(options) {
+      if (!this.client) {
+        throw new Error('No `client` passed to transaction, either provide one or pass the ' + 'transaction to a clients `mutate()` method');
+      }
 
-    this.trxId = id;
-    return this;
-  },
-  serialize: function serialize() {
-    return this.operations.slice();
-  },
-  toJSON: function toJSON() {
-    return this.serialize();
-  },
-  commit: function commit(options) {
-    if (!this.client) {
-      throw new Error('No `client` passed to transaction, either provide one or pass the ' + 'transaction to a clients `mutate()` method');
+      return this.client.mutate(this.serialize(), Object.assign({
+        transactionId: this.trxId
+      }, defaultMutateOptions, options || {}));
+    }
+  }, {
+    key: "reset",
+    value: function reset() {
+      this.operations = [];
+      return this;
+    }
+  }, {
+    key: "_add",
+    value: function _add(mut) {
+      this.operations.push(mut);
+      return this;
     }
+  }]);
 
-    return this.client.mutate(this.serialize(), assign({
-      transactionId: this.trxId
-    }, defaultMutateOptions, options || {}));
-  },
-  reset: function reset() {
-    this.operations = [];
-    return this;
-  },
-  _add: function _add(mut) {
-    this.operations.push(mut);
-    return this;
-  }
-});
-module.exports = Transaction;
+  return Transaction;
+}();
+
+exports.Transaction = Transaction;