@aws-amplify/datastore-storage-adapter 2.1.1-api-v6-models.c1977f8.0 → 2.1.1-api-v6-models.891fe0d.0

package/dist/aws-amplify-datastore-sqlite-adapter-expo.js

@@ -22,7 +22,6 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
 /* harmony export */ });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! tslib */ "../../node_modules/tslib/tslib.es6.mjs");
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var expo_file_system__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! expo-file-system */ "expo-file-system");
@@ -30,7 +29,446 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var expo_sqlite__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! expo-sqlite */ "expo-sqlite");
 /* harmony import */ var expo_sqlite__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(expo_sqlite__WEBPACK_IMPORTED_MODULE_2__);
 /* harmony import */ var _common_constants__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ../common/constants */ "./lib-esm/common/constants.js");
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
+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 _regeneratorRuntime() {
+  "use strict";
 
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+  _regeneratorRuntime = function _regeneratorRuntime() {
+    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 define(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 value(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 reset(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 stop() {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function dispatchException(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 abrupt(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 complete(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 finish(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 _catch(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 delegateYield(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 _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, _toPropertyKey(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;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
@@ -46,184 +484,283 @@ error was handled or not. Returning a true value indicates the error was handled
 rollback the whole transaction.
 
 */
-var ExpoSQLiteDatabase = /** @class */function () {
-  function ExpoSQLiteDatabase() {}
-  ExpoSQLiteDatabase.prototype.init = function () {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(this, void 0, void 0, function () {
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-        // only open database once.
-        if (!this.db) {
-          // As per expo docs version, description and size arguments are ignored,
-          // but are accepted by the function for compatibility with the WebSQL specification.
-          // Hence, we do not need those arguments.
-          this.db = (0,expo_sqlite__WEBPACK_IMPORTED_MODULE_2__.openDatabase)(_common_constants__WEBPACK_IMPORTED_MODULE_3__.DB_NAME);
-        }
-        return [2 /*return*/];
-      });
-    });
-  };
-
-  ExpoSQLiteDatabase.prototype.createSchema = function (statements) {
-    return this.executeStatements(statements);
-  };
-  ExpoSQLiteDatabase.prototype.clear = function () {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(this, void 0, void 0, function () {
-      var error_1;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            _a.trys.push([0, 3,, 4]);
-            logger.debug('Clearing database');
-            return [4 /*yield*/, this.closeDB()];
-          case 1:
-            _a.sent();
-            // delete database is not supported by expo-sqlite.
-            // Database file needs to be deleted using deleteAsync from expo-file-system
-            return [4 /*yield*/, (0,expo_file_system__WEBPACK_IMPORTED_MODULE_1__.deleteAsync)(expo_file_system__WEBPACK_IMPORTED_MODULE_1__.documentDirectory + "SQLite/" + _common_constants__WEBPACK_IMPORTED_MODULE_3__.DB_NAME)];
-          case 2:
-            // delete database is not supported by expo-sqlite.
-            // Database file needs to be deleted using deleteAsync from expo-file-system
-            _a.sent();
-            logger.debug('Database cleared');
-            return [3 /*break*/, 4];
-          case 3:
-            error_1 = _a.sent();
-            logger.warn('Error clearing the database.', error_1);
-            // open database if it was closed earlier and this.db was set to undefined.
-            this.init();
-            return [3 /*break*/, 4];
-          case 4:
-            return [2 /*return*/];
-        }
-      });
-    });
-  };
-
-  ExpoSQLiteDatabase.prototype.get = function (statement, params) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(this, void 0, void 0, function () {
-      var results;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            return [4 /*yield*/, this.getAll(statement, params)];
-          case 1:
-            results = _a.sent();
-            return [2 /*return*/, results[0]];
-        }
-      });
-    });
-  };
-  ExpoSQLiteDatabase.prototype.getAll = function (statement, params) {
-    var _this = this;
-    return new Promise(function (resolve, reject) {
-      _this.db.readTransaction(function (transaction) {
-        transaction.executeSql(statement, params, function (_, result) {
-          resolve(result.rows._array || []);
-        }, function (_, error) {
-          reject(error);
-          logger.warn(error);
-          return true;
+var ExpoSQLiteDatabase = /*#__PURE__*/function () {
+  function ExpoSQLiteDatabase() {
+    _classCallCheck(this, ExpoSQLiteDatabase);
+  }
+  _createClass(ExpoSQLiteDatabase, [{
+    key: "init",
+    value: function () {
+      var _init = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              // only open database once.
+              if (!this.db) {
+                // As per expo docs version, description and size arguments are ignored,
+                // but are accepted by the function for compatibility with the WebSQL specification.
+                // Hence, we do not need those arguments.
+                this.db = (0,expo_sqlite__WEBPACK_IMPORTED_MODULE_2__.openDatabase)(_common_constants__WEBPACK_IMPORTED_MODULE_3__.DB_NAME);
+              }
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function init() {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+  }, {
+    key: "createSchema",
+    value: function createSchema(statements) {
+      return this.executeStatements(statements);
+    }
+  }, {
+    key: "clear",
+    value: function () {
+      var _clear = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.prev = 0;
+              logger.debug('Clearing database');
+              _context2.next = 4;
+              return this.closeDB();
+            case 4:
+              _context2.next = 6;
+              return (0,expo_file_system__WEBPACK_IMPORTED_MODULE_1__.deleteAsync)("".concat(expo_file_system__WEBPACK_IMPORTED_MODULE_1__.documentDirectory, "SQLite/").concat(_common_constants__WEBPACK_IMPORTED_MODULE_3__.DB_NAME));
+            case 6:
+              logger.debug('Database cleared');
+              _context2.next = 13;
+              break;
+            case 9:
+              _context2.prev = 9;
+              _context2.t0 = _context2["catch"](0);
+              logger.warn('Error clearing the database.', _context2.t0);
+              // open database if it was closed earlier and this.db was set to undefined.
+              this.init();
+            case 13:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this, [[0, 9]]);
+      }));
+      function clear() {
+        return _clear.apply(this, arguments);
+      }
+      return clear;
+    }()
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(statement, params) {
+        var results;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.next = 2;
+              return this.getAll(statement, params);
+            case 2:
+              results = _context3.sent;
+              return _context3.abrupt("return", results[0]);
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function get(_x, _x2) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+  }, {
+    key: "getAll",
+    value: function getAll(statement, params) {
+      var _this = this;
+      return new Promise(function (resolve, reject) {
+        _this.db.readTransaction(function (transaction) {
+          transaction.executeSql(statement, params, function (_, result) {
+            resolve(result.rows._array || []);
+          }, function (_, error) {
+            reject(error);
+            logger.warn(error);
+            return true;
+          });
         });
       });
-    });
-  };
-  ExpoSQLiteDatabase.prototype.save = function (statement, params) {
-    var _this = this;
-    return new Promise(function (resolve, reject) {
-      _this.db.transaction(function (transaction) {
-        transaction.executeSql(statement, params, function () {
-          resolve(null);
-        }, function (_, error) {
-          reject(error);
-          logger.warn(error);
-          return true;
+    }
+  }, {
+    key: "save",
+    value: function save(statement, params) {
+      var _this2 = this;
+      return new Promise(function (resolve, reject) {
+        _this2.db.transaction(function (transaction) {
+          transaction.executeSql(statement, params, function () {
+            resolve(null);
+          }, function (_, error) {
+            reject(error);
+            logger.warn(error);
+            return true;
+          });
         });
       });
-    });
-  };
-  ExpoSQLiteDatabase.prototype.batchQuery = function (queryParameterizedStatements) {
-    var _this = this;
-    if (queryParameterizedStatements === void 0) {
-      queryParameterizedStatements = new Set();
     }
-    return new Promise(function (resolveTransaction, rejectTransaction) {
-      _this.db.transaction(function (transaction) {
-        return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(_this, void 0, void 0, function () {
-          var results, error_2;
-          return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                _a.trys.push([0, 2,, 3]);
-                return [4 /*yield*/, Promise.all((0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)(queryParameterizedStatements).map(function (_a) {
-                  var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__read)(_a, 2),
-                    statement = _b[0],
-                    params = _b[1];
-                  return new Promise(function (resolve, reject) {
-                    transaction.executeSql(statement, params, function (_, result) {
-                      resolve(result.rows._array[0]);
-                    }, function (_, error) {
-                      reject(error);
-                      logger.warn(error);
-                      return true;
+  }, {
+    key: "batchQuery",
+    value: function batchQuery() {
+      var _this3 = this;
+      var queryParameterizedStatements = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Set();
+      return new Promise(function (resolveTransaction, rejectTransaction) {
+        _this3.db.transaction( /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(transaction) {
+            var results;
+            return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+              while (1) switch (_context4.prev = _context4.next) {
+                case 0:
+                  _context4.prev = 0;
+                  _context4.next = 3;
+                  return Promise.all(_toConsumableArray(queryParameterizedStatements).map(function (_ref2) {
+                    var _ref3 = _slicedToArray(_ref2, 2),
+                      statement = _ref3[0],
+                      params = _ref3[1];
+                    return new Promise(function (resolve, reject) {
+                      transaction.executeSql(statement, params, function (_, result) {
+                        resolve(result.rows._array[0]);
+                      }, function (_, error) {
+                        reject(error);
+                        logger.warn(error);
+                        return true;
+                      });
                     });
-                  });
-                }))];
-              case 1:
-                results = _a.sent();
-                resolveTransaction(results);
-                return [3 /*break*/, 3];
-              case 2:
-                error_2 = _a.sent();
-                rejectTransaction(error_2);
-                logger.warn(error_2);
-                return [3 /*break*/, 3];
-              case 3:
-                return [2 /*return*/];
-            }
-          });
-        });
+                  }));
+                case 3:
+                  results = _context4.sent;
+                  resolveTransaction(results);
+                  _context4.next = 11;
+                  break;
+                case 7:
+                  _context4.prev = 7;
+                  _context4.t0 = _context4["catch"](0);
+                  rejectTransaction(_context4.t0);
+                  logger.warn(_context4.t0);
+                case 11:
+                case "end":
+                  return _context4.stop();
+              }
+            }, _callee4, null, [[0, 7]]);
+          }));
+          return function (_x3) {
+            return _ref.apply(this, arguments);
+          };
+        }());
       });
-    });
-  };
-
-  ExpoSQLiteDatabase.prototype.batchSave = function (saveParameterizedStatements, deleteParameterizedStatements) {
-    var _this = this;
-    if (saveParameterizedStatements === void 0) {
-      saveParameterizedStatements = new Set();
     }
-    return new Promise(function (resolveTransaction, rejectTransaction) {
-      _this.db.transaction(function (transaction) {
-        return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(_this, void 0, void 0, function () {
-          var error_3;
-          return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                _a.trys.push([0, 4,, 5]);
-                // await for all sql statements promises to resolve
-                return [4 /*yield*/, Promise.all((0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)(saveParameterizedStatements).map(function (_a) {
-                  var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__read)(_a, 2),
-                    statement = _b[0],
-                    params = _b[1];
+  }, {
+    key: "batchSave",
+    value: function batchSave() {
+      var _this4 = this;
+      var saveParameterizedStatements = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Set();
+      var deleteParameterizedStatements = arguments.length > 1 ? arguments[1] : undefined;
+      return new Promise(function (resolveTransaction, rejectTransaction) {
+        _this4.db.transaction( /*#__PURE__*/function () {
+          var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(transaction) {
+            return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+              while (1) switch (_context5.prev = _context5.next) {
+                case 0:
+                  _context5.prev = 0;
+                  _context5.next = 3;
+                  return Promise.all(_toConsumableArray(saveParameterizedStatements).map(function (_ref5) {
+                    var _ref6 = _slicedToArray(_ref5, 2),
+                      statement = _ref6[0],
+                      params = _ref6[1];
+                    return new Promise(function (resolve, reject) {
+                      transaction.executeSql(statement, params, function () {
+                        resolve(null);
+                      }, function (_, error) {
+                        reject(error);
+                        logger.warn(error);
+                        return true;
+                      });
+                    });
+                  }));
+                case 3:
+                  if (!deleteParameterizedStatements) {
+                    _context5.next = 6;
+                    break;
+                  }
+                  _context5.next = 6;
+                  return Promise.all(_toConsumableArray(deleteParameterizedStatements).map(function (_ref7) {
+                    var _ref8 = _slicedToArray(_ref7, 2),
+                      statement = _ref8[0],
+                      params = _ref8[1];
+                    return new Promise(function (resolve, reject) {
+                      return transaction.executeSql(statement, params, function () {
+                        resolve(null);
+                      }, function (_, error) {
+                        reject(error);
+                        logger.warn(error);
+                        return true;
+                      });
+                    });
+                  }));
+                case 6:
+                  resolveTransaction(null);
+                  _context5.next = 13;
+                  break;
+                case 9:
+                  _context5.prev = 9;
+                  _context5.t0 = _context5["catch"](0);
+                  rejectTransaction(_context5.t0);
+                  logger.warn(_context5.t0);
+                case 13:
+                case "end":
+                  return _context5.stop();
+              }
+            }, _callee5, null, [[0, 9]]);
+          }));
+          return function (_x4) {
+            return _ref4.apply(this, arguments);
+          };
+        }());
+      });
+    }
+  }, {
+    key: "selectAndDelete",
+    value: function selectAndDelete(queryParameterizedStatement, deleteParameterizedStatement) {
+      var _this5 = this;
+      var _queryParameterizedSt = _slicedToArray(queryParameterizedStatement, 2),
+        queryStatement = _queryParameterizedSt[0],
+        queryParams = _queryParameterizedSt[1];
+      var _deleteParameterizedS = _slicedToArray(deleteParameterizedStatement, 2),
+        deleteStatement = _deleteParameterizedS[0],
+        deleteParams = _deleteParameterizedS[1];
+      return new Promise(function (resolveTransaction, rejectTransaction) {
+        _this5.db.transaction( /*#__PURE__*/function () {
+          var _ref9 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(transaction) {
+            var result;
+            return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+              while (1) switch (_context6.prev = _context6.next) {
+                case 0:
+                  _context6.prev = 0;
+                  _context6.next = 3;
                   return new Promise(function (resolve, reject) {
-                    transaction.executeSql(statement, params, function () {
-                      resolve(null);
+                    transaction.executeSql(queryStatement, queryParams, function (_, result) {
+                      resolve(result.rows._array || []);
                     }, function (_, error) {
                       reject(error);
                       logger.warn(error);
                       return true;
                     });
                   });
-                }))];
-              case 1:
-                // await for all sql statements promises to resolve
-                _a.sent();
-                if (!deleteParameterizedStatements) return [3 /*break*/, 3];
-                return [4 /*yield*/, Promise.all((0,tslib__WEBPACK_IMPORTED_MODULE_4__.__spread)(deleteParameterizedStatements).map(function (_a) {
-                  var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__read)(_a, 2),
-                    statement = _b[0],
-                    params = _b[1];
+                case 3:
+                  result = _context6.sent;
+                  _context6.next = 6;
                   return new Promise(function (resolve, reject) {
-                    return transaction.executeSql(statement, params, function () {
+                    transaction.executeSql(deleteStatement, deleteParams, function () {
                       resolve(null);
                     }, function (_, error) {
                       reject(error);
@@ -231,143 +768,101 @@ var ExpoSQLiteDatabase = /** @class */function () {
                       return true;
                     });
                   });
-                }))];
-              case 2:
-                _a.sent();
-                _a.label = 3;
-              case 3:
-                resolveTransaction(null);
-                return [3 /*break*/, 5];
-              case 4:
-                error_3 = _a.sent();
-                rejectTransaction(error_3);
-                logger.warn(error_3);
-                return [3 /*break*/, 5];
-              case 5:
-                return [2 /*return*/];
-            }
-          });
-        });
-      });
-    });
-  };
-
-  ExpoSQLiteDatabase.prototype.selectAndDelete = function (queryParameterizedStatement, deleteParameterizedStatement) {
-    var _this = this;
-    var _a = (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__read)(queryParameterizedStatement, 2),
-      queryStatement = _a[0],
-      queryParams = _a[1];
-    var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__read)(deleteParameterizedStatement, 2),
-      deleteStatement = _b[0],
-      deleteParams = _b[1];
-    return new Promise(function (resolveTransaction, rejectTransaction) {
-      _this.db.transaction(function (transaction) {
-        return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(_this, void 0, void 0, function () {
-          var result, error_4;
-          return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                _a.trys.push([0, 3,, 4]);
-                return [4 /*yield*/, new Promise(function (resolve, reject) {
-                  transaction.executeSql(queryStatement, queryParams, function (_, result) {
-                    resolve(result.rows._array || []);
-                  }, function (_, error) {
-                    reject(error);
-                    logger.warn(error);
-                    return true;
-                  });
-                })];
-              case 1:
-                result = _a.sent();
-                return [4 /*yield*/, new Promise(function (resolve, reject) {
-                  transaction.executeSql(deleteStatement, deleteParams, function () {
-                    resolve(null);
-                  }, function (_, error) {
-                    reject(error);
-                    logger.warn(error);
-                    return true;
-                  });
-                })];
-              case 2:
-                _a.sent();
-                resolveTransaction(result);
-                return [3 /*break*/, 4];
-              case 3:
-                error_4 = _a.sent();
-                rejectTransaction(error_4);
-                logger.warn(error_4);
-                return [3 /*break*/, 4];
-              case 4:
-                return [2 /*return*/];
-            }
-          });
-        });
+                case 6:
+                  resolveTransaction(result);
+                  _context6.next = 13;
+                  break;
+                case 9:
+                  _context6.prev = 9;
+                  _context6.t0 = _context6["catch"](0);
+                  rejectTransaction(_context6.t0);
+                  logger.warn(_context6.t0);
+                case 13:
+                case "end":
+                  return _context6.stop();
+              }
+            }, _callee6, null, [[0, 9]]);
+          }));
+          return function (_x5) {
+            return _ref9.apply(this, arguments);
+          };
+        }());
       });
-    });
-  };
-
-  ExpoSQLiteDatabase.prototype.executeStatements = function (statements) {
-    var _this = this;
-    return new Promise(function (resolveTransaction, rejectTransaction) {
-      _this.db.transaction(function (transaction) {
-        return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(_this, void 0, void 0, function () {
-          var error_5;
-          return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-            switch (_a.label) {
-              case 0:
-                _a.trys.push([0, 2,, 3]);
-                return [4 /*yield*/, Promise.all(statements.map(function (statement) {
-                  return new Promise(function (resolve, reject) {
-                    transaction.executeSql(statement, [], function () {
-                      resolve(null);
-                    }, function (_, error) {
-                      reject(error);
-                      return true;
+    }
+  }, {
+    key: "executeStatements",
+    value: function executeStatements(statements) {
+      var _this6 = this;
+      return new Promise(function (resolveTransaction, rejectTransaction) {
+        _this6.db.transaction( /*#__PURE__*/function () {
+          var _ref10 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(transaction) {
+            return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+              while (1) switch (_context7.prev = _context7.next) {
+                case 0:
+                  _context7.prev = 0;
+                  _context7.next = 3;
+                  return Promise.all(statements.map(function (statement) {
+                    return new Promise(function (resolve, reject) {
+                      transaction.executeSql(statement, [], function () {
+                        resolve(null);
+                      }, function (_, error) {
+                        reject(error);
+                        return true;
+                      });
                     });
-                  });
-                }))];
-              case 1:
-                _a.sent();
-                resolveTransaction(null);
-                return [3 /*break*/, 3];
-              case 2:
-                error_5 = _a.sent();
-                rejectTransaction(error_5);
-                logger.warn(error_5);
-                return [3 /*break*/, 3];
-              case 3:
-                return [2 /*return*/];
-            }
-          });
-        });
-      });
-    });
-  };
-
-  ExpoSQLiteDatabase.prototype.closeDB = function () {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__awaiter)(this, void 0, void 0, function () {
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_4__.__generator)(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            if (!this.db) return [3 /*break*/, 2];
-            logger.debug('Closing Database');
-            // closing database is not supported by expo-sqlite.
-            // Workaround is to access the private db variable and call the close() method.
-            return [4 /*yield*/, this.db._db.close()];
-          case 1:
-            // closing database is not supported by expo-sqlite.
-            // Workaround is to access the private db variable and call the close() method.
-            _a.sent();
-            logger.debug('Database closed');
-            this.db = undefined;
-            _a.label = 2;
-          case 2:
-            return [2 /*return*/];
-        }
+                  }));
+                case 3:
+                  resolveTransaction(null);
+                  _context7.next = 10;
+                  break;
+                case 6:
+                  _context7.prev = 6;
+                  _context7.t0 = _context7["catch"](0);
+                  rejectTransaction(_context7.t0);
+                  logger.warn(_context7.t0);
+                case 10:
+                case "end":
+                  return _context7.stop();
+              }
+            }, _callee7, null, [[0, 6]]);
+          }));
+          return function (_x6) {
+            return _ref10.apply(this, arguments);
+          };
+        }());
       });
-    });
-  };
-
+    }
+  }, {
+    key: "closeDB",
+    value: function () {
+      var _closeDB = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              if (!this.db) {
+                _context8.next = 6;
+                break;
+              }
+              logger.debug('Closing Database');
+              // closing database is not supported by expo-sqlite.
+              // Workaround is to access the private db variable and call the close() method.
+              _context8.next = 4;
+              return this.db._db.close();
+            case 4:
+              logger.debug('Database closed');
+              this.db = undefined;
+            case 6:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function closeDB() {
+        return _closeDB.apply(this, arguments);
+      }
+      return closeDB;
+    }()
+  }]);
   return ExpoSQLiteDatabase;
 }();
 /* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (ExpoSQLiteDatabase);
@@ -384,13 +879,534 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */ __webpack_require__.d(__webpack_exports__, {
 /* harmony export */   CommonSQLiteAdapter: () => (/* binding */ CommonSQLiteAdapter)
 /* harmony export */ });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! tslib */ "../../node_modules/tslib/tslib.es6.mjs");
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @aws-amplify/core */ "@aws-amplify/core");
 /* harmony import */ var _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var _common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ../common/SQLiteUtils */ "./lib-esm/common/SQLiteUtils.js");
 /* harmony import */ var _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! @aws-amplify/datastore */ "@aws-amplify/datastore");
 /* harmony import */ var _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__);
