@aws-amplify/datastore 4.1.1 → 4.1.2

package/lib-esm/storage/adapter/AsyncStorageAdapter.js

@@ -1,107 +1,133 @@
-import { __asyncValues, __awaiter, __generator, __values } from "tslib";
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
+import { __asyncValues, __awaiter, __extends, __generator, __values } from "tslib";
 import AsyncStorageDatabase from './AsyncStorageDatabase';
-import { ModelPredicateCreator } from '../../predicates';
-import { isPredicateObj, OpType, QueryOne, } from '../../types';
-import { DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR, getIndex, getIndexFromAssociation, isModelConstructor, traverseModel, validatePredicate, inMemoryPagination, keysEqual, getStorename, getIndexKeys, extractPrimaryKeyValues, IDENTIFIER_KEY_SEPARATOR, } from '../../util';
-var logger = new Logger('DataStore');
-var AsyncStorageAdapter = /** @class */ (function () {
+import { OpType, QueryOne, } from '../../types';
+import { DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR, getIndex, getIndexFromAssociation, traverseModel, validatePredicate, inMemoryPagination, keysEqual, getStorename, getIndexKeys, IDENTIFIER_KEY_SEPARATOR, } from '../../util';
+import { StorageAdapterBase } from './StorageAdapterBase';
+var AsyncStorageAdapter = /** @class */ (function (_super) {
+    __extends(AsyncStorageAdapter, _super);
     function AsyncStorageAdapter() {
+        return _super !== null && _super.apply(this, arguments) || this;
     }
-    AsyncStorageAdapter.prototype.getStorenameForModel = function (modelConstructor) {
-        var namespace = this.namespaceResolver(modelConstructor);
-        var modelName = modelConstructor.name;
-        return getStorename(namespace, modelName);
+    // no-ops for this adapter
+    AsyncStorageAdapter.prototype.preSetUpChecks = function () {
+        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); });
     };
-    // Retrieves primary key values from a model
-    AsyncStorageAdapter.prototype.getIndexKeyValuesFromModel = function (model) {
-        var modelConstructor = Object.getPrototypeOf(model)
-            .constructor;
-        var namespaceName = this.namespaceResolver(modelConstructor);
-        var keys = getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
-        return extractPrimaryKeyValues(model, keys);
+    AsyncStorageAdapter.prototype.preOpCheck = function () {
+        return __awaiter(this, void 0, void 0, function () { return __generator(this, function (_a) {
+            return [2 /*return*/];
+        }); });
     };
-    // Retrieves concatenated primary key values from a model
-    AsyncStorageAdapter.prototype.getIndexKeyValuesPath = function (model) {
-        return this.getIndexKeyValuesFromModel(model).join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
-    };
-    AsyncStorageAdapter.prototype.setUp = function (theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
+    /**
+     * Open AsyncStorage database
+     * Create new DB if one doesn't exist
+     *
+     * Called by `StorageAdapterBase.setUp()`
+     *
+     * @returns AsyncStorageDatabase instance
+     */
+    AsyncStorageAdapter.prototype.initDb = function () {
         return __awaiter(this, void 0, void 0, function () {
-            var error_1;
-            var _this = this;
+            var db;
             return __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:
+                        db = new AsyncStorageDatabase();
+                        return [4 /*yield*/, db.init()];
+                    case 1:
                         _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]);
-                        if (!!this.db) return [3 /*break*/, 6];
-                        this.db = new AsyncStorageDatabase();
-                        return [4 /*yield*/, this.db.init()];
-                    case 5:
+                        return [2 /*return*/, db];
+                }
+            });
+        });
+    };
+    AsyncStorageAdapter.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.db.clear()];
+                    case 1:
                         _a.sent();
-                        this.resolve();
-                        _a.label = 6;
-                    case 6: return [3 /*break*/, 8];
-                    case 7:
-                        error_1 = _a.sent();
-                        this.reject(error_1);
-                        return [3 /*break*/, 8];
-                    case 8: return [2 /*return*/];
+                        this.db = undefined;
+                        this.initPromise = undefined;
+                        return [2 /*return*/];
                 }
             });
         });
     };
