datastore-api 2.2.0 → 4.0.3

package/dist/datastore-api.cjs.development.js

@@ -0,0 +1,1436 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var async_hooks = require('async_hooks');
+var promises = require('timers/promises');
+var datastore = require('@google-cloud/datastore');
+var entity = require('@google-cloud/datastore/build/src/entity');
+var assertateDebug = require('assertate-debug');
+var Debug = require('debug');
+var promClient = require('prom-client');
+
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: !0,
+      configurable: !0,
+      writable: !0
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw new Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: !0
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(!0);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = !1, next;
+            return next.value = t, next.done = !0, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: !0
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: !0
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    void 0 === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = !1, next;
+      }
+      return next.done = !0, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
+          } else {
+            if (!u) throw new Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw new Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+  try {
+    var info = gen[key](arg);
+    var value = info.value;
+  } catch (error) {
+    reject(error);
+    return;
+  }
+  if (info.done) {
+    resolve(value);
+  } else {
+    Promise.resolve(value).then(_next, _throw);
+  }
+}
+function _asyncToGenerator(fn) {
+  return function () {
+    var self = this,
+      args = arguments;
+    return new Promise(function (resolve, reject) {
+      var gen = fn.apply(self, args);
+      function _next(value) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+      }
+      function _throw(err) {
+        asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+      }
+      _next(undefined);
+    });
+  };
+}
+function _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _inheritsLoose(subClass, superClass) {
+  subClass.prototype = Object.create(superClass.prototype);
+  subClass.prototype.constructor = subClass;
+  _setPrototypeOf(subClass, superClass);
+}
+function _getPrototypeOf(o) {
+  _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function _getPrototypeOf(o) {
+    return o.__proto__ || Object.getPrototypeOf(o);
+  };
+  return _getPrototypeOf(o);
+}
+function _setPrototypeOf(o, p) {
+  _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function _setPrototypeOf(o, p) {
+    o.__proto__ = p;
+    return o;
+  };
+  return _setPrototypeOf(o, p);
+}
+function _isNativeReflectConstruct() {
+  if (typeof Reflect === "undefined" || !Reflect.construct) return false;
+  if (Reflect.construct.sham) return false;
+  if (typeof Proxy === "function") return true;
+  try {
+    Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {}));
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+function _construct(Parent, args, Class) {
+  if (_isNativeReflectConstruct()) {
+    _construct = Reflect.construct.bind();
+  } else {
+    _construct = function _construct(Parent, args, Class) {
+      var a = [null];
+      a.push.apply(a, args);
+      var Constructor = Function.bind.apply(Parent, a);
+      var instance = new Constructor();
+      if (Class) _setPrototypeOf(instance, Class.prototype);
+      return instance;
+    };
+  }
+  return _construct.apply(null, arguments);
+}
+function _isNativeFunction(fn) {
+  try {
+    return Function.toString.call(fn).indexOf("[native code]") !== -1;
+  } catch (e) {
+    return typeof fn === "function";
+  }
+}
+function _wrapNativeSuper(Class) {
+  var _cache = typeof Map === "function" ? new Map() : undefined;
+  _wrapNativeSuper = function _wrapNativeSuper(Class) {
+    if (Class === null || !_isNativeFunction(Class)) return Class;
+    if (typeof Class !== "function") {
+      throw new TypeError("Super expression must either be null or a function");
+    }
+    if (typeof _cache !== "undefined") {
+      if (_cache.has(Class)) return _cache.get(Class);
+      _cache.set(Class, Wrapper);
+    }
+    function Wrapper() {
+      return _construct(Class, arguments, _getPrototypeOf(this).constructor);
+    }
+    Wrapper.prototype = Object.create(Class.prototype, {
+      constructor: {
+        value: Wrapper,
+        enumerable: false,
+        writable: true,
+        configurable: true
+      }
+    });
+    return _setPrototypeOf(Wrapper, Class);
+  };
+  return _wrapNativeSuper(Class);
+}
+function _assertThisInitialized(self) {
+  if (self === void 0) {
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  }
+  return self;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+/** @ignore */
+var debug = /*#__PURE__*/Debug('ds:api');
+/** @ignore */
+var transactionAsyncLocalStorage = /*#__PURE__*/new async_hooks.AsyncLocalStorage();
+/** @ignore */
+var metricHistogram = /*#__PURE__*/new promClient.Histogram({
+  name: 'dstore_requests_seconds',
+  help: 'How long did Datastore operations take?',
+  labelNames: ['operation']
+});
+var metricFailureCounter = /*#__PURE__*/new promClient.Counter({
+  name: 'dstore_failures_total',
+  help: 'How many Datastore operations failed?',
+  labelNames: ['operation']
+});
+/** Use instead of Datastore.KEY
+ *
+ * Even better: use `_key` instead.
+ */
+var KEYSYM = datastore.Datastore.KEY;
+/** Dstore implements a slightly more accessible version of the [Google Cloud Datastore: Node.js Client](https://cloud.google.com/nodejs/docs/reference/datastore/latest)
+
+[@google-cloud/datastore](https://github.com/googleapis/nodejs-datastore#readme) is a strange beast: [The documentation is auto generated](https://cloud.google.com/nodejs/docs/reference/datastore/latest) and completely shy of documenting any advanced concepts.
+(Example: If you ask the datastore to auto-generate keys during save: how do you retrieve the generated key?) Generally I suggest to look at the Python 2.x [db](https://cloud.google.com/appengine/docs/standard/python/datastore/api-overview) and [ndb](https://cloud.google.com/appengine/docs/standard/python/ndb) documentation to get a better explanation of the workings of the datastore.
+
+Also the typings are strange. The Google provided type `Entities` can be the on disk representation, the same but including a key reference (`Datastore.KEY` - [[IDstoreEntry]]), a list of these  or a structured object containing the on disk representation under the `data` property and a `key` property and maybe some configuration like `excludeFromIndexes` ([[DstoreSaveEntity]]) or a list of these.
+
+KvStore tries to abstract away most surprises the datastore provides to you but als tries to stay as API compatible as possible to [@google-cloud/datastore](https://github.com/googleapis/nodejs-datastore).
+
+Main differences:
+
+- Everything asynchronous is Promise-based - no callbacks.
+- [[get]] always returns a single [[IDstoreEntry]].
+- [[getMulti]] always returns an Array<[[IDstoreEntry]]> of the same length as the input Array. Items not found are represented by null.
+- [[set]] is called with `(key, value)` and always returns the complete [[Key]] of the entity being written. Keys are normalized, numeric IDs are always encoded as strings.
+- [[key]] handles [[Key]] object instantiation for you.
+- [[readKey]] extracts the key from an [[IDstoreEntry]] you have read without the need of fancy `Symbol`-based access to `entity[Datastore.KEY]`. If needed, it tries to deserialize `_keyStr` to create `entity[Datastore.KEY]`. This ist important when rehydrating an [[IDstoreEntry]] from a serializing cache.
+- [[allocateOneId]] returns a single numeric string encoded unique datastore id without the need of fancy unpacking.
+- [[runInTransaction]] allows you to provide a function to be executed inside an transaction without the need of passing around the transaction object. This is modelled after Python 2.7 [ndb's `@ndb.transactional` feature](https://cloud.google.com/appengine/docs/standard/python/ndb/transactions). This is implemented via node's [AsyncLocalStorage](https://nodejs.org/docs/latest-v14.x/api/async_hooks.html).
+- [[keySerialize]] is synchronous.
+
+This documentation also tries to document the little known idiosyncrasies of the [@google-cloud/datastore](https://github.com/googleapis/nodejs-datastore) library. See the corresponding functions.
+*/
+var Dstore = /*#__PURE__*/function () {
+  /** Generate a Dstore instance for a specific [[Datastore]] instance.
+     ```
+  const dstore = Dstore(new Datastore())
+  ```
+     You are encouraged to provide the second parameter to provide the ProjectID. This makes [[keySerialize]] more robust. Usually you can get this from the Environment:
+     ```
+  const dstore = Dstore(new Datastore(), process.env.GCLOUD_PROJECT)
+     @param datastore A [[Datastore]] instance. Can be freely accessed by the client. Be aware that using this inside [[runInTransaction]] ignores the transaction.
+  @param projectId The `GCLOUD_PROJECT ID`. Used for Key generation during serialization.
+  ```
+  */
+  function Dstore(datastore, projectId, logger) {
+    this.datastore = void 0;
+    this.projectId = void 0;
+    this.logger = void 0;
+    this.engine = 'Dstore';
+    this.engines = [];
+    this.urlSaveKey = new entity.entity.URLSafeKey();
+    this.datastore = datastore;
+    this.projectId = projectId;
+    this.logger = logger;
+    assertateDebug.assertIsObject(datastore);
+    this.engines.push(this.engine);
+  }
+  /** Gets the Datastore or the current Transaction. */
+  var _proto = Dstore.prototype;
+  _proto.getDoT = function getDoT() {
+    return transactionAsyncLocalStorage.getStore() || this.datastore;
+  }
+  /** `key()` creates a [[Key]] Object from a path.
+   *
+   * Compatible to [Datastore.key](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_key_member_1_)
+   *
+   * If the Path has an odd number of elements, it is considered an incomplete Key. This can only be used for saving and will prompt the Datastore to auto-generate an (random) ID. See also [[save]].
+   *
+   * @category Datastore Drop-In
+   */;
+  _proto.key = function key(path) {
+    return this.datastore.key(path);
+  }
+  /** `keyFromSerialized()` serializes [[Key]] to a string.
+   *
+   * Compatible to [keyToLegacyUrlSafe](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_keyToLegacyUrlSafe_member_1_), but does not support the "locationPrefix" since the use for this parameter is undocumented and unknown. It seems to be an artifact from early App Engine days.
+   *
+   * It can be a synchronous function because it does not look up the `projectId`. Instead it is assumed, that you give the `projectId` upon instantiation of [[Dstore]]. It also seems, that a wrong `projectId` bears no ill effects.
+   *
+   * @category Datastore Drop-In
+   */;
+  _proto.keySerialize = function keySerialize(key) {
+    var _this$projectId;
+    return key ? this.urlSaveKey.legacyEncode((_this$projectId = this.projectId) != null ? _this$projectId : '', key) : '';
+  }
+  /** `keyFromSerialized()` deserializes a string created with [[keySerialize]] to a [[Key]].
+   *
+   * Compatible to [keyFromLegacyUrlsafe](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_keyFromLegacyUrlsafe_member_1_).
+   *
+   * @category Datastore Drop-In
+   */;
+  _proto.keyFromSerialized = function keyFromSerialized(text) {
+    return this.urlSaveKey.legacyDecode(text);
+  }
+  /** `readKey()` extracts the [[Key]] from an [[IDstoreEntry]].
+   *
+   * Is is an alternative to `entity[Datastore.KEY]` which tends to fail in various contexts and also confuses older Typescript compilers.
+   * It can extract the [[Key]] form a [[IDstoreEntry]] which has been serialized to JSON by leveraging the property `_keyStr`.
+   *
+   * @category Additional
+   */;
+  _proto.readKey = function readKey(ent) {
+    assertateDebug.assertIsObject(ent);
+    var ret = ent[datastore.Datastore.KEY];
+    if (ent._keyStr && !ret) {
+      ret = this.keyFromSerialized(ent._keyStr);
+    }
+    assertateDebug.assertIsObject(ret, 'entity[Datastore.KEY]/entity._keyStr', "Entity is missing the datastore Key: " + JSON.stringify(ent));
+    return ret;
+  }
+  /** `fixKeys()` is called for all [[IDstoreEntry]]sa returned from [[Dstore]].
+   *
+   * Is ensures that besides `entity[Datastore.KEY]` there is `_keyStr` to be leveraged by [[readKey]].
+   *
+   * @internal
+   */;
+  _proto.fixKeys = function fixKeys(entities) {
+    var _this = this;
+    entities.forEach(function (x) {
+      if (!!(x != null && x[datastore.Datastore.KEY]) && x[datastore.Datastore.KEY]) {
+        assertateDebug.assertIsDefined(x[datastore.Datastore.KEY]);
+        assertateDebug.assertIsObject(x[datastore.Datastore.KEY]);
+        // Old TypesScript has problems with symbols as a property
+        x._keyStr = _this.keySerialize(x[datastore.Datastore.KEY]);
+      }
+    });
+    return entities;
+  }
+  /** `get()` reads a [[IDstoreEntry]] from the Datastore.
+   *
+   * It returns [[IDstoreEntry]] or `null` if not found.
+      * The underlying Datastore API Call is [lookup](https://cloud.google.com/datastore/docs/reference/data/rest/v1/projects/lookup).
+   *
+   * It is in the Spirit of [Datastore.get()]. Unfortunately currently (late 2021) there is no formal documentation from Google on [Datastore.get()].
+   *
+   * Differences between [[Dstore.get]] and [[Datastore.get]]:
+   *
+   * - [Dstore.get]] takes a single [[Key]] as Parameter, no Array. Check [[getMulti]] if you want Arrays.
+   * - [Dstore.get]] returns a single [[IDstoreEntry]], no Array.
+   *
+   * @category Datastore Drop-In
+   */;
+  _proto.get =
+  /*#__PURE__*/
+  function () {
+    var _get = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(key) {
+      var result;
+      return _regeneratorRuntime().wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            assertateDebug.assertIsObject(key);
+            assertateDebug.assert(!Array.isArray(key));
+            assertateDebug.assert(key.path.length % 2 == 0, "key.path must be complete: " + JSON.stringify(key.path));
+            _context.next = 5;
+            return this.getMulti([key]);
+          case 5:
+            result = _context.sent;
+            return _context.abrupt("return", (result == null ? void 0 : result[0]) || null);
+          case 7:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee, this);
+    }));
+    function get(_x) {
+      return _get.apply(this, arguments);
+    }
+    return get;
+  }()
+  /** `getMulti()` reads several [[IDstoreEntry]]s from the Datastore.
+   *
+   * It returns a list of [[IDstoreEntry]]s or `undefined` if not found. Entries are in the same Order as the keys in the Parameter.
+   * This is different from the @google-cloud/datastore where not found items are not present in the result and the order in the result list is undefined.
+   *
+   * The underlying Datastore API Call is [lookup](https://cloud.google.com/datastore/docs/reference/data/rest/v1/projects/lookup).
+   *
+   * It is in the Spirit of [Datastore.get()]. Unfortunately currently (late 2021) there is no formal documentation from Google on [Datastore.get()].
+   *
+   * Differences between [[Dstore.getMulti]] and [[Datastore.get]]:
+   *
+   * - [[Dstore.getMulti]] always takes an Array of [[Key]]s as Parameter.
+   * - [[Dstore.getMulti]] returns always a Array of [[IDstoreEntry]], or null.
+   * - [[Datastore.get]] has many edge cases - e.g. when not being able to find any of the provided keys - which return surprising results. [[Dstore.getMulti]] always returns an Array. TODO: return a Array with the same length as the Input.
+   *
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto.getMulti =
+  /*#__PURE__*/
+  function () {
+    var _getMulti = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(keys) {
+      var results, metricEnd, _yield$this$getDoT$ge, entities, entitiesByKey;
+      return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+        while (1) switch (_context2.prev = _context2.next) {
+          case 0:
+            // assertIsArray(keys);
+            metricEnd = metricHistogram.startTimer();
+            _context2.prev = 1;
+            _context2.t0 = this;
+            if (!(keys.length > 0)) {
+              _context2.next = 15;
+              break;
+            }
+            _context2.next = 6;
+            return this.getDoT().get(keys);
+          case 6:
+            _context2.t2 = _yield$this$getDoT$ge = _context2.sent;
+            if (!(_context2.t2 == null)) {
+              _context2.next = 11;
+              break;
+            }
+            _context2.t3 = void 0;
+            _context2.next = 12;
+            break;
+          case 11:
+            _context2.t3 = _yield$this$getDoT$ge[0];
+          case 12:
+            _context2.t1 = _context2.t3;
+            _context2.next = 16;
+            break;
+          case 15:
+            _context2.t1 = [];
+          case 16:
+            _context2.t4 = _context2.t1;
+            results = _context2.t0.fixKeys.call(_context2.t0, _context2.t4);
+            _context2.next = 26;
+            break;
+          case 20:
+            _context2.prev = 20;
+            _context2.t5 = _context2["catch"](1);
+            metricFailureCounter.inc({
+              operation: 'get'
+            });
+            _context2.next = 25;
+            return promises.setImmediate();
+          case 25:
+            throw new DstoreError('datastore.getMulti error', _context2.t5, {
+              keys: keys
+            });
+          case 26:
+            _context2.prev = 26;
+            metricEnd({
+              operation: 'get'
+            });
+            return _context2.finish(26);
+          case 29:
+            // Sort resulting entities by the keys they were requested with.
+            assertateDebug.assertIsArray(results);
+            entities = results;
+            entitiesByKey = {};
+            entities.forEach(function (entity) {
+              entitiesByKey[JSON.stringify(entity[datastore.Datastore.KEY])] = entity;
+            });
+            return _context2.abrupt("return", keys.map(function (key) {
+              return entitiesByKey[JSON.stringify(key)] || null;
+            }));
+          case 34:
+          case "end":
+            return _context2.stop();
+        }
+      }, _callee2, this, [[1, 20, 26, 29]]);
+    }));
+    function getMulti(_x2) {
+      return _getMulti.apply(this, arguments);
+    }
+    return getMulti;
+  }()
+  /** `set()` is addition to [[Datastore]]. It provides a classic Key-value Interface.
+   *
+   * Instead providing a nested [[DstoreSaveEntity]] to [[save]] you can call set directly as `set( key, value)`.
+   * Observe that set takes a [[Key]] as first parameter. you call it like this;
+   *
+   * ```js
+   * const ds = Dstore()
+   * ds.set(ds.key('kind', '123'), {props1: 'foo', prop2: 'bar'})
+   * ```
+   *
+   * It returns the [[Key]] of the Object being written.
+   * If the Key provided was an incomplete [[Key]] it will return a completed [[Key]].
+   * See [[save]] for more information on key generation.
+   *
+   * @category Additional
+   */
+  ;
+  _proto.set =
+  /*#__PURE__*/
+  function () {
+    var _set = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(key, data) {
+      var saveEntity;
+      return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+        while (1) switch (_context3.prev = _context3.next) {
+          case 0:
+            assertateDebug.assertIsObject(key);
+            assertateDebug.assertIsObject(data);
+            saveEntity = {
+              key: key,
+              data: data
+            };
+            _context3.next = 5;
+            return this.save([saveEntity]);
+          case 5:
+            return _context3.abrupt("return", saveEntity.key);
+          case 6:
+          case "end":
+            return _context3.stop();
+        }
+      }, _callee3, this);
+    }));
+    function set(_x3, _x4) {
+      return _set.apply(this, arguments);
+    }
+    return set;
+  }()
+  /** `save()` is compatible to [Datastore.save()](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_save_member_1_).
+   *
+   * The single Parameter is a list of [[DstoreSaveEntity]]s.
+   * If called within a transaction it returns `undefined`.
+   * If not, it returns a [[CommitResponse]] which is not documented by Google.
+   *
+   * Different [DstoreSaveEntity]]s in the `entities` parameter can have different values in their [[DstoreSaveEntity.method]] property.
+   * This allows you to do `insert`, `update` and `upsert` (the default) in a single request.
+   *
+   * `save()` seems to basically be an alias to [upsert](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_upsert_member_1_).
+   *
+   * If the [[Key]] provided in [[DstoreSaveEntity.key]] was an incomplete [[Key]] it will be updated by `save()` inside the [[DstoreSaveEntity]].
+   *
+   * If the Datastore generates a new ID because of an incomplete [[Key]] *on first save* it will return an large integer as [[Key.id]].
+   * On every subsequent `save()` an string encoded number representation is returned.
+   * @todo Dstore should normalizes that and always return an string encoded number representation.
+   *
+   * Each [[DstoreSaveEntity]] can have an `excludeFromIndexes` property which is somewhat underdocumented.
+   * It can use something like JSON-Path notation
+   * ([Source](https://github.com/googleapis/nodejs-datastore/blob/2941f2f0f132b41534e303d441d837051ce88fd7/src/index.ts#L948))
+   * [.*](https://github.com/googleapis/nodejs-datastore/blob/406b15d2014087172df617c6e0a397a2c0902c5f/test/index.ts#L1598),
+   * [parent[]](https://github.com/googleapis/nodejs-datastore/blob/406b15d2014087172df617c6e0a397a2c0902c5f/test/index.ts#L1672),
+   * [parent.*](https://github.com/googleapis/nodejs-datastore/blob/406b15d2014087172df617c6e0a397a2c0902c5f/test/index.ts#L1672),
+   * [parent[].*](https://github.com/googleapis/nodejs-datastore/blob/406b15d2014087172df617c6e0a397a2c0902c5f/test/index.ts#L1672)
+   * and [more complex patterns](https://github.com/googleapis/nodejs-datastore/blob/406b15d2014087172df617c6e0a397a2c0902c5f/test/index.ts#L1754)
+   * seem to be supported patterns.
+   *
+   * If the caller has not provided an `excludeLargeProperties` in a [[DstoreSaveEntity]] we will default it
+   * to `excludeLargeProperties: true`. Without this you can not store strings longer than 1500 bytes easily
+   * ([source](https://github.com/googleapis/nodejs-datastore/blob/c7a08a8382c6706ccbfbbf77950babf40bac757c/src/entity.ts#L961)).
+   *
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto.save =
+  /*#__PURE__*/
+  function () {
+    var _save = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(entities) {
+      var ret, metricEnd, _iterator, _step, e, _iterator2, _step2, _e;
+      return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+        while (1) switch (_context4.prev = _context4.next) {
+          case 0:
+            assertateDebug.assertIsArray(entities);
+            metricEnd = metricHistogram.startTimer();
+            _context4.prev = 2;
+            // Within Transaction we don't get any answer here!
+            // [ { mutationResults: [ [Object], [Object] ], indexUpdates: 51 } ]
+            for (_iterator = _createForOfIteratorHelperLoose(entities); !(_step = _iterator()).done;) {
+              e = _step.value;
+              assertateDebug.assertIsObject(e.key);
+              assertateDebug.assertIsObject(e.data);
+              this.fixKeys([e.data]);
+              e.excludeLargeProperties = e.excludeLargeProperties === undefined ? true : e.excludeLargeProperties;
+              e.data = _extends({}, e.data, {
+                _keyStr: undefined
+              });
+            }
+            _context4.next = 6;
+            return this.getDoT().save(entities);
+          case 6:
+            _context4.t0 = _context4.sent;
+            if (_context4.t0) {
+              _context4.next = 9;
+              break;
+            }
+            _context4.t0 = undefined;
+          case 9:
+            ret = _context4.t0;
+            for (_iterator2 = _createForOfIteratorHelperLoose(entities); !(_step2 = _iterator2()).done;) {
+              _e = _step2.value;
+              _e.data[datastore.Datastore.KEY] = _e.key;
+              this.fixKeys([_e.data]);
+            }
+            _context4.next = 19;
+            break;
+          case 13:
+            _context4.prev = 13;
+            _context4.t1 = _context4["catch"](2);
+            metricFailureCounter.inc({
+              operation: 'save'
+            });
+            _context4.next = 18;
+            return promises.setImmediate();
+          case 18:
+            throw new DstoreError('datastore.save error', _context4.t1);
+          case 19:
+            _context4.prev = 19;
+            metricEnd({
+              operation: 'save'
+            });
+            return _context4.finish(19);
+          case 22:
+            return _context4.abrupt("return", ret);
+          case 23:
+          case "end":
+            return _context4.stop();
+        }
+      }, _callee4, this, [[2, 13, 19, 22]]);
+    }));
+    function save(_x5) {
+      return _save.apply(this, arguments);
+    }
+    return save;
+  }()
+  /** `insert()` is compatible to [Datastore.insert()](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_insert_member_1_).
+   *
+   * The single Parameter is a list of [[DstoreSaveEntity]]s.
+   * If called within a transaction it returns `undefined`.
+   * If not, it returns a [[CommitResponse]] which is not documented by Google.
+   *
+   * `insert()` seems to be like [[save]] where [[DstoreSaveEntity.method]] is set to `'insert'`. It throws an [[DstoreError]] if there is already a Entity with the same [[Key]] in the Datastore.
+   *
+   * For handling of incomplete [[Key]]s see [[save]].
+   *
+   * This function can be completely emulated by using [[save]] with `method: 'insert'` inside each [[DstoreSaveEntity]].
+   * Prefer using `save()` because it is much better tested.
+   *
+   *     await ds.insert([{key: ds.key(['testKind', 123]), entity: {data:' 123'}}])
+   *
+   * @throws [[DstoreError]]
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto.insert =
+  /*#__PURE__*/
+  function () {
+    var _insert = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(entities) {
+      var ret, metricEnd;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) switch (_context5.prev = _context5.next) {
+          case 0:
+            assertateDebug.assertIsArray(entities);
+            metricEnd = metricHistogram.startTimer();
+            _context5.prev = 2;
+            _context5.next = 5;
+            return this.getDoT().insert(entities);
+          case 5:
+            _context5.t0 = _context5.sent;
+            if (_context5.t0) {
+              _context5.next = 8;
+              break;
+            }
+            _context5.t0 = undefined;
+          case 8:
+            ret = _context5.t0;
+            _context5.next = 17;
+            break;
+          case 11:
+            _context5.prev = 11;
+            _context5.t1 = _context5["catch"](2);
+            // console.error(error)
+            metricFailureCounter.inc({
+              operation: 'insert'
+            });
+            _context5.next = 16;
+            return promises.setImmediate();
+          case 16:
+            throw new DstoreError('datastore.insert error', _context5.t1);
+          case 17:
+            _context5.prev = 17;
+            metricEnd({
+              operation: 'insert'
+            });
+            return _context5.finish(17);
+          case 20:
+            return _context5.abrupt("return", ret);
+          case 21:
+          case "end":
+            return _context5.stop();
+        }
+      }, _callee5, this, [[2, 11, 17, 20]]);
+    }));
+    function insert(_x6) {
+      return _insert.apply(this, arguments);
+    }
+    return insert;
+  }()
+  /** `update()` is compatible to [Datastore.update()](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_update_member_1_).
+      * The single Parameter is a list of [[DstoreSaveEntity]]s.
+   * If called within a transaction it returns `undefined`.
+   * If not, it returns a [[CommitResponse]] which is not documented by Google.
+   *
+   * `update()` seems to be like [[save]] where [[DstoreSaveEntity.method]] is set to `'update'`.
+   * It throws an [[DstoreError]] if there is no Entity with the same [[Key]] in the Datastore. `update()` *overwrites all existing data* for that [[Key]].
+   * There was an alpha functionality called `merge()` in the Datastore which read an Entity, merged it with the new data and wrote it back, but this was never documented.
+   *
+   * `update()` is idempotent. Updating the same [[Key]] twice is no error.
+   *
+   * This function can be completely emulated by using [[save]] with `method: 'update'` inside each [[DstoreSaveEntity]].
+   * Prefer using `save()` because it is much better tested.
+   *
+   * @throws [[DstoreError]]
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto.update =
+  /*#__PURE__*/
+  function () {
+    var _update = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(entities) {
+      var ret, metricEnd;
+      return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+        while (1) switch (_context6.prev = _context6.next) {
+          case 0:
+            assertateDebug.assertIsArray(entities);
+            entities.forEach(function (entity) {
+              return assertateDebug.assertIsObject(entity.key);
+            });
+            entities.forEach(function (entity) {
+              return assertateDebug.assert(entity.key.path.length % 2 == 0, "entity.key.path must be complete: " + JSON.stringify([entity.key.path, entity]));
+            });
+            metricEnd = metricHistogram.startTimer();
+            _context6.prev = 4;
+            _context6.next = 7;
+            return this.getDoT().update(entities);
+          case 7:
+            _context6.t0 = _context6.sent;
+            if (_context6.t0) {
+              _context6.next = 10;
+              break;
+            }
+            _context6.t0 = undefined;
+          case 10:
+            ret = _context6.t0;
+            _context6.next = 19;
+            break;
+          case 13:
+            _context6.prev = 13;
+            _context6.t1 = _context6["catch"](4);
+            // console.error(error)
+            metricFailureCounter.inc({
+              operation: 'update'
+            });
+            _context6.next = 18;
+            return promises.setImmediate();
+          case 18:
+            throw new DstoreError('datastore.update error', _context6.t1);
+          case 19:
+            _context6.prev = 19;
+            metricEnd({
+              operation: 'update'
+            });
+            return _context6.finish(19);
+          case 22:
+            return _context6.abrupt("return", ret);
+          case 23:
+          case "end":
+            return _context6.stop();
+        }
+      }, _callee6, this, [[4, 13, 19, 22]]);
+    }));
+    function update(_x7) {
+      return _update.apply(this, arguments);
+    }
+    return update;
+  }()
+  /** `delete()` is compatible to [Datastore.delete()].
+   *
+   * Unfortunately currently (late 2021) there is no formal documentation from Google on [Datastore.delete()].
+   *
+   * The single Parameter is a list of [[Key]]s.
+   * If called within a transaction it returns `undefined`.
+   * If not, it returns a [[CommitResponse]] which is not documented by Google.
+   *
+   * `delete()` is idempotent. Deleting the same [[Key]] twice is no error.
+   *
+   * @throws [[DstoreError]]
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto["delete"] =
+  /*#__PURE__*/
+  function () {
+    var _delete2 = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(keys) {
+      var ret, metricEnd;
+      return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+        while (1) switch (_context7.prev = _context7.next) {
+          case 0:
+            assertateDebug.assertIsArray(keys);
+            keys.forEach(function (key) {
+              return assertateDebug.assertIsObject(key);
+            });
+            keys.forEach(function (key) {
+              return assertateDebug.assert(key.path.length % 2 == 0, "key.path must be complete: " + JSON.stringify(key.path));
+            });
+            metricEnd = metricHistogram.startTimer();
+            _context7.prev = 4;
+            _context7.next = 7;
+            return this.getDoT()["delete"](keys);
+          case 7:
+            _context7.t0 = _context7.sent;
+            if (_context7.t0) {
+              _context7.next = 10;
+              break;
+            }
+            _context7.t0 = undefined;
+          case 10:
+            ret = _context7.t0;
+            _context7.next = 19;
+            break;
+          case 13:
+            _context7.prev = 13;
+            _context7.t1 = _context7["catch"](4);
+            metricFailureCounter.inc({
+              operation: 'delete'
+            });
+            _context7.next = 18;
+            return promises.setImmediate();
+          case 18:
+            throw new DstoreError('datastore.delete error', _context7.t1);
+          case 19:
+            _context7.prev = 19;
+            metricEnd({
+              operation: 'delete'
+            });
+            return _context7.finish(19);
+          case 22:
+            return _context7.abrupt("return", ret);
+          case 23:
+          case "end":
+            return _context7.stop();
+        }
+      }, _callee7, this, [[4, 13, 19, 22]]);
+    }));
+    function _delete(_x8) {
+      return _delete2.apply(this, arguments);
+    }
+    return _delete;
+  }()
+  /** `createQuery()` creates an "empty" [[Query]] Object.
+   *
+   * Compatible to [createQuery](https://cloud.google.com/nodejs/docs/reference/datastore/latest/datastore/datastore#_google_cloud_datastore_Datastore_createQuery_member_1_) in the datastore.
+   *
+   * @param kindName Name of the [[Datastore]][Kind](https://cloud.google.com/datastore/docs/concepts/entities#kinds_and_identifiers) ("Table") which should be searched.
+   *
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto.createQuery = function createQuery(kindName) {
+    try {
+      return this.getDoT().createQuery(kindName);
+    } catch (error) {
+      throw new DstoreError('datastore.createQuery error', error);
+    }
+  };
+  _proto.runQuery = /*#__PURE__*/function () {
+    var _runQuery = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(query) {
+      var ret, metricEnd, _yield$this$getDoT$ru, entities, info;
+      return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+        while (1) switch (_context8.prev = _context8.next) {
+          case 0:
+            metricEnd = metricHistogram.startTimer();
+            _context8.prev = 1;
+            _context8.next = 4;
+            return this.getDoT().runQuery(query);
+          case 4:
+            _yield$this$getDoT$ru = _context8.sent;
+            entities = _yield$this$getDoT$ru[0];
+            info = _yield$this$getDoT$ru[1];
+            ret = [this.fixKeys(entities), info];
+            _context8.next = 15;
+            break;
+          case 10:
+            _context8.prev = 10;
+            _context8.t0 = _context8["catch"](1);
+            _context8.next = 14;
+            return promises.setImmediate();
+          case 14:
+            throw new DstoreError('datastore.runQuery error', _context8.t0);
+          case 15:
+            _context8.prev = 15;
+            metricEnd({
+              operation: 'query'
+            });
+            return _context8.finish(15);
+          case 18:
+            return _context8.abrupt("return", ret);
+          case 19:
+          case "end":
+            return _context8.stop();
+        }
+      }, _callee8, this, [[1, 10, 15, 18]]);
+    }));
+    function runQuery(_x9) {
+      return _runQuery.apply(this, arguments);
+    }
+    return runQuery;
+  }()
+  /** `query()` combined [[createQuery]] and [[runQuery]] in a single call.
+   *
+   *
+   * @param kindName Name of the [[Datastore]][Kind](https://cloud.google.com/datastore/docs/concepts/entities#kinds_and_identifiers) ("Table") which should be searched.
+   * @param filters List of [[Query]] filter() calls.
+   * @param limit Maximum Number of Results to return.
+   * @param ordering List of [[Query]] order() calls.
+   * @param selection selectionList of [[Query]] select() calls.
+   * @param cursor unsupported so far.
+   *
+   * @category Datastore Drop-In
+   */
+  ;
+  _proto.query =
+  /*#__PURE__*/
+  function () {
+    var _query = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(kindName, filters, limit, ordering, selection, cursor) {
+      var q, _iterator3, _step3, filterSpec, _iterator4, _step4, orderField;
+      return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+        while (1) switch (_context9.prev = _context9.next) {
+          case 0:
+            if (filters === void 0) {
+              filters = [];
+            }
+            if (limit === void 0) {
+              limit = 2500;
+            }
+            if (ordering === void 0) {
+              ordering = [];
+            }
+            if (selection === void 0) {
+              selection = [];
+            }
+            assertateDebug.assertIsString(kindName);
+            assertateDebug.assertIsArray(filters);
+            assertateDebug.assertIsNumber(limit);
+            _context9.prev = 7;
+            q = this.createQuery(kindName);
+            for (_iterator3 = _createForOfIteratorHelperLoose(filters); !(_step3 = _iterator3()).done;) {
+              filterSpec = _step3.value;
+              assertateDebug.assertIsObject(filterSpec);
+              // @ts-ignore
+              q.filter(_construct(datastore.PropertyFilter, filterSpec));
+            }
+            for (_iterator4 = _createForOfIteratorHelperLoose(ordering); !(_step4 = _iterator4()).done;) {
+              orderField = _step4.value;
+              q.order(orderField);
+            }
+            if (limit > 0) {
+              q.limit(limit);
+            }
+            if (selection.length > 0) {
+              q.select(selection);
+            }
+            _context9.next = 15;
+            return this.runQuery(q);
+          case 15:
+            return _context9.abrupt("return", _context9.sent);
+          case 18:
+            _context9.prev = 18;
+            _context9.t0 = _context9["catch"](7);
+            _context9.next = 22;
+            return promises.setImmediate();
+          case 22:
+            throw new DstoreError('datastore.query error', _context9.t0, {
+              kindName: kindName,
+              filters: filters,
+              limit: limit,
+              ordering: ordering
+            });
+          case 23:
+          case "end":
+            return _context9.stop();
+        }
+      }, _callee9, this, [[7, 18]]);
+    }));
+    function query(_x10, _x11, _x12, _x13, _x14, _x15) {
+      return _query.apply(this, arguments);
+    }
+    return query;
+  }()
+  /** Allocate one ID in the Datastore.
+   *
+   * Currently (late 2021) there is no documentation provided by Google for the underlying node function.
+   * Check the Documentation for [the low-level function](https://cloud.google.com/datastore/docs/reference/data/rest/v1/projects/allocateIds)
+   * and [the conceptual overview](https://cloud.google.com/datastore/docs/concepts/entities#assigning_your_own_numeric_id)
+   * and [this Stackoverflow post](https://stackoverflow.com/questions/60516959/how-does-allocateids-work-in-cloud-datastore-mode).
+   *
+   * The ID is a string encoded large number. This function will never return the same ID twice for any given Datastore.
+   * If you provide a kindName the ID will be namespaced to this kind.
+   * In fact the generated ID is namespaced via an incomplete [[Key]] of the given Kind.
+   */
+  ;
+  _proto.allocateOneId =
+  /*#__PURE__*/
+  function () {
+    var _allocateOneId = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(kindName) {
+      var ret;
+      return _regeneratorRuntime().wrap(function _callee10$(_context10) {
+        while (1) switch (_context10.prev = _context10.next) {
+          case 0:
+            if (kindName === void 0) {
+              kindName = 'Numbering';
+            }
+            assertateDebug.assertIsString(kindName);
+            _context10.next = 4;
+            return this.datastore.allocateIds(this.key([kindName]), 1);
+          case 4:
+            ret = _context10.sent[0][0].id;
+            assertateDebug.assertIsString(ret);
+            return _context10.abrupt("return", ret);
+          case 7:
+          case "end":
+            return _context10.stop();
+        }
+      }, _callee10, this);
+    }));
+    function allocateOneId(_x16) {
+      return _allocateOneId.apply(this, arguments);
+    }
+    return allocateOneId;
+  }()
+  /** This tries to give high level access to transactions.
+       So called "Gross Group Transactions" are always enabled. Transactions are never Cross Project. `runInTransaction()` works only if you use the same [[KvStore] instance for all access within the Transaction.
+       [[runInTransaction]] is modelled after Python 2.7 [ndb's `@ndb.transactional` feature](https://cloud.google.com/appengine/docs/standard/python/ndb/transactions). This is based on node's [AsyncLocalStorage](https://nodejs.org/docs/latest-v14.x/api/async_hooks.html).
+       Transactions frequently fail if you try to access the same data via in a transaction. See the [Documentation on Locking](https://cloud.google.com/datastore/docs/concepts/transactions#transaction_locks) for further reference. You are advised to use [p-limit](https://github.com/sindresorhus/p-limit)(1) to serialize transactions touching the same resource. This should work nicely with node's single process model. It is a much bigger problem on shared-nothing approaches, like Python on App Engine.
+       Transactions might be wrapped in [p-retry](https://github.com/sindresorhus/p-retry) to implement automatically retrying them with exponential back-off should they fail due to contention.
+       Be aware that Transactions differ considerable between Master-Slave Datastore (very old), High Replication Datastore (old, later called [Google Cloud Datastore](https://cloud.google.com/datastore/docs/concepts/cloud-datastore-transactions)) and [Firestore in Datastore Mode](https://cloud.google.com/datastore/docs/firestore-or-datastore#in_datastore_mode) (current).
+       Most Applications today are running on "Firestore in Datastore Mode". Beware that the Datastore-Emulator fails with `error: 3 INVALID_ARGUMENT: Only ancestor queries are allowed inside transactions.` during [[runQuery]] while the Datastore on Google Infrastructure does not have such an restriction anymore as of 2022.
+    */
+  ;
+  _proto.runInTransaction =
+  /*#__PURE__*/
+  function () {
+    var _runInTransaction = /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee12(func) {
+      var ret, transaction;
+      return _regeneratorRuntime().wrap(function _callee12$(_context12) {
+        while (1) switch (_context12.prev = _context12.next) {
+          case 0:
+            transaction = this.datastore.transaction();
+            _context12.next = 3;
+            return transactionAsyncLocalStorage.run(transaction, /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee11() {
+              var _yield$transaction$ru, transactionInfo, transactionRunApiResponse, commitApiResponse, rollbackInfo;
+              return _regeneratorRuntime().wrap(function _callee11$(_context11) {
+                while (1) switch (_context11.prev = _context11.next) {
+                  case 0:
+                    _context11.next = 2;
+                    return transaction.run();
+                  case 2:
+                    _yield$transaction$ru = _context11.sent;
+                    transactionInfo = _yield$transaction$ru[0];
+                    transactionRunApiResponse = _yield$transaction$ru[1];
+                    _context11.prev = 5;
+                    _context11.next = 8;
+                    return func();
+                  case 8:
+                    ret = _context11.sent;
+                    _context11.next = 20;
+                    break;
+                  case 11:
+                    _context11.prev = 11;
+                    _context11.t0 = _context11["catch"](5);
+                    _context11.next = 15;
+                    return transaction.rollback();
+                  case 15:
+                    rollbackInfo = _context11.sent;
+                    debug('Transaction failed, rollback initiated: %O  %O %O %O', transactionInfo, transactionRunApiResponse, rollbackInfo, _context11.t0);
+                    _context11.next = 19;
+                    return promises.setImmediate();
+                  case 19:
+                    throw new DstoreError('datastore.transaction execution error', _context11.t0);
+                  case 20:
+                    _context11.prev = 20;
+                    _context11.next = 23;
+                    return transaction.commit();
+                  case 23:
+                    commitApiResponse = _context11.sent[0];
+                    _context11.next = 32;
+                    break;
+                  case 26:
+                    _context11.prev = 26;
+                    _context11.t1 = _context11["catch"](20);
+                    debug('Transaction commit failed: %O %O %O %O ret: %O', transactionInfo, transactionRunApiResponse, commitApiResponse, _context11.t1, ret);
+                    _context11.next = 31;
+                    return promises.setImmediate();
+                  case 31:
+                    throw new DstoreError('datastore.transaction execution error', _context11.t1);
+                  case 32:
+                  case "end":
+                    return _context11.stop();
+                }
+              }, _callee11, null, [[5, 11], [20, 26]]);
+            })));
+          case 3:
+            return _context12.abrupt("return", ret);
+          case 4:
+          case "end":
+            return _context12.stop();
+        }
+      }, _callee12, this);
+    }));
+    function runInTransaction(_x17) {
+      return _runInTransaction.apply(this, arguments);
+    }
+    return runInTransaction;
+  }();
+  return Dstore;
+}();
+var DstoreError = /*#__PURE__*/function (_Error) {
+  _inheritsLoose(DstoreError, _Error);
+  function DstoreError(message, originalError, extensions) {
+    var _this2$stack, _originalError$stack, _this2$stack2;
+    var _this2;
+    _this2 = _Error.call(this, message + ": " + (originalError == null ? void 0 : originalError.message)) || this;
+    // if no name provided, use the default. defineProperty ensures that it stays non-enumerable
+    _this2.extensions = void 0;
+    _this2.originalError = void 0;
+    if (!_this2.name) {
+      Object.defineProperty(_assertThisInitialized(_this2), 'name', {
+        value: 'DstoreError'
+      });
+    }
+    // metadata: Metadata { internalRepr: Map(0) {}, options: {} },
+    _this2.originalError = originalError;
+    _this2.extensions = _extends({}, extensions);
+    _this2.stack = (((_this2$stack = _this2.stack) == null ? void 0 : _this2$stack.split('\n')[0]) || '') + '\n' + ((originalError == null || (_originalError$stack = originalError.stack) == null || (_originalError$stack = _originalError$stack.split('\n')) == null || (_originalError$stack = _originalError$stack.slice(1)) == null ? void 0 : _originalError$stack.join('\n')) || '') + '\n' + (((_this2$stack2 = _this2.stack) == null || (_this2$stack2 = _this2$stack2.split('\n')) == null || (_this2$stack2 = _this2$stack2.slice(1)) == null ? void 0 : _this2$stack2.join('\n')) || '');
+    // These are usually present on Datastore Errors
+    // logger.error({ err: originalError, extensions }, message);
+    return _this2;
+  }
+  return DstoreError;
+}( /*#__PURE__*/_wrapNativeSuper(Error));
+
+Object.defineProperty(exports, 'Datastore', {
+  enumerable: true,
+  get: function () { return datastore.Datastore; }
+});
+Object.defineProperty(exports, 'Key', {
+  enumerable: true,
+  get: function () { return datastore.Key; }
+});
+Object.defineProperty(exports, 'Query', {
+  enumerable: true,
+  get: function () { return datastore.Query; }
+});
+Object.defineProperty(exports, 'Transaction', {
+  enumerable: true,
+  get: function () { return datastore.Transaction; }
+});
+exports.Dstore = Dstore;
+exports.DstoreError = DstoreError;
+exports.KEYSYM = KEYSYM;
+//# sourceMappingURL=datastore-api.cjs.development.js.map