+function _typeof(o) {
+  "@babel/helpers - typeof";
 
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function F() {};
+      return {
+        s: F,
+        n: function n() {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function e(_e) {
+          throw _e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function s() {
+      it = it.call(o);
+    },
+    n: function n() {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function e(_e2) {
+      didErr = true;
+      err = _e2;
+    },
+    f: function f() {
+      try {
+        if (!normalCompletion && it["return"] != null) it["return"]();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+function _regeneratorRuntime() {
+  "use strict";
+
+  /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
+  _regeneratorRuntime = function _regeneratorRuntime() {
+    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 define(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 value(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 reset(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 stop() {
+      this.done = !0;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function dispatchException(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 abrupt(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 complete(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 finish(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 _catch(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 delegateYield(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 _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, _toPropertyKey(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;
+}
+function _toPropertyKey(arg) {
+  var key = _toPrimitive(arg, "string");
+  return _typeof(key) === "symbol" ? key : String(key);
+}
+function _toPrimitive(input, hint) {
+  if (_typeof(input) !== "object" || input === null) return input;
+  var prim = input[Symbol.toPrimitive];
+  if (prim !== undefined) {
+    var res = prim.call(input, hint || "default");
+    if (_typeof(res) !== "object") return res;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return (hint === "string" ? String : Number)(input);
+}
+function _asyncIterator(r) {
+  var n,
+    t,
+    o,
+    e = 2;
+  for ("undefined" != typeof Symbol && (t = Symbol.asyncIterator, o = Symbol.iterator); e--;) {
+    if (t && null != (n = r[t])) return n.call(r);
+    if (o && null != (n = r[o])) return new AsyncFromSyncIterator(n.call(r));
+    t = "@@asyncIterator", o = "@@iterator";
+  }
+  throw new TypeError("Object is not async iterable");
+}
+function AsyncFromSyncIterator(r) {
+  function AsyncFromSyncIteratorContinuation(r) {
+    if (Object(r) !== r) return Promise.reject(new TypeError(r + " is not an object."));
+    var n = r.done;
+    return Promise.resolve(r.value).then(function (r) {
+      return {
+        value: r,
+        done: n
+      };
+    });
+  }
+  return AsyncFromSyncIterator = function AsyncFromSyncIterator(r) {
+    this.s = r, this.n = r.next;
+  }, AsyncFromSyncIterator.prototype = {
+    s: null,
+    n: null,
+    next: function next() {
+      return AsyncFromSyncIteratorContinuation(this.n.apply(this.s, arguments));
+    },
+    "return": function _return(r) {
+      var n = this.s["return"];
+      return void 0 === n ? Promise.resolve({
+        value: r,
+        done: !0
+      }) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+    },
+    "throw": function _throw(r) {
+      var n = this.s["return"];
+      return void 0 === n ? Promise.reject(r) : AsyncFromSyncIteratorContinuation(n.apply(this.s, arguments));
+    }
+  }, new AsyncFromSyncIterator(r);
+}
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
@@ -400,449 +1416,591 @@ var traverseModel = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.utils.tr
   validatePredicate = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.utils.validatePredicate,
   isModelConstructor = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.utils.isModelConstructor;
 var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_0__.ConsoleLogger('DataStore');
-var CommonSQLiteAdapter = /** @class */function () {
+var CommonSQLiteAdapter = /*#__PURE__*/function () {
   function CommonSQLiteAdapter(db) {
+    _classCallCheck(this, CommonSQLiteAdapter);
     this.db = db;
   }
-  CommonSQLiteAdapter.prototype.setUp = function (theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var usesCPKCodegen, statements, error_1;
-      var _this = this;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            if (!!this.initPromise) return [3 /*break*/, 1];
-            this.initPromise = new Promise(function (res, rej) {
-              _this.resolve = res;
-              _this.reject = rej;
-            });
-            return [3 /*break*/, 3];
-          case 1:
-            return [4 /*yield*/, this.initPromise];
-          case 2:
-            _a.sent();
-            return [2 /*return*/];
-          case 3:
-            this.schema = theSchema;
-            this.namespaceResolver = namespaceResolver;
-            this.modelInstanceCreator = modelInstanceCreator;
-            this.getModelConstructorByModelName = getModelConstructorByModelName;
-            _a.label = 4;
-          case 4:
-            _a.trys.push([4, 7,, 8]);
-            usesCPKCodegen = Object.values(this.schema.namespaces.user.models).some(function (model) {
-              return Object.values(model.fields).some(function (field) {
-                var _a;
-                return (_a = field.association) === null || _a === void 0 ? void 0 : _a.hasOwnProperty('targetNames');
+  _createClass(CommonSQLiteAdapter, [{
+    key: "setUp",
+    value: function () {
+      var _setUp = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
+        var _this = this;
+        var usesCPKCodegen, statements;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this.initPromise) {
+                _context.next = 4;
+                break;
+              }
+              this.initPromise = new Promise(function (res, rej) {
+                _this.resolve = res;
+                _this.reject = rej;
               });
-            });
-            if (usesCPKCodegen) {
-              logger.error('The SQLite adapter does not support schemas using custom primary key. Set `graphQLTransformer.respectPrimaryKeyAttributesOnConnectionField in `amplify/cli.json` to false to disable custom primary key. To regenerate your API, add or remove an empty newline to your GraphQL schema (to change the computed hash) then run `amplify push`.');
-            }
-            return [4 /*yield*/, this.db.init()];
-          case 5:
-            _a.sent();
-            statements = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.generateSchemaStatements)(this.schema);
-            return [4 /*yield*/, this.db.createSchema(statements)];
-          case 6:
-            _a.sent();
-            this.resolve();
-            return [3 /*break*/, 8];
-          case 7:
-            error_1 = _a.sent();
-            this.reject(error_1);
-            return [3 /*break*/, 8];
-          case 8:
-            return [2 /*return*/];
-        }
-      });
-    });
-  };
-
-  CommonSQLiteAdapter.prototype.clear = function () {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            return [4 /*yield*/, this.db.clear()];
-          case 1:
-            _a.sent();
-            this.initPromise = undefined;
-            return [2 /*return*/];
-        }
-      });
-    });
-  };
-
-  CommonSQLiteAdapter.prototype.save = function (model, condition) {
-    var e_1, _a;
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var modelConstructor, tableName, connectedModels, connectionStoreNames, _b, queryStatement, params, fromDB, predicates, predicateObjs, type, isValid, msg, result, saveStatements, connectionStoreNames_1, connectionStoreNames_1_1, resItem, modelName, item, instance, id, _c, queryStatement_1, params_1, fromDB_1, opType, saveStatement, e_1_1;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_d) {
-        switch (_d.label) {
-          case 0:
-            modelConstructor = Object.getPrototypeOf(model).constructor;
-            tableName = modelConstructor.name;
-            connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
-            connectionStoreNames = Object.values(connectedModels).map(function (_a) {
-              var modelName = _a.modelName,
-                item = _a.item,
-                instance = _a.instance;
-              return {
-                modelName: modelName,
-                item: item,
-                instance: instance
-              };
-            });
-            _b = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(model.id, tableName), 2), queryStatement = _b[0], params = _b[1];
-            return [4 /*yield*/, this.db.get(queryStatement, params)];
-          case 1:
-            fromDB = _d.sent();
-            if (condition && fromDB) {
+              _context.next = 7;
+              break;
+            case 4:
+              _context.next = 6;
+              return this.initPromise;
+            case 6:
+              return _context.abrupt("return");
+            case 7:
+              this.schema = theSchema;
+              this.namespaceResolver = namespaceResolver;
+              this.modelInstanceCreator = modelInstanceCreator;
+              this.getModelConstructorByModelName = getModelConstructorByModelName;
+              _context.prev = 11;
+              usesCPKCodegen = Object.values(this.schema.namespaces.user.models).some(function (model) {
+                return Object.values(model.fields).some(function (field) {
+                  var _field$association;
+                  return (_field$association = field.association) === null || _field$association === void 0 ? void 0 : _field$association.hasOwnProperty('targetNames');
+                });
+              });
+              if (usesCPKCodegen) {
+                logger.error('The SQLite adapter does not support schemas using custom primary key. Set `graphQLTransformer.respectPrimaryKeyAttributesOnConnectionField in `amplify/cli.json` to false to disable custom primary key. To regenerate your API, add or remove an empty newline to your GraphQL schema (to change the computed hash) then run `amplify push`.');
+              }
+              _context.next = 16;
+              return this.db.init();
+            case 16:
+              statements = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.generateSchemaStatements)(this.schema);
+              _context.next = 19;
+              return this.db.createSchema(statements);
+            case 19:
+              this.resolve();
+              _context.next = 25;
+              break;
+            case 22:
+              _context.prev = 22;
+              _context.t0 = _context["catch"](11);
+              this.reject(_context.t0);
+            case 25:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this, [[11, 22]]);
+      }));
+      function setUp(_x, _x2, _x3, _x4) {
+        return _setUp.apply(this, arguments);
+      }
+      return setUp;
+    }()
+  }, {
+    key: "clear",
+    value: function () {
+      var _clear = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              _context2.next = 2;
+              return this.db.clear();
+            case 2:
+              this.initPromise = undefined;
+            case 3:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function clear() {
+        return _clear.apply(this, arguments);
+      }
+      return clear;
+    }()
+  }, {
+    key: "save",
+    value: function () {
+      var _save = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(model, condition) {
+        var modelConstructor, tableName, connectedModels, connectionStoreNames, _queryByIdStatement, _queryByIdStatement2, queryStatement, params, fromDB, predicates, predicateObjs, type, isValid, msg, result, saveStatements, _iteratorAbruptCompletion, _didIteratorError, _iteratorError, _iterator, _step, resItem, modelName, item, instance, id, _queryByIdStatement3, _queryByIdStatement4, _queryStatement, _params, _fromDB, opType, saveStatement;
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              modelConstructor = Object.getPrototypeOf(model).constructor;
+              tableName = modelConstructor.name;
+              connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
+              connectionStoreNames = Object.values(connectedModels).map(function (_ref) {
+                var modelName = _ref.modelName,
+                  item = _ref.item,
+                  instance = _ref.instance;
+                return {
+                  modelName: modelName,
+                  item: item,
+                  instance: instance
+                };
+              });
+              _queryByIdStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(model.id, tableName), _queryByIdStatement2 = _slicedToArray(_queryByIdStatement, 2), queryStatement = _queryByIdStatement2[0], params = _queryByIdStatement2[1];
+              _context3.next = 7;
+              return this.db.get(queryStatement, params);
+            case 7:
+              fromDB = _context3.sent;
+              if (!(condition && fromDB)) {
+                _context3.next = 16;
+                break;
+              }
               predicates = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(condition);
               predicateObjs = predicates.predicates, type = predicates.type;
               isValid = validatePredicate(fromDB, type, predicateObjs);
-              if (!isValid) {
-                msg = 'Conditional update failed';
-                logger.error(msg, {
-                  model: fromDB,
-                  condition: predicateObjs
-                });
-                throw new Error(msg);
+              if (isValid) {
+                _context3.next = 16;
+                break;
               }
-            }
-            result = [];
-            saveStatements = new Set();
-            _d.label = 2;
-          case 2:
-            _d.trys.push([2, 8, 9, 14]);
-            connectionStoreNames_1 = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__asyncValues)(connectionStoreNames);
-            _d.label = 3;
-          case 3:
-            return [4 /*yield*/, connectionStoreNames_1.next()];
-          case 4:
-            if (!(connectionStoreNames_1_1 = _d.sent(), !connectionStoreNames_1_1.done)) return [3 /*break*/, 7];
-            resItem = connectionStoreNames_1_1.value;
-            modelName = resItem.modelName, item = resItem.item, instance = resItem.instance;
-            id = item.id;
-            _c = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(id, modelName), 2), queryStatement_1 = _c[0], params_1 = _c[1];
-            return [4 /*yield*/, this.db.get(queryStatement_1, params_1)];
-          case 5:
-            fromDB_1 = _d.sent();
-            opType = fromDB_1 === undefined ? _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.INSERT : _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.UPDATE;
-            saveStatement = fromDB_1 ? (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelUpdateStatement)(instance, modelName) : (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelInsertStatement)(instance, modelName);
-            if (id === model.id || opType === _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.INSERT) {
-              saveStatements.add(saveStatement);
-              result.push([instance, opType]);
-            }
-            _d.label = 6;
-          case 6:
-            return [3 /*break*/, 3];
-          case 7:
-            return [3 /*break*/, 14];
-          case 8:
-            e_1_1 = _d.sent();
-            e_1 = {
-              error: e_1_1
-            };
-            return [3 /*break*/, 14];
-          case 9:
-            _d.trys.push([9,, 12, 13]);
-            if (!(connectionStoreNames_1_1 && !connectionStoreNames_1_1.done && (_a = connectionStoreNames_1["return"]))) return [3 /*break*/, 11];
-            return [4 /*yield*/, _a.call(connectionStoreNames_1)];
-          case 10:
-            _d.sent();
-            _d.label = 11;
-          case 11:
-            return [3 /*break*/, 13];
-          case 12:
-            if (e_1) throw e_1.error;
-            return [7 /*endfinally*/];
-          case 13:
-            return [7 /*endfinally*/];
-          case 14:
-            return [4 /*yield*/, this.db.batchSave(saveStatements)];
-          case 15:
-            _d.sent();
-            return [2 /*return*/, result];
-        }
-      });
-    });
-  };
-  CommonSQLiteAdapter.prototype.load = function (namespaceName, srcModelName, records) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var namespace, relations, connectionTableNames, modelConstructor;
-      var _this = this;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_a) {
-        namespace = this.schema.namespaces[namespaceName];
-        relations = namespace.relationships[srcModelName].relationTypes;
-        connectionTableNames = relations.map(function (_a) {
-          var modelName = _a.modelName;
-          return modelName;
-        });
-        modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
-        if (connectionTableNames.length === 0) {
-          return [2 /*return*/, records.map(function (record) {
-            return _this.modelInstanceCreator(modelConstructor, record);
-          })];
-        }
-        // Remove related-model fields. They're all `null` in the database,
-        // and any that happen to be required will result in a false validation
-        // error when DataStore attempts to initialize with `null`.
-        // These fields aren't actually needed here. DataStore will use the FK's
-        // from the schema model.
-        return [2 /*return*/, records.map(function (record) {
-          var e_2, _a;
-          try {
-            for (var relations_1 = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__values)(relations), relations_1_1 = relations_1.next(); !relations_1_1.done; relations_1_1 = relations_1.next()) {
-              var r = relations_1_1.value;
-              delete record[r.fieldName];
-            }
-          } catch (e_2_1) {
-            e_2 = {
-              error: e_2_1
-            };
-          } finally {
-            try {
-              if (relations_1_1 && !relations_1_1.done && (_a = relations_1["return"])) _a.call(relations_1);
-            } finally {
-              if (e_2) throw e_2.error;
-            }
+              msg = 'Conditional update failed';
+              logger.error(msg, {
+                model: fromDB,
+                condition: predicateObjs
+              });
+              throw new Error(msg);
+            case 16:
+              result = [];
+              saveStatements = new Set();
+              _iteratorAbruptCompletion = false;
+              _didIteratorError = false;
+              _context3.prev = 20;
+              _iterator = _asyncIterator(connectionStoreNames);
+            case 22:
+              _context3.next = 24;
+              return _iterator.next();
+            case 24:
+              if (!(_iteratorAbruptCompletion = !(_step = _context3.sent).done)) {
+                _context3.next = 38;
+                break;
+              }
+              resItem = _step.value;
+              modelName = resItem.modelName, item = resItem.item, instance = resItem.instance;
+              id = item.id;
+              _queryByIdStatement3 = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(id, modelName), _queryByIdStatement4 = _slicedToArray(_queryByIdStatement3, 2), _queryStatement = _queryByIdStatement4[0], _params = _queryByIdStatement4[1];
+              _context3.next = 31;
+              return this.db.get(_queryStatement, _params);
+            case 31:
+              _fromDB = _context3.sent;
+              opType = _fromDB === undefined ? _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.INSERT : _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.UPDATE;
+              saveStatement = _fromDB ? (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelUpdateStatement)(instance, modelName) : (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelInsertStatement)(instance, modelName);
+              if (id === model.id || opType === _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.INSERT) {
+                saveStatements.add(saveStatement);
+                result.push([instance, opType]);
+              }
+            case 35:
+              _iteratorAbruptCompletion = false;
+              _context3.next = 22;
+              break;
+            case 38:
+              _context3.next = 44;
+              break;
+            case 40:
+              _context3.prev = 40;
+              _context3.t0 = _context3["catch"](20);
+              _didIteratorError = true;
+              _iteratorError = _context3.t0;
+            case 44:
+              _context3.prev = 44;
+              _context3.prev = 45;
+              if (!(_iteratorAbruptCompletion && _iterator["return"] != null)) {
+                _context3.next = 49;
+                break;
+              }
+              _context3.next = 49;
+              return _iterator["return"]();
+            case 49:
+              _context3.prev = 49;
+              if (!_didIteratorError) {
+                _context3.next = 52;
+                break;
+              }
+              throw _iteratorError;
+            case 52:
+              return _context3.finish(49);
+            case 53:
+              return _context3.finish(44);
+            case 54:
+              _context3.next = 56;
+              return this.db.batchSave(saveStatements);
+            case 56:
+              return _context3.abrupt("return", result);
+            case 57:
+            case "end":
+              return _context3.stop();
           }
-          return _this.modelInstanceCreator(modelConstructor, record);
-        })];
-      });
-    });
-  };
-  CommonSQLiteAdapter.prototype.query = function (modelConstructor, predicate, pagination) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var tableName, namespaceName, predicates, sortPredicates, limit, page, queryById, records;
-      var _this = this;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_a) {
-        switch (_a.label) {
-          case 0:
-            tableName = modelConstructor.name;
-            namespaceName = this.namespaceResolver(modelConstructor);
-            predicates = predicate && _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(predicate);
-            sortPredicates = pagination && pagination.sort && _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelSortPredicateCreator.getPredicates(pagination.sort);
-            limit = pagination && pagination.limit;
-            page = limit && pagination.page;
-            queryById = predicates && this.idFromPredicate(predicates);
-            return [4 /*yield*/, function () {
-              return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(_this, void 0, void 0, function () {
-                var record, _a, queryStatement, params;
-                return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_b) {
-                  switch (_b.label) {
+        }, _callee3, this, [[20, 40, 44, 54], [45,, 49, 53]]);
+      }));
+      function save(_x5, _x6) {
+        return _save.apply(this, arguments);
+      }
+      return save;
+    }()
+  }, {
+    key: "load",
+    value: function () {
+      var _load = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(namespaceName, srcModelName, records) {
+        var _this2 = this;
+        var namespace, relations, connectionTableNames, modelConstructor;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              namespace = this.schema.namespaces[namespaceName];
+              relations = namespace.relationships[srcModelName].relationTypes;
+              connectionTableNames = relations.map(function (_ref2) {
+                var modelName = _ref2.modelName;
+                return modelName;
+              });
+              modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
+              if (!(connectionTableNames.length === 0)) {
+                _context4.next = 6;
+                break;
+              }
+              return _context4.abrupt("return", records.map(function (record) {
+                return _this2.modelInstanceCreator(modelConstructor, record);
+              }));
+            case 6:
+              return _context4.abrupt("return", records.map(function (record) {
+                var _iterator2 = _createForOfIteratorHelper(relations),
+                  _step2;
+                try {
+                  for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+                    var r = _step2.value;
+                    delete record[r.fieldName];
+                  }
+                } catch (err) {
+                  _iterator2.e(err);
+                } finally {
+                  _iterator2.f();
+                }
+                return _this2.modelInstanceCreator(modelConstructor, record);
+              }));
+            case 7:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4, this);
+      }));
+      function load(_x7, _x8, _x9) {
+        return _load.apply(this, arguments);
+      }
+      return load;
+    }()
+  }, {
+    key: "query",
+    value: function () {
+      var _query = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6(modelConstructor, predicate, pagination) {
+        var _this3 = this;
+        var tableName, namespaceName, predicates, sortPredicates, limit, page, queryById, records;
+        return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+          while (1) switch (_context6.prev = _context6.next) {
+            case 0:
+              tableName = modelConstructor.name;
+              namespaceName = this.namespaceResolver(modelConstructor);
+              predicates = predicate && _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(predicate);
+              sortPredicates = pagination && pagination.sort && _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelSortPredicateCreator.getPredicates(pagination.sort);
+              limit = pagination && pagination.limit;
+              page = limit && pagination.page;
+              queryById = predicates && this.idFromPredicate(predicates);
+              _context6.next = 9;
+              return _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+                var record, _queryAllStatement, _queryAllStatement2, queryStatement, params;
+                return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+                  while (1) switch (_context5.prev = _context5.next) {
                     case 0:
-                      if (!queryById) return [3 /*break*/, 2];
-                      return [4 /*yield*/, this.getById(tableName, queryById)];
-                    case 1:
-                      record = _b.sent();
-                      return [2 /*return*/, record ? [record] : []];
-                    case 2:
-                      _a = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryAllStatement)(tableName, predicates, sortPredicates, limit, page), 2), queryStatement = _a[0], params = _a[1];
-                      return [4 /*yield*/, this.db.getAll(queryStatement, params)];
+                      if (!queryById) {
+                        _context5.next = 5;
+                        break;
+                      }
+                      _context5.next = 3;
+                      return _this3.getById(tableName, queryById);
                     case 3:
-                      return [2 /*return*/, _b.sent()];
+                      record = _context5.sent;
+                      return _context5.abrupt("return", record ? [record] : []);
+                    case 5:
+                      _queryAllStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryAllStatement)(tableName, predicates, sortPredicates, limit, page), _queryAllStatement2 = _slicedToArray(_queryAllStatement, 2), queryStatement = _queryAllStatement2[0], params = _queryAllStatement2[1];
+                      _context5.next = 8;
+                      return _this3.db.getAll(queryStatement, params);
+                    case 8:
+                      return _context5.abrupt("return", _context5.sent);
+                    case 9:
+                    case "end":
+                      return _context5.stop();
                   }
-                });
-              });
-            }()];
-          case 1:
-            records = _a.sent();
-            return [4 /*yield*/, this.load(namespaceName, modelConstructor.name, records)];
-          case 2:
-            return [2 /*return*/, _a.sent()];
-        }
-      });
-    });
-  };
-  CommonSQLiteAdapter.prototype.getById = function (tableName, id) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var _a, queryStatement, params, record;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_b) {
-        switch (_b.label) {
-          case 0:
-            _a = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(id, tableName), 2), queryStatement = _a[0], params = _a[1];
-            return [4 /*yield*/, this.db.get(queryStatement, params)];
-          case 1:
-            record = _b.sent();
-            return [2 /*return*/, record];
-        }
+                }, _callee5);
+              }))();
+            case 9:
+              records = _context6.sent;
+              _context6.next = 12;
+              return this.load(namespaceName, modelConstructor.name, records);
+            case 12:
+              return _context6.abrupt("return", _context6.sent);
+            case 13:
+            case "end":
+              return _context6.stop();
+          }
+        }, _callee6, this);
+      }));
+      function query(_x10, _x11, _x12) {
+        return _query.apply(this, arguments);
+      }
+      return query;
+    }()
+  }, {
+    key: "getById",
+    value: function () {
+      var _getById = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7(tableName, id) {
+        var _queryByIdStatement5, _queryByIdStatement6, queryStatement, params, record;
+        return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+          while (1) switch (_context7.prev = _context7.next) {
+            case 0:
+              _queryByIdStatement5 = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(id, tableName), _queryByIdStatement6 = _slicedToArray(_queryByIdStatement5, 2), queryStatement = _queryByIdStatement6[0], params = _queryByIdStatement6[1];
+              _context7.next = 3;
+              return this.db.get(queryStatement, params);
+            case 3:
+              record = _context7.sent;
+              return _context7.abrupt("return", record);
+            case 5:
+            case "end":
+              return _context7.stop();
+          }
+        }, _callee7, this);
+      }));
+      function getById(_x13, _x14) {
+        return _getById.apply(this, arguments);
+      }
+      return getById;
+    }()
+  }, {
+    key: "idFromPredicate",
+    value: function idFromPredicate(predicates) {
+      var predicateObjs = predicates.predicates;
+      var idPredicate = predicateObjs.length === 1 && predicateObjs.find(function (p) {
+        return (0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.isPredicateObj)(p) && p.field === 'id' && p.operator === 'eq';
       });
-    });
-  };
-  CommonSQLiteAdapter.prototype.idFromPredicate = function (predicates) {
-    var predicateObjs = predicates.predicates;
-    var idPredicate = predicateObjs.length === 1 && predicateObjs.find(function (p) {
-      return (0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.isPredicateObj)(p) && p.field === 'id' && p.operator === 'eq';
-    });
-    return idPredicate && idPredicate.operand;
-  };
-  CommonSQLiteAdapter.prototype.queryOne = function (modelConstructor, firstOrLast) {
-    if (firstOrLast === void 0) {
-      firstOrLast = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.QueryOne.FIRST;
+      return idPredicate && idPredicate.operand;
     }
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var tableName, _a, queryStatement, params, result, modelInstance;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_b) {
-        switch (_b.label) {
-          case 0:
-            tableName = modelConstructor.name;
-            _a = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryOneStatement)(firstOrLast, tableName), 2), queryStatement = _a[0], params = _a[1];
-            return [4 /*yield*/, this.db.get(queryStatement, params)];
-          case 1:
-            result = _b.sent();
-            modelInstance = result && this.modelInstanceCreator(modelConstructor, result);
-            return [2 /*return*/, modelInstance];
-        }
-      });
-    });
-  };
-  // Currently does not cascade
-  // TODO: use FKs in relations and have `ON DELETE CASCADE` set
-  // For Has Many and Has One relations to have SQL handle cascades automatically
-  CommonSQLiteAdapter.prototype["delete"] = function (modelOrModelConstructor, condition) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var modelConstructor, namespaceName, tableName, predicates, queryStatement, deleteStatement, models, modelInstances, model, modelConstructor, tableName, _a, queryStatement, params, fromDB, msg, predicates, predicateObjs, type, isValid, msg, _b, deleteStatement, deleteParams, _c, deleteStatement, params;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_d) {
-        switch (_d.label) {
-          case 0:
-            if (!isModelConstructor(modelOrModelConstructor)) return [3 /*break*/, 3];
-            modelConstructor = modelOrModelConstructor;
-            namespaceName = this.namespaceResolver(modelConstructor);
-            tableName = modelConstructor.name;
-            predicates = condition && _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(condition);
-            queryStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryAllStatement)(tableName, predicates);
-            deleteStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByPredicateStatement)(tableName, predicates);
-            return [4 /*yield*/, this.db.selectAndDelete(queryStatement, deleteStatement)];
-          case 1:
-            models = _d.sent();
-            return [4 /*yield*/, this.load(namespaceName, modelConstructor.name, models)];
-          case 2:
-            modelInstances = _d.sent();
-            return [2 /*return*/, [modelInstances, modelInstances]];
-          case 3:
-            model = modelOrModelConstructor;
-            modelConstructor = Object.getPrototypeOf(model).constructor;
-            tableName = modelConstructor.name;
-            if (!condition) return [3 /*break*/, 6];
-            _a = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(model.id, tableName), 2), queryStatement = _a[0], params = _a[1];
-            return [4 /*yield*/, this.db.get(queryStatement, params)];
-          case 4:
-            fromDB = _d.sent();
-            if (fromDB === undefined) {
+  }, {
+    key: "queryOne",
+    value: function () {
+      var _queryOne = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8(modelConstructor) {
+        var firstOrLast,
+          tableName,
+          _queryOneStatement,
+          _queryOneStatement2,
+          queryStatement,
+          params,
+          result,
+          modelInstance,
+          _args8 = arguments;
+        return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+          while (1) switch (_context8.prev = _context8.next) {
+            case 0:
+              firstOrLast = _args8.length > 1 && _args8[1] !== undefined ? _args8[1] : _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.QueryOne.FIRST;
+              tableName = modelConstructor.name;
+              _queryOneStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryOneStatement)(firstOrLast, tableName), _queryOneStatement2 = _slicedToArray(_queryOneStatement, 2), queryStatement = _queryOneStatement2[0], params = _queryOneStatement2[1];
+              _context8.next = 5;
+              return this.db.get(queryStatement, params);
+            case 5:
+              result = _context8.sent;
+              modelInstance = result && this.modelInstanceCreator(modelConstructor, result);
+              return _context8.abrupt("return", modelInstance);
+            case 8:
+            case "end":
+              return _context8.stop();
+          }
+        }, _callee8, this);
+      }));
+      function queryOne(_x15) {
+        return _queryOne.apply(this, arguments);
+      }
+      return queryOne;
+    }() // Currently does not cascade
+    // TODO: use FKs in relations and have `ON DELETE CASCADE` set
+    // For Has Many and Has One relations to have SQL handle cascades automatically
+  }, {
+    key: "delete",
+    value: function () {
+      var _delete2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9(modelOrModelConstructor, condition) {
+        var modelConstructor, namespaceName, tableName, predicates, queryStatement, deleteStatement, models, modelInstances, model, _modelConstructor, _tableName, _queryByIdStatement7, _queryByIdStatement8, _queryStatement2, params, fromDB, msg, _predicates, predicateObjs, type, isValid, _msg, _deleteByIdStatement, _deleteByIdStatement2, _deleteStatement, deleteParams, _deleteByIdStatement3, _deleteByIdStatement4, _deleteStatement2, _params2;
+        return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+          while (1) switch (_context9.prev = _context9.next) {
+            case 0:
+              if (!isModelConstructor(modelOrModelConstructor)) {
+                _context9.next = 16;
+                break;
+              }
+              modelConstructor = modelOrModelConstructor;
+              namespaceName = this.namespaceResolver(modelConstructor);
+              tableName = modelConstructor.name;
+              predicates = condition && _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(condition);
+              queryStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryAllStatement)(tableName, predicates);
+              deleteStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByPredicateStatement)(tableName, predicates);
+              _context9.next = 9;
+              return this.db.selectAndDelete(queryStatement, deleteStatement);
+            case 9:
+              models = _context9.sent;
+              _context9.next = 12;
+              return this.load(namespaceName, modelConstructor.name, models);
+            case 12:
+              modelInstances = _context9.sent;
+              return _context9.abrupt("return", [modelInstances, modelInstances]);
+            case 16:
+              model = modelOrModelConstructor;
+              _modelConstructor = Object.getPrototypeOf(model).constructor;
+              _tableName = _modelConstructor.name;
+              if (!condition) {
+                _context9.next = 41;
+                break;
+              }
+              _queryByIdStatement7 = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(model.id, _tableName), _queryByIdStatement8 = _slicedToArray(_queryByIdStatement7, 2), _queryStatement2 = _queryByIdStatement8[0], params = _queryByIdStatement8[1];
+              _context9.next = 23;
+              return this.db.get(_queryStatement2, params);
+            case 23:
+              fromDB = _context9.sent;
+              if (!(fromDB === undefined)) {
+                _context9.next = 28;
+                break;
+              }
               msg = 'Model instance not found in storage';
               logger.warn(msg, {
                 model: model
               });
-              return [2 /*return*/, [[model], []]];
-            }
-            predicates = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(condition);
-            predicateObjs = predicates.predicates, type = predicates.type;
-            isValid = validatePredicate(fromDB, type, predicateObjs);
-            if (!isValid) {
-              msg = 'Conditional update failed';
-              logger.error(msg, {
+              return _context9.abrupt("return", [[model], []]);
+            case 28:
+              _predicates = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.ModelPredicateCreator.getPredicates(condition);
+              predicateObjs = _predicates.predicates, type = _predicates.type;
+              isValid = validatePredicate(fromDB, type, predicateObjs);
+              if (isValid) {
+                _context9.next = 35;
+                break;
+              }
+              _msg = 'Conditional update failed';
+              logger.error(_msg, {
                 model: fromDB,
                 condition: predicateObjs
               });
-              throw new Error(msg);
-            }
-            _b = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByIdStatement)(model.id, tableName), 2), deleteStatement = _b[0], deleteParams = _b[1];
-            return [4 /*yield*/, this.db.save(deleteStatement, deleteParams)];
-          case 5:
-            _d.sent();
-            return [2 /*return*/, [[model], [model]]];
-          case 6:
-            _c = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__read)((0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByIdStatement)(model.id, tableName), 2), deleteStatement = _c[0], params = _c[1];
-            return [4 /*yield*/, this.db.save(deleteStatement, params)];
-          case 7:
-            _d.sent();
-            return [2 /*return*/, [[model], [model]]];
-        }
-      });
-    });
-  };
-  CommonSQLiteAdapter.prototype.batchSave = function (modelConstructor, items) {
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__awaiter)(this, void 0, void 0, function () {
-      var tableName, result, itemsToSave, queryStatements, deleteStatements, saveStatements, _loop_1, this_1, items_1, items_1_1, item, queryResponses;
-      var e_3, _a;
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__generator)(this, function (_b) {
-        switch (_b.label) {
-          case 0:
-            tableName = modelConstructor.name;
-            result = [];
-            itemsToSave = [];
-            queryStatements = new Set();
-            deleteStatements = new Set();
-            saveStatements = new Set();
-            _loop_1 = function _loop_1(item) {
-              var connectedModels = traverseModel(modelConstructor.name, this_1.modelInstanceCreator(modelConstructor, item), this_1.schema.namespaces[this_1.namespaceResolver(modelConstructor)], this_1.modelInstanceCreator, this_1.getModelConstructorByModelName);
-              var id = item.id,
-                _deleted = item._deleted;
-              var instance = connectedModels.find(function (_a) {
-                var instance = _a.instance;
-                return instance.id === id;
-              }).instance;
-              if (_deleted) {
-                // create the delete statements right away
-                var deleteStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByIdStatement)(instance.id, tableName);
-                deleteStatements.add(deleteStatement);
-                result.push([item, _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.DELETE]);
-              } else {
-                // query statements for the saves at first
-                var queryStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(id, tableName);
-                queryStatements.add(queryStatement);
-                // combination of insert and update items
-                itemsToSave.push(instance);
-              }
-            };
-            this_1 = this;
-            try {
-              for (items_1 = (0,tslib__WEBPACK_IMPORTED_MODULE_3__.__values)(items), items_1_1 = items_1.next(); !items_1_1.done; items_1_1 = items_1.next()) {
-                item = items_1_1.value;
-                _loop_1(item);
-              }
-            } catch (e_3_1) {
-              e_3 = {
-                error: e_3_1
-              };
-            } finally {
-              try {
-                if (items_1_1 && !items_1_1.done && (_a = items_1["return"])) _a.call(items_1);
-              } finally {
-                if (e_3) throw e_3.error;
-              }
-            }
-            return [4 /*yield*/, this.db.batchQuery(queryStatements)];
-          case 1:
-            queryResponses = _b.sent();
-            queryResponses.forEach(function (response, idx) {
-              if (response === undefined) {
-                var insertStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelInsertStatement)(itemsToSave[idx], tableName);
-                saveStatements.add(insertStatement);
-                result.push([itemsToSave[idx], _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.INSERT]);
-              } else {
-                var updateStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelUpdateStatement)(itemsToSave[idx], tableName);
-                saveStatements.add(updateStatement);
-                result.push([itemsToSave[idx], _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.UPDATE]);
+              throw new Error(_msg);
+            case 35:
+              _deleteByIdStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByIdStatement)(model.id, _tableName), _deleteByIdStatement2 = _slicedToArray(_deleteByIdStatement, 2), _deleteStatement = _deleteByIdStatement2[0], deleteParams = _deleteByIdStatement2[1];
+              _context9.next = 38;
+              return this.db.save(_deleteStatement, deleteParams);
+            case 38:
+              return _context9.abrupt("return", [[model], [model]]);
+            case 41:
+              _deleteByIdStatement3 = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByIdStatement)(model.id, _tableName), _deleteByIdStatement4 = _slicedToArray(_deleteByIdStatement3, 2), _deleteStatement2 = _deleteByIdStatement4[0], _params2 = _deleteByIdStatement4[1];
+              _context9.next = 44;
+              return this.db.save(_deleteStatement2, _params2);
+            case 44:
+              return _context9.abrupt("return", [[model], [model]]);
+            case 45:
+            case "end":
+              return _context9.stop();
+          }
+        }, _callee9, this);
+      }));
+      function _delete(_x16, _x17) {
+        return _delete2.apply(this, arguments);
+      }
+      return _delete;
+    }()
+  }, {
+    key: "batchSave",
+    value: function () {
+      var _batchSave = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee10(modelConstructor, items) {
+        var _this4 = this;
+        var tableName, result, itemsToSave, queryStatements, deleteStatements, saveStatements, _iterator3, _step3, _loop, queryResponses;
+        return _regeneratorRuntime().wrap(function _callee10$(_context11) {
+          while (1) switch (_context11.prev = _context11.next) {
+            case 0:
+              tableName = modelConstructor.name;
+              result = [];
+              itemsToSave = []; // To determine whether an item should result in an insert or update operation
+              // We first need to query the local DB on the item id
+              queryStatements = new Set(); // Deletes don't need to be queried first, because if the item doesn't exist,
+              // the delete operation will be a no-op
+              deleteStatements = new Set();
+              saveStatements = new Set();
+              _iterator3 = _createForOfIteratorHelper(items);
+              _context11.prev = 7;
+              _loop = /*#__PURE__*/_regeneratorRuntime().mark(function _loop() {
+                var item, connectedModels, id, _deleted, _connectedModels$find, instance, deleteStatement, queryStatement;
+                return _regeneratorRuntime().wrap(function _loop$(_context10) {
+                  while (1) switch (_context10.prev = _context10.next) {
+                    case 0:
+                      item = _step3.value;
+                      connectedModels = traverseModel(modelConstructor.name, _this4.modelInstanceCreator(modelConstructor, item), _this4.schema.namespaces[_this4.namespaceResolver(modelConstructor)], _this4.modelInstanceCreator, _this4.getModelConstructorByModelName);
+                      id = item.id, _deleted = item._deleted;
+                      _connectedModels$find = connectedModels.find(function (_ref4) {
+                        var instance = _ref4.instance;
+                        return instance.id === id;
+                      }), instance = _connectedModels$find.instance;
+                      if (_deleted) {
+                        // create the delete statements right away
+                        deleteStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.deleteByIdStatement)(instance.id, tableName);
+                        deleteStatements.add(deleteStatement);
+                        result.push([item, _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.DELETE]);
+                      } else {
+                        // query statements for the saves at first
+                        queryStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.queryByIdStatement)(id, tableName);
+                        queryStatements.add(queryStatement);
+                        // combination of insert and update items
+                        itemsToSave.push(instance);
+                      }
+                    case 5:
+                    case "end":
+                      return _context10.stop();
+                  }
+                }, _loop);
+              });
+              _iterator3.s();
+            case 10:
+              if ((_step3 = _iterator3.n()).done) {
+                _context11.next = 14;
+                break;
               }
-            });
-            // perform all of the insert/update/delete operations in a single transaction
-            return [4 /*yield*/, this.db.batchSave(saveStatements, deleteStatements)];
-          case 2:
-            // perform all of the insert/update/delete operations in a single transaction
-            _b.sent();
-            return [2 /*return*/, result];
-        }
-      });
-    });
-  };
+              return _context11.delegateYield(_loop(), "t0", 12);
+            case 12:
+              _context11.next = 10;
+              break;
+            case 14:
+              _context11.next = 19;
+              break;
+            case 16:
+              _context11.prev = 16;
+              _context11.t1 = _context11["catch"](7);
+              _iterator3.e(_context11.t1);
+            case 19:
+              _context11.prev = 19;
+              _iterator3.f();
+              return _context11.finish(19);
+            case 22:
+              _context11.next = 24;
+              return this.db.batchQuery(queryStatements);
+            case 24:
+              queryResponses = _context11.sent;
+              queryResponses.forEach(function (response, idx) {
+                if (response === undefined) {
+                  var insertStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelInsertStatement)(itemsToSave[idx], tableName);
+                  saveStatements.add(insertStatement);
+                  result.push([itemsToSave[idx], _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.INSERT]);
+                } else {
+                  var updateStatement = (0,_common_SQLiteUtils__WEBPACK_IMPORTED_MODULE_1__.modelUpdateStatement)(itemsToSave[idx], tableName);
+                  saveStatements.add(updateStatement);
+                  result.push([itemsToSave[idx], _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_2__.OpType.UPDATE]);
+                }
+              });
+              // perform all of the insert/update/delete operations in a single transaction
+              _context11.next = 28;
+              return this.db.batchSave(saveStatements, deleteStatements);
+            case 28:
+              return _context11.abrupt("return", result);
+            case 29:
+            case "end":
+              return _context11.stop();
+          }
+        }, _callee10, this, [[7, 16, 19, 22]]);
+      }));
+      function batchSave(_x18, _x19) {
+        return _batchSave.apply(this, arguments);
+      }
+      return batchSave;
+    }()
+  }]);
   return CommonSQLiteAdapter;
 }();
 