-    AsyncStorageAdapter.prototype.save = function (model, condition) {
-        var e_1, _a;
+    AsyncStorageAdapter.prototype.batchSave = function (modelConstructor, items) {
         return __awaiter(this, void 0, void 0, function () {
-            var modelConstructor, storeName, namespaceName, connectedModels, set, connectionStoreNames, keyValuesPath, fromDB, predicates, _b, predicateObjs, type, isValid, msg, result, connectionStoreNames_1, connectionStoreNames_1_1, resItem, storeName_1, item, instance, keys, itemKeyValues, itemKeyValuesPath, fromDB_1, opType, modelKeyValues, e_1_1;
+            var modelName, namespaceName, storeName, keys, batch, _loop_1, this_1, items_1, items_1_1, item;
+            var e_1, _a;
             var _this = this;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (items.length === 0) {
+                            return [2 /*return*/, []];
+                        }
+                        modelName = modelConstructor.name;
+                        namespaceName = this.namespaceResolver(modelConstructor);
+                        storeName = getStorename(namespaceName, modelName);
+                        keys = getIndexKeys(this.schema.namespaces[namespaceName], modelName);
+                        batch = [];
+                        _loop_1 = function (item) {
+                            var model = this_1.modelInstanceCreator(modelConstructor, item);
+                            var connectedModels = traverseModel(modelName, model, this_1.schema.namespaces[namespaceName], this_1.modelInstanceCreator, this_1.getModelConstructorByModelName);
+                            var keyValuesPath = this_1.getIndexKeyValuesPath(model);
+                            var instance = connectedModels.find(function (_a) {
+                                var instance = _a.instance;
+                                var instanceKeyValuesPath = _this.getIndexKeyValuesPath(instance);
+                                return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
+                            }).instance;
+                            batch.push(instance);
+                        };
+                        this_1 = this;
+                        try {
+                            for (items_1 = __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_1_1) { e_1 = { error: e_1_1 }; }
+                        finally {
+                            try {
+                                if (items_1_1 && !items_1_1.done && (_a = items_1.return)) _a.call(items_1);
+                            }
+                            finally { if (e_1) throw e_1.error; }
+                        }
+                        return [4 /*yield*/, this.db.batchSave(storeName, batch, keys)];
+                    case 1: return [2 /*return*/, _b.sent()];
+                }
+            });
+        });
+    };
+    AsyncStorageAdapter.prototype._get = function (storeName, keyArr) {
+        return __awaiter(this, void 0, void 0, function () {
+            var itemKeyValuesPath;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        itemKeyValuesPath = keyArr.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+                        return [4 /*yield*/, this.db.get(itemKeyValuesPath, storeName)];
+                    case 1: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    AsyncStorageAdapter.prototype.save = function (model, condition) {
+        var e_2, _a;
+        return __awaiter(this, void 0, void 0, function () {
+            var _b, storeName, connectionStoreNames, modelKeyValues, fromDB, result, connectionStoreNames_1, connectionStoreNames_1_1, resItem, storeName_1, item, instance, keys, itemKeyValues, fromDB_1, opType, e_2_1;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
-                        modelConstructor = Object.getPrototypeOf(model)
-                            .constructor;
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[namespaceName], this.modelInstanceCreator, this.getModelConstructorByModelName);
-                        set = new Set();
-                        connectionStoreNames = Object.values(connectedModels).map(function (_a) {
-                            var modelName = _a.modelName, item = _a.item, instance = _a.instance;
-                            var storeName = getStorename(namespaceName, modelName);
-                            set.add(storeName);
-                            var keys = getIndexKeys(_this.schema.namespaces[namespaceName], modelName);
-                            return { storeName: storeName, item: item, instance: instance, keys: keys };
-                        });
-                        keyValuesPath = this.getIndexKeyValuesPath(model);
-                        return [4 /*yield*/, this.db.get(keyValuesPath, storeName)];
+                        _b = this.saveMetadata(model), storeName = _b.storeName, connectionStoreNames = _b.connectionStoreNames, modelKeyValues = _b.modelKeyValues;
+                        return [4 /*yield*/, this._get(storeName, modelKeyValues)];
                     case 1:
                         fromDB = _c.sent();
-                        if (condition && fromDB) {
-                            predicates = ModelPredicateCreator.getPredicates(condition);
-                            _b = predicates, predicateObjs = _b.predicates, type = _b.type;
-                            isValid = validatePredicate(fromDB, type, predicateObjs);
-                            if (!isValid) {
-                                msg = 'Conditional update failed';
-                                logger.error(msg, { model: fromDB, condition: predicateObjs });
-                                throw new Error(msg);
-                            }
-                        }
+                        this.validateSaveCondition(condition, fromDB);
                         result = [];
                         _c.label = 2;
                     case 2:
@@ -114,15 +140,13 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         resItem = connectionStoreNames_1_1.value;
                         storeName_1 = resItem.storeName, item = resItem.item, instance = resItem.instance, keys = resItem.keys;
                         itemKeyValues = keys.map(function (key) { return item[key]; });
-                        itemKeyValuesPath = itemKeyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
-                        return [4 /*yield*/, this.db.get(itemKeyValuesPath, storeName_1)];
+                        return [4 /*yield*/, this._get(storeName_1, itemKeyValues)];
                     case 5:
                         fromDB_1 = _c.sent();
                         opType = fromDB_1 ? OpType.UPDATE : OpType.INSERT;
-                        modelKeyValues = this.getIndexKeyValuesFromModel(model);
                         if (!(keysEqual(itemKeyValues, modelKeyValues) ||
                             opType === OpType.INSERT)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.db.save(item, storeName_1, keys, itemKeyValuesPath)];
+                        return [4 /*yield*/, this.db.save(item, storeName_1, keys, itemKeyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR))];
                     case 6:
                         _c.sent();
                         result.push([instance, opType]);
@@ -130,8 +154,8 @@ var AsyncStorageAdapter = /** @class */ (function () {
                     case 7: return [3 /*break*/, 3];
                     case 8: return [3 /*break*/, 15];
                     case 9:
-                        e_1_1 = _c.sent();
-                        e_1 = { error: e_1_1 };
+                        e_2_1 = _c.sent();
+                        e_2 = { error: e_2_1 };
                         return [3 /*break*/, 15];
                     case 10:
                         _c.trys.push([10, , 13, 14]);
@@ -142,7 +166,7 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         _c.label = 12;
                     case 12: return [3 /*break*/, 14];
                     case 13:
-                        if (e_1) throw e_1.error;
+                        if (e_2) throw e_2.error;
                         return [7 /*endfinally*/];
                     case 14: return [7 /*endfinally*/];
                     case 15: return [2 /*return*/, result];
@@ -150,50 +174,22 @@ var AsyncStorageAdapter = /** @class */ (function () {
             });
         });
     };
-    AsyncStorageAdapter.prototype.load = function (namespaceName, srcModelName, records) {
-        return __awaiter(this, void 0, void 0, function () {
-            var namespace, relations, connectionStoreNames, modelConstructor;
-            var _this = this;
-            return __generator(this, function (_a) {
-                namespace = this.schema.namespaces[namespaceName];
-                relations = namespace.relationships[srcModelName].relationTypes;
-                connectionStoreNames = relations.map(function (_a) {
-                    var modelName = _a.modelName;
-                    return getStorename(namespaceName, modelName);
-                });
-                modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
-                if (connectionStoreNames.length === 0) {
-                    return [2 /*return*/, records.map(function (record) {
-                            return _this.modelInstanceCreator(modelConstructor, record);
-                        })];
-                }
-                return [2 /*return*/, records.map(function (record) {
-                        return _this.modelInstanceCreator(modelConstructor, record);
-                    })];
-            });
-        });
-    };
     AsyncStorageAdapter.prototype.query = function (modelConstructor, predicate, pagination) {
         return __awaiter(this, void 0, void 0, function () {
-            var storeName, namespaceName, predicates, keys, queryByKey, hasSort, hasPagination, records;
+            var _a, storeName, namespaceName, queryByKey, predicates, hasSort, hasPagination, records;
             var _this = this;
-            return __generator(this, function (_a) {
-                switch (_a.label) {
+            return __generator(this, function (_b) {
+                switch (_b.label) {
                     case 0:
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        predicates = predicate && ModelPredicateCreator.getPredicates(predicate);
-                        keys = getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
-                        queryByKey = predicates && this.keyValueFromPredicate(predicates, keys);
-                        hasSort = pagination && pagination.sort;
-                        hasPagination = pagination && pagination.limit;
+                        _a = this.queryMetadata(modelConstructor, predicate, pagination), storeName = _a.storeName, namespaceName = _a.namespaceName, queryByKey = _a.queryByKey, predicates = _a.predicates, hasSort = _a.hasSort, hasPagination = _a.hasPagination;
                         return [4 /*yield*/, (function () { return __awaiter(_this, void 0, void 0, function () {
-                                var record, filtered, all;
+                                var keyValues, record, filtered, all;
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
                                             if (!queryByKey) return [3 /*break*/, 2];
-                                            return [4 /*yield*/, this.getByKey(storeName, queryByKey)];
+                                            keyValues = queryByKey.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+                                            return [4 /*yield*/, this.getByKey(storeName, keyValues)];
                                         case 1:
                                             record = _a.sent();
                                             return [2 /*return*/, record ? [record] : []];
@@ -214,22 +210,19 @@ var AsyncStorageAdapter = /** @class */ (function () {
                                 });
                             }); })()];
                     case 1:
-                        records = (_a.sent());
+                        records = (_b.sent());
                         return [4 /*yield*/, this.load(namespaceName, modelConstructor.name, records)];
-                    case 2: return [2 /*return*/, _a.sent()];
+                    case 2: return [2 /*return*/, _b.sent()];
                 }
             });
         });
     };
     AsyncStorageAdapter.prototype.getByKey = function (storeName, keyValuePath) {
         return __awaiter(this, void 0, void 0, function () {
-            var record;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0: return [4 /*yield*/, this.db.get(keyValuePath, storeName)];
-                    case 1:
-                        record = _a.sent();
-                        return [2 /*return*/, record];
+                    case 1: return [2 /*return*/, _a.sent()];
                 }
             });
         });
@@ -244,34 +237,6 @@ var AsyncStorageAdapter = /** @class */ (function () {
             });
         });
     };
-    AsyncStorageAdapter.prototype.keyValueFromPredicate = function (predicates, keys) {
-        var e_2, _a;
-        var predicateObjs = predicates.predicates;
-        if (predicateObjs.length !== keys.length) {
-            return;
-        }
-        var keyValues = [];
-        var _loop_1 = function (key) {
-            var predicateObj = predicateObjs.find(function (p) { return isPredicateObj(p) && p.field === key && p.operator === 'eq'; });
-            predicateObj && keyValues.push(predicateObj.operand);
-        };
-        try {
-            for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
-                var key = keys_1_1.value;
-                _loop_1(key);
-            }
-        }
-        catch (e_2_1) { e_2 = { error: e_2_1 }; }
-        finally {
-            try {
-                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
-            }
-            finally { if (e_2) throw e_2.error; }
-        }
-        return keyValues.length === keys.length
-            ? keyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR)
-            : undefined;
-    };
     AsyncStorageAdapter.prototype.filterOnPredicate = function (storeName, predicates) {
         return __awaiter(this, void 0, void 0, function () {
             var predicateObjs, type, all, filtered;
@@ -309,97 +274,10 @@ var AsyncStorageAdapter = /** @class */ (function () {
             });
         });
     };
-    AsyncStorageAdapter.prototype.delete = function (modelOrModelConstructor, condition) {
-        return __awaiter(this, void 0, void 0, function () {
-            var deleteQueue, modelConstructor, nameSpace, models, relations, deletedModels, deletedModels, model, modelConstructor, nameSpace, storeName, keyValuePath, fromDB, msg, predicates, _a, predicateObjs, type, isValid, msg, relations, relations, deletedModels;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        deleteQueue = [];
-                        if (!isModelConstructor(modelOrModelConstructor)) return [3 /*break*/, 8];
-                        modelConstructor = modelOrModelConstructor;
-                        nameSpace = this.namespaceResolver(modelConstructor);
-                        return [4 /*yield*/, this.query(modelConstructor, condition)];
-                    case 1:
-                        models = _b.sent();
-                        relations = this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
-                            .relationTypes;
-                        if (!(condition !== undefined)) return [3 /*break*/, 4];
-                        return [4 /*yield*/, this.deleteTraverse(relations, models, modelConstructor.name, nameSpace, deleteQueue)];
-                    case 2:
-                        _b.sent();
-                        return [4 /*yield*/, this.deleteItem(deleteQueue)];
-                    case 3:
-                        _b.sent();
-                        deletedModels = deleteQueue.reduce(function (acc, _a) {
-                            var items = _a.items;
-                            return acc.concat(items);
-                        }, []);
-                        return [2 /*return*/, [models, deletedModels]];
-                    case 4: return [4 /*yield*/, this.deleteTraverse(relations, models, modelConstructor.name, nameSpace, deleteQueue)];
-                    case 5:
-                        _b.sent();
-                        return [4 /*yield*/, this.deleteItem(deleteQueue)];
-                    case 6:
-                        _b.sent();
-                        deletedModels = deleteQueue.reduce(function (acc, _a) {
-                            var items = _a.items;
-                            return acc.concat(items);
-                        }, []);
-                        return [2 /*return*/, [models, deletedModels]];
-                    case 7: return [3 /*break*/, 15];
-                    case 8:
-                        model = modelOrModelConstructor;
-                        modelConstructor = Object.getPrototypeOf(model)
-                            .constructor;
-                        nameSpace = this.namespaceResolver(modelConstructor);
-                        storeName = this.getStorenameForModel(modelConstructor);
-                        if (!condition) return [3 /*break*/, 11];
-                        keyValuePath = this.getIndexKeyValuesPath(model);
-                        return [4 /*yield*/, this.db.get(keyValuePath, storeName)];
-                    case 9:
-                        fromDB = _b.sent();
-                        if (fromDB === undefined) {
-                            msg = 'Model instance not found in storage';
-                            logger.warn(msg, { model: model });
-                            return [2 /*return*/, [[model], []]];
-                        }
-                        predicates = ModelPredicateCreator.getPredicates(condition);
-                        _a = predicates, predicateObjs = _a.predicates, type = _a.type;
-                        isValid = validatePredicate(fromDB, type, predicateObjs);
-                        if (!isValid) {
-                            msg = 'Conditional update failed';
-                            logger.error(msg, { model: fromDB, condition: predicateObjs });
-                            throw new Error(msg);
-                        }
-                        relations = this.schema.namespaces[nameSpace].relationships[modelConstructor.name].relationTypes;
-                        return [4 /*yield*/, this.deleteTraverse(relations, [model], modelConstructor.name, nameSpace, deleteQueue)];
-                    case 10:
-                        _b.sent();
-                        return [3 /*break*/, 13];
-                    case 11:
-                        relations = this.schema.namespaces[nameSpace].relationships[modelConstructor.name].relationTypes;
-                        return [4 /*yield*/, this.deleteTraverse(relations, [model], modelConstructor.name, nameSpace, deleteQueue)];
-                    case 12:
-                        _b.sent();
-                        _b.label = 13;
-                    case 13: return [4 /*yield*/, this.deleteItem(deleteQueue)];
-                    case 14:
-                        _b.sent();
-                        deletedModels = deleteQueue.reduce(function (acc, _a) {
-                            var items = _a.items;
-                            return acc.concat(items);
-                        }, []);
-                        return [2 /*return*/, [[model], deletedModels]];
-                    case 15: return [2 /*return*/];
-                }
-            });
-        });
-    };
     AsyncStorageAdapter.prototype.deleteItem = function (deleteQueue) {
         var e_3, _a, e_4, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var _c, _d, deleteItem, storeName, items, items_1, items_1_1, item, keyValuesPath, e_4_1, e_3_1;
+            var _c, _d, deleteItem, storeName, items, items_2, items_2_1, item, keyValuesPath, e_4_1, e_3_1;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
@@ -414,12 +292,12 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         _e.label = 3;
                     case 3:
                         _e.trys.push([3, 9, 10, 15]);
-                        items_1 = __asyncValues(items);
+                        items_2 = __asyncValues(items);
                         _e.label = 4;
-                    case 4: return [4 /*yield*/, items_1.next()];
+                    case 4: return [4 /*yield*/, items_2.next()];
                     case 5:
-                        if (!(items_1_1 = _e.sent(), !items_1_1.done)) return [3 /*break*/, 8];
-                        item = items_1_1.value;
+                        if (!(items_2_1 = _e.sent(), !items_2_1.done)) return [3 /*break*/, 8];
+                        item = items_2_1.value;
                         if (!item) return [3 /*break*/, 7];
                         if (!(typeof item === 'object')) return [3 /*break*/, 7];
                         keyValuesPath = this.getIndexKeyValuesPath(item);
@@ -435,8 +313,8 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         return [3 /*break*/, 15];
                     case 10:
                         _e.trys.push([10, , 13, 14]);
-                        if (!(items_1_1 && !items_1_1.done && (_b = items_1.return))) return [3 /*break*/, 12];
-                        return [4 /*yield*/, _b.call(items_1)];
+                        if (!(items_2_1 && !items_2_1.done && (_b = items_2.return))) return [3 /*break*/, 12];
+                        return [4 /*yield*/, _b.call(items_2)];
                     case 11:
                         _e.sent();
                         _e.label = 12;
@@ -469,85 +347,59 @@ var AsyncStorageAdapter = /** @class */ (function () {
         });
     };
     /**
-     * Populates the delete Queue with all the items to delete
-     * @param relations
-     * @param models
+     * Gets related Has One record for `model`
+     *
+     * @param model
      * @param srcModel
-     * @param nameSpace
-     * @param deleteQueue
+     * @param namespace
+     * @param rel
+     * @returns
      */