-
 /***/ }),
 
 /***/ "./lib-esm/common/SQLiteUtils.js":
@@ -869,9 +2027,71 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export */   whereClauseFromPredicate: () => (/* binding */ whereClauseFromPredicate),
 /* harmony export */   whereConditionFromPredicateObject: () => (/* binding */ whereConditionFromPredicateObject)
 /* harmony export */ });
-/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! tslib */ "../../node_modules/tslib/tslib.es6.mjs");
 /* harmony import */ var _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @aws-amplify/datastore */ "@aws-amplify/datastore");
 /* harmony import */ var _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__);
+function _createForOfIteratorHelper(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (!it) {
+    if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+      if (it) o = it;
+      var i = 0;
+      var F = function F() {};
+      return {
+        s: F,
+        n: function n() {
+          if (i >= o.length) return {
+            done: true
+          };
+          return {
+            done: false,
+            value: o[i++]
+          };
+        },
+        e: function e(_e) {
+          throw _e;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var normalCompletion = true,
+    didErr = false,
+    err;
+  return {
+    s: function s() {
+      it = it.call(o);
+    },
+    n: function n() {
+      var step = it.next();
+      normalCompletion = step.done;
+      return step;
+    },
+    e: function e(_e2) {
+      didErr = true;
+      err = _e2;
+    },
+    f: function f() {
+      try {
+        if (!normalCompletion && it["return"] != null) it["return"]();
+      } finally {
+        if (didErr) throw err;
+      }
+    }
+  };
+}
+function _toConsumableArray(arr) {
+  return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread();
+}
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _iterableToArray(iter) {
+  if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+function _arrayWithoutHoles(arr) {
+  if (Array.isArray(arr)) return _arrayLikeToArray(arr);
+}
 function _typeof(o) {
   "@babel/helpers - typeof";
 
@@ -881,7 +2101,55 @@ function _typeof(o) {
     return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
   }, _typeof(o);
 }
-
+function _slicedToArray(arr, i) {
+  return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest();
+}
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = !0,
+      o = !1;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = !0, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
@@ -890,7 +2158,7 @@ var USER = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.utils.USER,
   isModelConstructor = _aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.utils.isModelConstructor;
 var keysFromModel = function keysFromModel(model) {
   return Object.keys(model).map(function (k) {
-    return "\"" + k + "\"";
+    return "\"".concat(k, "\"");
   }).join(', ');
 };
 var valuesFromModel = function valuesFromModel(model) {
@@ -902,16 +2170,16 @@ var valuesFromModel = function valuesFromModel(model) {
 };
 var updateSet = function updateSet(model) {
   var values = [];
-  var paramaterized = Object.entries(model).filter(function (_a) {
-    var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(_a, 1),
-      k = _b[0];
+  var paramaterized = Object.entries(model).filter(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 1),
+      k = _ref2[0];
     return k !== 'id';
-  }).map(function (_a) {
-    var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(_a, 2),
-      k = _b[0],
-      v = _b[1];
+  }).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      k = _ref4[0],
+      v = _ref4[1];
     values.push(prepareValueForDML(v));
-    return "\"" + k + "\"=?";
+    return "\"".concat(k, "\"=?");
   }).join(', ');
   return [paramaterized, values];
 };
@@ -925,7 +2193,7 @@ function prepareValueForDML(value) {
   if (Array.isArray(value) || isObjectType) {
     return JSON.stringify(value);
   }
-  return "" + value;
+  return "".concat(value);
 }
 function getSQLiteType(scalar) {
   switch (scalar) {
@@ -948,7 +2216,7 @@ function getSQLiteType(scalar) {
       return 'REAL';
     default:
       var _ = scalar;
-      throw new Error("unknown type " + scalar);
+      throw new Error("unknown type ".concat(scalar));
   }
 }
 function generateSchemaStatements(schema) {
@@ -980,75 +2248,75 @@ var implicitAuthFieldsForModel = function implicitAuthFieldsForModel(model) {
     return !authFieldExplicitlyDefined;
   });
 };
-function modelCreateTableStatement(model, userModel) {
-  if (userModel === void 0) {
-    userModel = false;
-  }
+function modelCreateTableStatement(model) {
+  var userModel = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
   // implicitly defined auth fields, e.g., `owner`, `groupsField`, etc.
   var implicitAuthFields = implicitAuthFieldsForModel(model);
   var fields = Object.values(model.fields).reduce(function (acc, field) {
     if ((0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.isGraphQLScalarType)(field.type)) {
       if (field.name === 'id') {
-        return (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(acc, ['"id" PRIMARY KEY NOT NULL']);
+        return [].concat(_toConsumableArray(acc), ['"id" PRIMARY KEY NOT NULL']);
       }
-      var columnParam_1 = "\"" + field.name + "\" " + getSQLiteType(field.type);
+      var _columnParam = "\"".concat(field.name, "\" ").concat(getSQLiteType(field.type));
       if (field.isRequired) {
-        columnParam_1 += ' NOT NULL';
+        _columnParam += ' NOT NULL';
       }
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(acc, ["" + columnParam_1]);
+      return [].concat(_toConsumableArray(acc), ["".concat(_columnParam)]);
     }
     if ((0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.isModelFieldType)(field.type)) {
-      var columnParam_2 = "\"" + field.name + "\" TEXT";
+      var _columnParam2 = "\"".concat(field.name, "\" TEXT");
       // add targetName as well as field name for BELONGS_TO relations
       if ((0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.isTargetNameAssociation)(field.association)) {
         // check if this field has been explicitly defined in the model
         var fkDefinedInModel = Object.values(model.fields).find(function (f) {
-          var _a;
-          return f.name === ((_a = field === null || field === void 0 ? void 0 : field.association) === null || _a === void 0 ? void 0 : _a.targetName);
+          var _field$association;
+          return f.name === (field === null || field === void 0 || (_field$association = field.association) === null || _field$association === void 0 ? void 0 : _field$association.targetName);
         });
         // if the FK is not explicitly defined in the model, we have to add it here
         if (!fkDefinedInModel) {
           var required = field.isRequired ? ' NOT NULL' : '';
-          columnParam_2 += ", \"" + field.association.targetName + "\" TEXT" + required;
+          _columnParam2 += ", \"".concat(field.association.targetName, "\" TEXT").concat(required);
         }
       }
       // ignore isRequired param for model fields, since they will not contain
       // the related data locally
-      return (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(acc, ["" + columnParam_2]);
+      return [].concat(_toConsumableArray(acc), ["".concat(_columnParam2)]);
     }
     // default to TEXT
-    var columnParam = "\"" + field.name + "\" TEXT";
+    var columnParam = "\"".concat(field.name, "\" TEXT");
     if (field.isRequired) {
       columnParam += ' NOT NULL';
     }
-    return (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(acc, ["" + columnParam]);
+    return [].concat(_toConsumableArray(acc), ["".concat(columnParam)]);
   }, []);
   implicitAuthFields.forEach(function (authField) {
-    fields.push(authField + " TEXT");
+    fields.push("".concat(authField, " TEXT"));
   });
   if (userModel) {
-    fields = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(fields, ["\"_version\" INTEGER", "\"_lastChangedAt\" INTEGER", "\"_deleted\" INTEGER"]);
+    fields = [].concat(_toConsumableArray(fields), ["\"_version\" INTEGER", "\"_lastChangedAt\" INTEGER", "\"_deleted\" INTEGER"]);
   }
-  var createTableStatement = "CREATE TABLE IF NOT EXISTS \"" + model.name + "\" (" + fields.join(', ') + ");";
+  var createTableStatement = "CREATE TABLE IF NOT EXISTS \"".concat(model.name, "\" (").concat(fields.join(', '), ");");
   return createTableStatement;
 }
 function modelInsertStatement(model, tableName) {
   var keys = keysFromModel(model);
-  var _a = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(valuesFromModel(model), 2),
-    paramaterized = _a[0],
-    values = _a[1];
-  var insertStatement = "INSERT INTO \"" + tableName + "\" (" + keys + ") VALUES (" + paramaterized + ")";
+  var _valuesFromModel = valuesFromModel(model),
+    _valuesFromModel2 = _slicedToArray(_valuesFromModel, 2),
+    paramaterized = _valuesFromModel2[0],
+    values = _valuesFromModel2[1];
+  var insertStatement = "INSERT INTO \"".concat(tableName, "\" (").concat(keys, ") VALUES (").concat(paramaterized, ")");
   return [insertStatement, values];
 }
 function modelUpdateStatement(model, tableName) {
-  var _a = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(updateSet(model), 2),
-    paramaterized = _a[0],
-    values = _a[1];
-  var updateStatement = "UPDATE \"" + tableName + "\" SET " + paramaterized + " WHERE id=?";
-  return [updateStatement, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(values, [model.id])];
+  var _updateSet = updateSet(model),
+    _updateSet2 = _slicedToArray(_updateSet, 2),
+    paramaterized = _updateSet2[0],
+    values = _updateSet2[1];
+  var updateStatement = "UPDATE \"".concat(tableName, "\" SET ").concat(paramaterized, " WHERE id=?");
+  return [updateStatement, [].concat(_toConsumableArray(values), [model.id])];
 }
 function queryByIdStatement(id, tableName) {
-  return ["SELECT * FROM \"" + tableName + "\" WHERE \"id\" = ?", [id]];
+  return ["SELECT * FROM \"".concat(tableName, "\" WHERE \"id\" = ?"), [id]];
 }
 /*
     Predicates supported by DataStore:
@@ -1085,25 +2353,25 @@ var logicalOperatorMap = {
 function buildSpecialNullComparison(field, operator, operand) {
   if (operand === null || operand === undefined) {
     if (operator === 'eq') {
-      return "\"" + field + "\" IS NULL";
+      return "\"".concat(field, "\" IS NULL");
     } else if (operator === 'ne') {
-      return "\"" + field + "\" IS NOT NULL";
+      return "\"".concat(field, "\" IS NOT NULL");
     }
   }
   // no special null handling required
   return null;
 }
-var whereConditionFromPredicateObject = function whereConditionFromPredicateObject(_a) {
-  var field = _a.field,
-    operator = _a.operator,
-    operand = _a.operand;
+var whereConditionFromPredicateObject = function whereConditionFromPredicateObject(_ref5) {
+  var field = _ref5.field,
+    operator = _ref5.operator,
+    operand = _ref5.operand;
   var specialNullClause = buildSpecialNullComparison(field, operator, operand);
   if (specialNullClause) {
     return [specialNullClause, []];
   }
   var comparisonOperator = comparisonOperatorMap[operator];
   if (comparisonOperator) {
-    return ["\"" + field + "\" " + comparisonOperator + " ?", [operand]];
+    return ["\"".concat(field, "\" ").concat(comparisonOperator, " ?"), [operand]];
   }
   var logicalOperatorKey = operator;
   var logicalOperator = logicalOperatorMap[logicalOperatorKey];
@@ -1113,14 +2381,14 @@ var whereConditionFromPredicateObject = function whereConditionFromPredicateObje
     switch (logicalOperatorKey) {
       case 'between':
         rightExp = operand; // operand is a 2-tuple
-        statement = ["\"" + field + "\" " + logicalOperator + " " + rightExp.map(function (_) {
+        statement = ["\"".concat(field, "\" ").concat(logicalOperator, " ").concat(rightExp.map(function (_) {
           return '?';
-        }).join(' AND '), rightExp];
+        }).join(' AND ')), rightExp];
         break;
       case 'beginsWith':
       case 'contains':
       case 'notContains':
-        statement = ["instr(\"" + field + "\", ?) " + logicalOperator, [operand]];
+        statement = ["instr(\"".concat(field, "\", ?) ").concat(logicalOperator), [operand]];
         break;
       default:
         var _ = logicalOperatorKey;
@@ -1134,16 +2402,11 @@ function whereClauseFromPredicate(predicate) {
   var result = [];
   var params = [];
   recurse(predicate, result, params);
-  var whereClause = "WHERE " + result.join(' ');
+  var whereClause = "WHERE ".concat(result.join(' '));
   return [whereClause, params];
-  function recurse(predicate, result, params) {
-    var e_1, _a;
-    if (result === void 0) {
-      result = [];
-    }
-    if (params === void 0) {
-      params = [];
-    }
+  function recurse(predicate) {
+    var result = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    var params = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
     if ((0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.isPredicateGroup)(predicate)) {
       var groupType = predicate.type,
         groupPredicates = predicate.predicates;
@@ -1161,32 +2424,29 @@ function whereClauseFromPredicate(predicate) {
           break;
         default:
           var _ = groupType;
-          throw new Error("Invalid " + groupType);
+          throw new Error("Invalid ".concat(groupType));
       }
       var groupResult = [];
+      var _iterator = _createForOfIteratorHelper(groupPredicates),
+        _step;
       try {
-        for (var groupPredicates_1 = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__values)(groupPredicates), groupPredicates_1_1 = groupPredicates_1.next(); !groupPredicates_1_1.done; groupPredicates_1_1 = groupPredicates_1.next()) {
-          var p = groupPredicates_1_1.value;
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var p = _step.value;
           recurse(p, groupResult, params);
         }
-      } catch (e_1_1) {
-        e_1 = {
-          error: e_1_1
-        };
+      } catch (err) {
+        _iterator.e(err);
       } finally {
-        try {
-          if (groupPredicates_1_1 && !groupPredicates_1_1.done && (_a = groupPredicates_1["return"])) _a.call(groupPredicates_1);
-        } finally {
-          if (e_1) throw e_1.error;
-        }
+        _iterator.f();
       }
-      result.push((isNegation ? 'NOT' : '') + "(" + groupResult.join(" " + filterType + " ") + ")");
+      result.push("".concat(isNegation ? 'NOT' : '', "(").concat(groupResult.join(" ".concat(filterType, " ")), ")"));
     } else if ((0,_aws_amplify_datastore__WEBPACK_IMPORTED_MODULE_0__.isPredicateObj)(predicate)) {
-      var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(whereConditionFromPredicateObject(predicate), 2),
-        condition = _b[0],
-        conditionParams = _b[1];
+      var _whereConditionFromPr = whereConditionFromPredicateObject(predicate),
+        _whereConditionFromPr2 = _slicedToArray(_whereConditionFromPr, 2),
+        condition = _whereConditionFromPr2[0],
+        conditionParams = _whereConditionFromPr2[1];
       result.push(condition);
-      params.push.apply(params, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(conditionParams));
+      params.push.apply(params, _toConsumableArray(conditionParams));
     }
   }
 }
@@ -1194,23 +2454,19 @@ var sortDirectionMap = {
   ASCENDING: 'ASC',
   DESCENDING: 'DESC'
 };
-function orderByClauseFromSort(sortPredicate) {
-  if (sortPredicate === void 0) {
-    sortPredicate = [];
-  }
-  var orderByParts = sortPredicate.map(function (_a) {
-    var field = _a.field,
-      sortDirection = _a.sortDirection;
-    return "\"" + field + "\" " + sortDirectionMap[sortDirection];
+function orderByClauseFromSort() {
+  var sortPredicate = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+  var orderByParts = sortPredicate.map(function (_ref6) {
+    var field = _ref6.field,
+      sortDirection = _ref6.sortDirection;
+    return "\"".concat(field, "\" ").concat(sortDirectionMap[sortDirection]);
   });
   // We always sort by _rowid_ last
-  orderByParts.push("_rowid_ " + sortDirectionMap.ASCENDING);
-  return "ORDER BY " + orderByParts.join(', ');
+  orderByParts.push("_rowid_ ".concat(sortDirectionMap.ASCENDING));
+  return "ORDER BY ".concat(orderByParts.join(', '));
 }
-function limitClauseFromPagination(limit, page) {
-  if (page === void 0) {
-    page = 0;
-  }
+function limitClauseFromPagination(limit) {
+  var page = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
   var params = [limit];
   var clause = 'LIMIT ?';
   if (page) {
@@ -1221,23 +2477,25 @@ function limitClauseFromPagination(limit, page) {
   return [clause, params];
 }
 function queryAllStatement(tableName, predicate, sort, limit, page) {
-  var statement = "SELECT * FROM \"" + tableName + "\"";
+  var statement = "SELECT * FROM \"".concat(tableName, "\"");
   var params = [];
   if (predicate && predicate.predicates.length) {
-    var _a = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(whereClauseFromPredicate(predicate), 2),
-      whereClause = _a[0],
-      whereParams = _a[1];
-    statement += " " + whereClause;
-    params.push.apply(params, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(whereParams));
+    var _whereClauseFromPredi = whereClauseFromPredicate(predicate),
+      _whereClauseFromPredi2 = _slicedToArray(_whereClauseFromPredi, 2),
+      whereClause = _whereClauseFromPredi2[0],
+      whereParams = _whereClauseFromPredi2[1];
+    statement += " ".concat(whereClause);
+    params.push.apply(params, _toConsumableArray(whereParams));
   }
   var orderByClause = orderByClauseFromSort(sort);
-  statement += " " + orderByClause;
+  statement += " ".concat(orderByClause);
   if (limit) {
-    var _b = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(limitClauseFromPagination(limit, page), 2),
-      limitClause = _b[0],
-      limitParams = _b[1];
-    statement += " " + limitClause;
-    params.push.apply(params, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(limitParams));
+    var _limitClauseFromPagin = limitClauseFromPagination(limit, page),
+      _limitClauseFromPagin2 = _slicedToArray(_limitClauseFromPagin, 2),
+      limitClause = _limitClauseFromPagin2[0],
+      limitParams = _limitClauseFromPagin2[1];
+    statement += " ".concat(limitClause);
+    params.push.apply(params, _toConsumableArray(limitParams));
   }
   return [statement, params];
 }
@@ -1246,24 +2504,25 @@ function queryOneStatement(firstOrLast, tableName) {
     // ORDER BY rowid will no longer work as expected if a customer has
     // a field by that name in their schema. We may want to enforce it
     // as a reserved keyword in Codegen
-    return ["SELECT * FROM " + tableName + " ORDER BY _rowid_ LIMIT 1", []];
+    return ["SELECT * FROM ".concat(tableName, " ORDER BY _rowid_ LIMIT 1"), []];
   } else {
-    return ["SELECT * FROM " + tableName + " ORDER BY _rowid_ DESC LIMIT 1", []];
+    return ["SELECT * FROM ".concat(tableName, " ORDER BY _rowid_ DESC LIMIT 1"), []];
   }
 }
 function deleteByIdStatement(id, tableName) {
-  var deleteStatement = "DELETE FROM \"" + tableName + "\" WHERE \"id\"=?";
+  var deleteStatement = "DELETE FROM \"".concat(tableName, "\" WHERE \"id\"=?");
   return [deleteStatement, [id]];
 }
 function deleteByPredicateStatement(tableName, predicate) {
-  var statement = "DELETE FROM \"" + tableName + "\"";
+  var statement = "DELETE FROM \"".concat(tableName, "\"");
   var params = [];
   if (predicate && predicate.predicates.length) {
-    var _a = (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__read)(whereClauseFromPredicate(predicate), 2),
-      whereClause = _a[0],
-      whereParams = _a[1];
-    statement += " " + whereClause;
-    params.push.apply(params, (0,tslib__WEBPACK_IMPORTED_MODULE_1__.__spread)(whereParams));
+    var _whereClauseFromPredi3 = whereClauseFromPredicate(predicate),
+      _whereClauseFromPredi4 = _slicedToArray(_whereClauseFromPredi3, 2),
+      whereClause = _whereClauseFromPredi4[0],
+      whereParams = _whereClauseFromPredi4[1];
+    statement += " ".concat(whereClause);
+    params.push.apply(params, _toConsumableArray(whereParams));
   }
   return [statement, params];
 }
@@ -1324,421 +2583,6 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_expo_file_system__;
 
 module.exports = __WEBPACK_EXTERNAL_MODULE_expo_sqlite__;
 
-/***/ }),
-
-/***/ "../../node_modules/tslib/tslib.es6.mjs":
-/*!**********************************************!*\
-  !*** ../../node_modules/tslib/tslib.es6.mjs ***!
-  \**********************************************/
-/***/ ((__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) => {
-
-__webpack_require__.r(__webpack_exports__);
-/* harmony export */ __webpack_require__.d(__webpack_exports__, {
-/* harmony export */   __addDisposableResource: () => (/* binding */ __addDisposableResource),
-/* harmony export */   __assign: () => (/* binding */ __assign),
-/* harmony export */   __asyncDelegator: () => (/* binding */ __asyncDelegator),
-/* harmony export */   __asyncGenerator: () => (/* binding */ __asyncGenerator),
-/* harmony export */   __asyncValues: () => (/* binding */ __asyncValues),
-/* harmony export */   __await: () => (/* binding */ __await),
-/* harmony export */   __awaiter: () => (/* binding */ __awaiter),
-/* harmony export */   __classPrivateFieldGet: () => (/* binding */ __classPrivateFieldGet),
-/* harmony export */   __classPrivateFieldIn: () => (/* binding */ __classPrivateFieldIn),
-/* harmony export */   __classPrivateFieldSet: () => (/* binding */ __classPrivateFieldSet),
-/* harmony export */   __createBinding: () => (/* binding */ __createBinding),
-/* harmony export */   __decorate: () => (/* binding */ __decorate),
-/* harmony export */   __disposeResources: () => (/* binding */ __disposeResources),
-/* harmony export */   __esDecorate: () => (/* binding */ __esDecorate),
-/* harmony export */   __exportStar: () => (/* binding */ __exportStar),
-/* harmony export */   __extends: () => (/* binding */ __extends),
-/* harmony export */   __generator: () => (/* binding */ __generator),
-/* harmony export */   __importDefault: () => (/* binding */ __importDefault),
-/* harmony export */   __importStar: () => (/* binding */ __importStar),
-/* harmony export */   __makeTemplateObject: () => (/* binding */ __makeTemplateObject),
-/* harmony export */   __metadata: () => (/* binding */ __metadata),
-/* harmony export */   __param: () => (/* binding */ __param),
-/* harmony export */   __propKey: () => (/* binding */ __propKey),
-/* harmony export */   __read: () => (/* binding */ __read),
-/* harmony export */   __rest: () => (/* binding */ __rest),
-/* harmony export */   __runInitializers: () => (/* binding */ __runInitializers),
-/* harmony export */   __setFunctionName: () => (/* binding */ __setFunctionName),
-/* harmony export */   __spread: () => (/* binding */ __spread),
-/* harmony export */   __spreadArray: () => (/* binding */ __spreadArray),
-/* harmony export */   __spreadArrays: () => (/* binding */ __spreadArrays),
-/* harmony export */   __values: () => (/* binding */ __values),
-/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
-/* harmony export */ });
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol */
-
-var extendStatics = function(d, b) {
-  extendStatics = Object.setPrototypeOf ||
-      ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-      function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-  return extendStatics(d, b);
-};
-
-function __extends(d, b) {
-  if (typeof b !== "function" && b !== null)
-      throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-  extendStatics(d, b);
-  function __() { this.constructor = d; }
-  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-}
-
-var __assign = function() {
-  __assign = Object.assign || function __assign(t) {
-      for (var s, i = 1, n = arguments.length; i < n; i++) {
-          s = arguments[i];
-          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
-      }
-      return t;
-  }
-  return __assign.apply(this, arguments);
-}
-
-function __rest(s, e) {
-  var t = {};
-  for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
-      t[p] = s[p];
-  if (s != null && typeof Object.getOwnPropertySymbols === "function")
-      for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
-          if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
-              t[p[i]] = s[p[i]];
-      }
-  return t;
-}
-
-function __decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-
-function __param(paramIndex, decorator) {
-  return function (target, key) { decorator(target, key, paramIndex); }
-}
-
-function __esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
-  function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
-  var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
-  var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
-  var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
-  var _, done = false;
-  for (var i = decorators.length - 1; i >= 0; i--) {
-      var context = {};
-      for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
-      for (var p in contextIn.access) context.access[p] = contextIn.access[p];
-      context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
-      var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
-      if (kind === "accessor") {
-          if (result === void 0) continue;
-          if (result === null || typeof result !== "object") throw new TypeError("Object expected");
-          if (_ = accept(result.get)) descriptor.get = _;
-          if (_ = accept(result.set)) descriptor.set = _;
-          if (_ = accept(result.init)) initializers.unshift(_);
-      }
-      else if (_ = accept(result)) {
-          if (kind === "field") initializers.unshift(_);
-          else descriptor[key] = _;
-      }
-  }
-  if (target) Object.defineProperty(target, contextIn.name, descriptor);
-  done = true;
-};
-
-function __runInitializers(thisArg, initializers, value) {
-  var useValue = arguments.length > 2;
-  for (var i = 0; i < initializers.length; i++) {
-      value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
-  }
-  return useValue ? value : void 0;
-};
-
-function __propKey(x) {
-  return typeof x === "symbol" ? x : "".concat(x);
-};
-
-function __setFunctionName(f, name, prefix) {
-  if (typeof name === "symbol") name = name.description ? "[".concat(name.description, "]") : "";
-  return Object.defineProperty(f, "name", { configurable: true, value: prefix ? "".concat(prefix, " ", name) : name });
-};
-
-function __metadata(metadataKey, metadataValue) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
-}
-
-function __awaiter(thisArg, _arguments, P, generator) {
-  function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-  return new (P || (P = Promise))(function (resolve, reject) {
-      function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-      function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-      function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-      step((generator = generator.apply(thisArg, _arguments || [])).next());
-  });
-}
-
-function __generator(thisArg, body) {
-  var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-  return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-  function verb(n) { return function (v) { return step([n, v]); }; }
-  function step(op) {
-      if (f) throw new TypeError("Generator is already executing.");
-      while (g && (g = 0, op[0] && (_ = 0)), _) try {
-          if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-          if (y = 0, t) op = [op[0] & 2, t.value];
-          switch (op[0]) {
-              case 0: case 1: t = op; break;
-              case 4: _.label++; return { value: op[1], done: false };
-              case 5: _.label++; y = op[1]; op = [0]; continue;
-              case 7: op = _.ops.pop(); _.trys.pop(); continue;
-              default:
-                  if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                  if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                  if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                  if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                  if (t[2]) _.ops.pop();
-                  _.trys.pop(); continue;
-          }
-          op = body.call(thisArg, _);
-      } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-      if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-  }
-}
-
-var __createBinding = Object.create ? (function(o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  var desc = Object.getOwnPropertyDescriptor(m, k);
-  if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-  }
-  Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-  if (k2 === undefined) k2 = k;
-  o[k2] = m[k];
-});
-
-function __exportStar(m, o) {
-  for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(o, p)) __createBinding(o, m, p);
-}
-
-function __values(o) {
-  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-  if (m) return m.call(o);
-  if (o && typeof o.length === "number") return {
-      next: function () {
-          if (o && i >= o.length) o = void 0;
-          return { value: o && o[i++], done: !o };
-      }
-  };
-  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __read(o, n) {
-  var m = typeof Symbol === "function" && o[Symbol.iterator];
-  if (!m) return o;
-  var i = m.call(o), r, ar = [], e;
-  try {
-      while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-  }
-  catch (error) { e = { error: error }; }
-  finally {
-      try {
-          if (r && !r.done && (m = i["return"])) m.call(i);
-      }
-      finally { if (e) throw e.error; }
-  }
-  return ar;
-}
-
-/** @deprecated */
-function __spread() {
-  for (var ar = [], i = 0; i < arguments.length; i++)
-      ar = ar.concat(__read(arguments[i]));
-  return ar;
-}
-
-/** @deprecated */
-function __spreadArrays() {
-  for (var s = 0, i = 0, il = arguments.length; i < il; i++) s += arguments[i].length;
-  for (var r = Array(s), k = 0, i = 0; i < il; i++)
-      for (var a = arguments[i], j = 0, jl = a.length; j < jl; j++, k++)
-          r[k] = a[j];
-  return r;
-}
-
-function __spreadArray(to, from, pack) {
-  if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-      if (ar || !(i in from)) {
-          if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-          ar[i] = from[i];
-      }
-  }
-  return to.concat(ar || Array.prototype.slice.call(from));
-}
-
-function __await(v) {
-  return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var g = generator.apply(thisArg, _arguments || []), i, q = [];
-  return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-  function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-  function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-  function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-  function fulfill(value) { resume("next", value); }
-  function reject(value) { resume("throw", value); }
-  function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncDelegator(o) {
-  var i, p;
-  return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-  function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-}
-
-function __asyncValues(o) {
-  if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-  var m = o[Symbol.asyncIterator], i;
-  return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-  function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-  function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-function __makeTemplateObject(cooked, raw) {
-  if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
-  return cooked;
-};
-
-var __setModuleDefault = Object.create ? (function(o, v) {
-  Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-  o["default"] = v;
-};
-
-function __importStar(mod) {
-  if (mod && mod.__esModule) return mod;
-  var result = {};
-  if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-  __setModuleDefault(result, mod);
-  return result;
-}
-
-function __importDefault(mod) {
-  return (mod && mod.__esModule) ? mod : { default: mod };
-}
-
-function __classPrivateFieldGet(receiver, state, kind, f) {
-  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-}
-
-function __classPrivateFieldSet(receiver, state, value, kind, f) {
-  if (kind === "m") throw new TypeError("Private method is not writable");
-  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-  return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-}
-
-function __classPrivateFieldIn(state, receiver) {
-  if (receiver === null || (typeof receiver !== "object" && typeof receiver !== "function")) throw new TypeError("Cannot use 'in' operator on non-object");
-  return typeof state === "function" ? receiver === state : state.has(receiver);
-}
-
-function __addDisposableResource(env, value, async) {
-  if (value !== null && value !== void 0) {
-    if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
-    var dispose;
-    if (async) {
-        if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
-        dispose = value[Symbol.asyncDispose];
-    }
-    if (dispose === void 0) {
-        if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
-        dispose = value[Symbol.dispose];
-    }
-    if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
-    env.stack.push({ value: value, dispose: dispose, async: async });
-  }
-  else if (async) {
-    env.stack.push({ async: true });
-  }
-  return value;
-}
-
-var _SuppressedError = typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-  var e = new Error(message);
-  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-function __disposeResources(env) {
-  function fail(e) {
-    env.error = env.hasError ? new _SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
-    env.hasError = true;
-  }
-  function next() {
-    while (env.stack.length) {
-      var rec = env.stack.pop();
-      try {
-        var result = rec.dispose && rec.dispose.call(rec.value);
-        if (rec.async) return Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
-      }
-      catch (e) {
-          fail(e);
-      }
-    }
-    if (env.hasError) throw env.error;
-  }
-  return next();
-}
-
-/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = ({
-  __extends,
-  __assign,
-  __rest,
-  __decorate,
-  __param,
-  __metadata,
-  __awaiter,
-  __generator,
-  __createBinding,
-  __exportStar,
-  __values,
-  __read,
-  __spread,
-  __spreadArrays,
-  __spreadArray,
-  __await,
-  __asyncGenerator,
-  __asyncDelegator,
-  __asyncValues,
-  __makeTemplateObject,
-  __importStar,
-  __importDefault,
-  __classPrivateFieldGet,
-  __classPrivateFieldSet,
-  __classPrivateFieldIn,
-  __addDisposableResource,
-  __disposeResources,
-});
-
-
 /***/ })
 
 /******/ 	});