-    AsyncStorageAdapter.prototype.deleteTraverse = function (relations, models, srcModel, nameSpace, deleteQueue) {
-        var relations_1, relations_1_1, models_1, models_1_1, models_2, models_2_1;
-        var e_5, _a, e_6, _b, e_7, _c;
+    AsyncStorageAdapter.prototype.getHasOneChild = function (model, srcModel, namespace, rel) {
         return __awaiter(this, void 0, void 0, function () {
-            var rel, relationType, modelName, targetName, targetNames, associatedWith, storeName, index, _d, model, hasOneIndex_1, hasConnectedModelFields, keyValuesPath, values_1, isUnidirectionalConnection, allRecords, recordToDelete, hasOneIndex_2, hasOneCustomField, keyValuesPath, value_1, allRecords, recordsToDelete, modelsToDelete, _e, e_6_1, model, keyValues, allRecords, indices, childRecords, childModels, e_7_1, e_5_1;
-            var _this = this;
-            return __generator(this, function (_f) {
-                switch (_f.label) {
+            var hasOneIndex, modelName, targetNames, associatedWith, storeName, index, hasConnectedModelFields, keyValuesPath, values, isUnidirectionalConnection, allRecords, recordToDelete;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
-                        _f.trys.push([0, 42, 43, 48]);
-                        relations_1 = __asyncValues(relations);
-                        _f.label = 1;
-                    case 1: return [4 /*yield*/, relations_1.next()];
-                    case 2:
-                        if (!(relations_1_1 = _f.sent(), !relations_1_1.done)) return [3 /*break*/, 41];
-                        rel = relations_1_1.value;
-                        relationType = rel.relationType, modelName = rel.modelName, targetName = rel.targetName, targetNames = rel.targetNames, associatedWith = rel.associatedWith;
-                        storeName = getStorename(nameSpace, modelName);
-                        index = getIndex(this.schema.namespaces[nameSpace].relationships[modelName]
+                        modelName = rel.modelName, targetNames = rel.targetNames, associatedWith = rel.associatedWith;
+                        storeName = getStorename(namespace, modelName);
+                        index = getIndex(this.schema.namespaces[namespace].relationships[modelName]
                             .relationTypes, srcModel) ||
                             // if we were unable to find an index via relationTypes
                             // i.e. for keyName connections, attempt to find one by the
                             // associatedWith property
-                            getIndexFromAssociation(this.schema.namespaces[nameSpace].relationships[modelName].indexes, rel.associatedWith);
-                        _d = relationType;
-                        switch (_d) {
-                            case 'HAS_ONE': return [3 /*break*/, 3];
-                            case 'HAS_MANY': return [3 /*break*/, 23];
-                            case 'BELONGS_TO': return [3 /*break*/, 38];
-                        }
-                        return [3 /*break*/, 39];
-                    case 3:
-                        _f.trys.push([3, 16, 17, 22]);
-                        models_1 = __asyncValues(models);
-                        _f.label = 4;
-                    case 4: return [4 /*yield*/, models_1.next()];
-                    case 5:
-                        if (!(models_1_1 = _f.sent(), !models_1_1.done)) return [3 /*break*/, 15];
-                        model = models_1_1.value;
-                        if (!(targetNames && (targetNames === null || targetNames === void 0 ? void 0 : targetNames.length))) return [3 /*break*/, 8];
+                            getIndexFromAssociation(this.schema.namespaces[namespace].relationships[modelName].indexes, rel.associatedWith);
                         if (index) {
-                            hasOneIndex_1 = index.split(IDENTIFIER_KEY_SEPARATOR);
+                            hasOneIndex = index.split(IDENTIFIER_KEY_SEPARATOR);
                         }
                         else if (associatedWith) {
                             if (Array.isArray(associatedWith)) {
-                                hasOneIndex_1 = associatedWith;
+                                hasOneIndex = associatedWith;
                             }
                             else {
-                                hasOneIndex_1 = [associatedWith];
+                                hasOneIndex = [associatedWith];
                             }
                         }
                         hasConnectedModelFields = targetNames.every(function (targetName) {
                             return model.hasOwnProperty(targetName);
                         });
                         keyValuesPath = this.getIndexKeyValuesPath(model);
-                        isUnidirectionalConnection = hasOneIndex_1 === associatedWith;
+                        isUnidirectionalConnection = hasOneIndex === associatedWith;
                         if (hasConnectedModelFields && isUnidirectionalConnection) {
                             // Values will be that of the child model
-                            values_1 = targetNames
+                            values = targetNames
                                 .filter(function (targetName) { var _a; return (_a = model[targetName]) !== null && _a !== void 0 ? _a : false; })
                                 .map(function (targetName) { return model[targetName]; });
                         }
                         else {
                             // values will be that of the parent model
-                            values_1 = keyValuesPath.split(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+                            values = keyValuesPath.split(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
                         }
-                        if (values_1.length === 0)
-                            return [3 /*break*/, 15];
+                        if (values.length === 0)
+                            return [2 /*return*/];
                         return [4 /*yield*/, this.db.getAll(storeName)];
-                    case 6:
-                        allRecords = _f.sent();
-                        recordToDelete = void 0;
+                    case 1:
+                        allRecords = _a.sent();
                         // values === targetNames
                         if (hasConnectedModelFields) {
                             /**
@@ -555,206 +407,90 @@ var AsyncStorageAdapter = /** @class */ (function () {
                              * targetNames are present on the connected model.
                              *
                              */
-                            // recordToDelete = allRecords.filter(childItem =>
-                            // 	values.every(value => childItem[value] != null)
-                            // ) as T[];
-                            recordToDelete = allRecords.filter(function (childItem) {
-                                return hasOneIndex_1.every(function (index) { return values_1.includes(childItem[index]); });
+                            recordToDelete = allRecords.find(function (childItem) {
+                                return hasOneIndex.every(function (index) { return values.includes(childItem[index]); });
                             });
                         }
                         else {
                             // values === keyValuePath
-                            recordToDelete = allRecords.filter(function (childItem) { return childItem[hasOneIndex_1] === values_1; });
+                            recordToDelete = allRecords.find(function (childItem) { return childItem[hasOneIndex] === values; });
                         }
-                        return [4 /*yield*/, this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName]
-                                .relationTypes, recordToDelete, modelName, nameSpace, deleteQueue)];
-                    case 7:
-                        _f.sent();
-                        return [3 /*break*/, 14];
-                    case 8:
-                        hasOneIndex_2 = index || associatedWith;
-                        hasOneCustomField = targetName in model;
-                        keyValuesPath = this.getIndexKeyValuesPath(model);
-                        value_1 = hasOneCustomField
-                            ? model[targetName]
-                            : keyValuesPath;
-                        if (!value_1)
-                            return [3 /*break*/, 15];
-                        return [4 /*yield*/, this.db.getAll(storeName)];
-                    case 9:
-                        allRecords = _f.sent();
-                        recordsToDelete = allRecords.filter(function (childItem) { return childItem[hasOneIndex_2] === value_1; });
-                        if (!recordsToDelete.length) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.load(nameSpace, modelName, recordsToDelete)];
-                    case 10:
-                        _e = _f.sent();
-                        return [3 /*break*/, 12];
-                    case 11:
-                        _e = [];
-                        _f.label = 12;
-                    case 12:
-                        modelsToDelete = _e;
-                        return [4 /*yield*/, this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName]
-                                .relationTypes, modelsToDelete, modelName, nameSpace, deleteQueue)];
-                    case 13:
-                        _f.sent();
-                        _f.label = 14;
-                    case 14: return [3 /*break*/, 4];
-                    case 15: return [3 /*break*/, 22];
-                    case 16:
-                        e_6_1 = _f.sent();
-                        e_6 = { error: e_6_1 };
-                        return [3 /*break*/, 22];
-                    case 17:
-                        _f.trys.push([17, , 20, 21]);
-                        if (!(models_1_1 && !models_1_1.done && (_b = models_1.return))) return [3 /*break*/, 19];
-                        return [4 /*yield*/, _b.call(models_1)];
-                    case 18:
-                        _f.sent();
-                        _f.label = 19;
-                    case 19: return [3 /*break*/, 21];
-                    case 20:
-                        if (e_6) throw e_6.error;
-                        return [7 /*endfinally*/];
-                    case 21: return [7 /*endfinally*/];
-                    case 22: return [3 /*break*/, 40];
-                    case 23:
-                        _f.trys.push([23, 31, 32, 37]);
-                        models_2 = __asyncValues(models);
-                        _f.label = 24;
-                    case 24: return [4 /*yield*/, models_2.next()];
-                    case 25:
-                        if (!(models_2_1 = _f.sent(), !models_2_1.done)) return [3 /*break*/, 30];
-                        model = models_2_1.value;
-                        keyValues = this.getIndexKeyValuesFromModel(model);
-                        return [4 /*yield*/, this.db.getAll(storeName)];
-                    case 26:
-                        allRecords = _f.sent();
-                        indices = index.split(IDENTIFIER_KEY_SEPARATOR);
-                        childRecords = allRecords.filter(function (childItem) {
-                            return indices.every(function (index) { return keyValues.includes(childItem[index]); });
-                        });
-                        return [4 /*yield*/, this.load(nameSpace, modelName, childRecords)];
-                    case 27:
-                        childModels = _f.sent();
-                        return [4 /*yield*/, this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName]
-                                .relationTypes, childModels, modelName, nameSpace, deleteQueue)];
-                    case 28:
-                        _f.sent();
-                        _f.label = 29;
-                    case 29: return [3 /*break*/, 24];
-                    case 30: return [3 /*break*/, 37];
-                    case 31:
-                        e_7_1 = _f.sent();
-                        e_7 = { error: e_7_1 };
-                        return [3 /*break*/, 37];
-                    case 32:
-                        _f.trys.push([32, , 35, 36]);
-                        if (!(models_2_1 && !models_2_1.done && (_c = models_2.return))) return [3 /*break*/, 34];
-                        return [4 /*yield*/, _c.call(models_2)];
-                    case 33:
-                        _f.sent();
-                        _f.label = 34;
-                    case 34: return [3 /*break*/, 36];
-                    case 35:
-                        if (e_7) throw e_7.error;
-                        return [7 /*endfinally*/];
-                    case 36: return [7 /*endfinally*/];
-                    case 37: return [3 /*break*/, 40];
-                    case 38: 
-                    // Intentionally blank
-                    return [3 /*break*/, 40];
-                    case 39: throw new Error("Invalid relationType " + relationType);
-                    case 40: return [3 /*break*/, 1];
-                    case 41: return [3 /*break*/, 48];
-                    case 42:
-                        e_5_1 = _f.sent();
-                        e_5 = { error: e_5_1 };
-                        return [3 /*break*/, 48];
-                    case 43:
-                        _f.trys.push([43, , 46, 47]);
-                        if (!(relations_1_1 && !relations_1_1.done && (_a = relations_1.return))) return [3 /*break*/, 45];
-                        return [4 /*yield*/, _a.call(relations_1)];
-                    case 44:
-                        _f.sent();
-                        _f.label = 45;
-                    case 45: return [3 /*break*/, 47];
-                    case 46:
-                        if (e_5) throw e_5.error;
-                        return [7 /*endfinally*/];
-                    case 47: return [7 /*endfinally*/];
-                    case 48:
-                        deleteQueue.push({
-                            storeName: getStorename(nameSpace, srcModel),
-                            items: models.map(function (record) {
-                                return _this.modelInstanceCreator(_this.getModelConstructorByModelName(nameSpace, srcModel), record);
-                            }),
-                        });
-                        return [2 /*return*/];
+                        return [2 /*return*/, recordToDelete];
                 }
             });
         });
     };
-    AsyncStorageAdapter.prototype.clear = function () {
+    /**
+     * Backwards compatability for pre-CPK codegen
+     * TODO - deprecate this in v6; will need to re-gen MIPR for older unit
+     * tests that hit this path
+     */
+    AsyncStorageAdapter.prototype.getHasOneChildLegacy = function (model, srcModel, namespace, rel) {
         return __awaiter(this, void 0, void 0, function () {
+            var modelName, targetName, associatedWith, storeName, index, hasOneIndex, hasOneCustomField, keyValuesPath, value, allRecords, recordToDelete;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.db.clear()];
+                    case 0:
+                        modelName = rel.modelName, targetName = rel.targetName, associatedWith = rel.associatedWith;
+                        storeName = getStorename(namespace, modelName);
+                        index = getIndex(this.schema.namespaces[namespace].relationships[modelName]
+                            .relationTypes, srcModel) ||
+                            // if we were unable to find an index via relationTypes
+                            // i.e. for keyName connections, attempt to find one by the
+                            // associatedWith property
+                            getIndexFromAssociation(this.schema.namespaces[namespace].relationships[modelName].indexes, rel.associatedWith);
+                        hasOneIndex = index || associatedWith;
+                        hasOneCustomField = targetName in model;
+                        keyValuesPath = this.getIndexKeyValuesPath(model);
+                        value = hasOneCustomField ? model[targetName] : keyValuesPath;
+                        if (!value)
+                            return [2 /*return*/];
+                        return [4 /*yield*/, this.db.getAll(storeName)];
                     case 1:
-                        _a.sent();
-                        this.db = undefined;
-                        this.initPromise = undefined;
-                        return [2 /*return*/];
+                        allRecords = _a.sent();
+                        recordToDelete = allRecords.find(function (childItem) { return childItem[hasOneIndex] === value; });
+                        return [2 /*return*/, recordToDelete];
                 }
             });
         });
     };
-    AsyncStorageAdapter.prototype.batchSave = function (modelConstructor, items) {
+    /**
+     *  Gets related Has Many records by given `storeName`, `index`, and `keyValues`
+     *
+     * @param storeName
+     * @param index
+     * @param keyValues
+     * @returns
+     */
+    AsyncStorageAdapter.prototype.getHasManyChildren = function (storeName, index, keyValues) {
         return __awaiter(this, void 0, void 0, function () {
-            var modelName, namespaceName, storeName, keys, batch, _loop_2, this_1, items_2, items_2_1, item;
-            var e_8, _a;
-            var _this = this;
-            return __generator(this, function (_b) {
-                switch (_b.label) {
-                    case 0:
-                        modelName = modelConstructor.name;
-                        namespaceName = this.namespaceResolver(modelConstructor);
-                        storeName = getStorename(namespaceName, modelName);
-                        keys = getIndexKeys(this.schema.namespaces[namespaceName], modelName);
-                        batch = [];
-                        _loop_2 = function (item) {
-                            var model = this_1.modelInstanceCreator(modelConstructor, item);
-                            var connectedModels = traverseModel(modelName, model, this_1.schema.namespaces[namespaceName], this_1.modelInstanceCreator, this_1.getModelConstructorByModelName);
-                            var keyValuesPath = this_1.getIndexKeyValuesPath(model);
-                            var instance = connectedModels.find(function (_a) {
-                                var instance = _a.instance;
-                                var instanceKeyValuesPath = _this.getIndexKeyValuesPath(instance);
-                                return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
-                            }).instance;
-                            batch.push(instance);
-                        };
-                        this_1 = this;
-                        try {
-                            for (items_2 = __values(items), items_2_1 = items_2.next(); !items_2_1.done; items_2_1 = items_2.next()) {
-                                item = items_2_1.value;
-                                _loop_2(item);
-                            }
-                        }
-                        catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                        finally {
-                            try {
-                                if (items_2_1 && !items_2_1.done && (_a = items_2.return)) _a.call(items_2);
-                            }
-                            finally { if (e_8) throw e_8.error; }
-                        }
-                        return [4 /*yield*/, this.db.batchSave(storeName, batch, keys)];
-                    case 1: return [2 /*return*/, _b.sent()];
+            var allRecords, indices, childRecords;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.db.getAll(storeName)];
+                    case 1:
+                        allRecords = _a.sent();
+                        indices = index.split(IDENTIFIER_KEY_SEPARATOR);
+                        childRecords = allRecords.filter(function (childItem) {
+                            return indices.every(function (index) { return keyValues.includes(childItem[index]); });
+                        });
+                        return [2 /*return*/, childRecords];
                 }
             });
         });
     };
+    //#region platform-specific helper methods
+    /**
+     * Retrieves concatenated primary key values from a model
+     *
+     * @param model
+     * @returns
+     */
+    AsyncStorageAdapter.prototype.getIndexKeyValuesPath = function (model) {
+        return this.getIndexKeyValuesFromModel(model).join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+    };
     return AsyncStorageAdapter;
-}());
+}(StorageAdapterBase));
 export { AsyncStorageAdapter };
 export default new AsyncStorageAdapter();
 //# sourceMappingURL=AsyncStorageAdapter.js.map