@aws-amplify/datastore 3.7.3 → 3.7.4-custom-pk.86

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

@@ -58,6 +58,7 @@ import { ModelPredicateCreator, ModelSortPredicateCreator, } from '../../predica
 import { isPredicateObj, OpType, QueryOne, } from '../../types';
 import { exhaustiveCheck, getIndex, getIndexFromAssociation, isModelConstructor, traverseModel, validatePredicate, sortCompareFunction, } from '../../util';
 var logger = new Logger('DataStore');
+var DEFAULT_PRIMARY_KEY_SEPARATOR = '#';
 var AsyncStorageAdapter = /** @class */ (function () {
     function AsyncStorageAdapter() {
     }
@@ -70,6 +71,45 @@ var AsyncStorageAdapter = /** @class */ (function () {
         var storeName = namespace + "_" + modelName;
         return storeName;
     };
+    // Returns primary keys for a model
+    AsyncStorageAdapter.prototype.getIndexKeys = function (namespaceName, modelName) {
+        var _a;
+        var namespace = this.schema.namespaces[namespaceName];
+        var keyPath = (_a = namespace === null || namespace === void 0 ? void 0 : namespace.keys[modelName]) === null || _a === void 0 ? void 0 : _a.primaryKey;
+        if (keyPath) {
+            return keyPath;
+        }
+        return ['id'];
+    };
+    // Retrieves concatenated primary key values from a model
+    AsyncStorageAdapter.prototype.getIndexKeyValuesPath = function (model) {
+        var modelConstructor = Object.getPrototypeOf(model)
+            .constructor;
+        var namespaceName = this.namespaceResolver(modelConstructor);
+        var keys = this.getIndexKeys(namespaceName, modelConstructor.name);
+        // Retrieve key values from model
+        var keyValues = keys.map(function (field) { return model[field]; });
+        // Return concatenated key values
+        return keyValues.join(DEFAULT_PRIMARY_KEY_SEPARATOR);
+    };
+    // Retrieves concatenated primary key values from a model
+    AsyncStorageAdapter.prototype.getIndexKeyValues = function (model) {
+        var modelConstructor = Object.getPrototypeOf(model)
+            .constructor;
+        var namespaceName = this.namespaceResolver(modelConstructor);
+        var keys = this.getIndexKeys(namespaceName, modelConstructor.name);
+        // Retrieve key values from model
+        return keys.map(function (field) { return model[field]; });
+    };
+    AsyncStorageAdapter.prototype.keysEqual = function (keysA, keysB) {
+        if (keysA.length !== keysB.length) {
+            return false;
+        }
+        if (keysA.length === 1) {
+            return keysA[0] === keysB[0];
+        }
+        return keysA.every(function (key, idx) { return key === keysB[idx]; });
+    };
     AsyncStorageAdapter.prototype.setUp = function (theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
         return __awaiter(this, void 0, void 0, function () {
             var error_1;
@@ -115,7 +155,7 @@ var AsyncStorageAdapter = /** @class */ (function () {
     AsyncStorageAdapter.prototype.save = function (model, condition) {
         var e_1, _a;
         return __awaiter(this, void 0, void 0, function () {
-            var modelConstructor, storeName, connectedModels, namespaceName, set, connectionStoreNames, fromDB, predicates, predicateObjs, type, isValid, msg, result, connectionStoreNames_1, connectionStoreNames_1_1, resItem, storeName_1, item, instance, id, fromDB_1, opType, e_1_1;
+            var modelConstructor, storeName, namespaceName, connectedModels, set, connectionStoreNames, keyValuesPath, fromDB, predicates, predicateObjs, type, isValid, msg, result, connectionStoreNames_1, connectionStoreNames_1_1, resItem, storeName_1, item, instance, keys, itemKeyValues, itemKeyValuesPath, fromDB_1, opType, modelKeyValues, keysEqual, e_1_1;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -123,16 +163,18 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         modelConstructor = Object.getPrototypeOf(model)
                             .constructor;
                         storeName = this.getStorenameForModel(modelConstructor);
-                        connectedModels = traverseModel(modelConstructor.name, model, this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
                         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 = _this.getStorename(namespaceName, modelName);
                             set.add(storeName);
-                            return { storeName: storeName, item: item, instance: instance };
+                            var keys = _this.getIndexKeys(namespaceName, modelName);
+                            return { storeName: storeName, item: item, instance: instance, keys: keys };
                         });
-                        return [4 /*yield*/, this.db.get(model.id, storeName)];
+                        keyValuesPath = this.getIndexKeyValuesPath(model);
+                        return [4 /*yield*/, this.db.get(keyValuesPath, storeName)];
                     case 1:
                         fromDB = _b.sent();
                         if (condition && fromDB) {
@@ -155,14 +197,17 @@ var AsyncStorageAdapter = /** @class */ (function () {
                     case 4:
                         if (!(connectionStoreNames_1_1 = _b.sent(), !connectionStoreNames_1_1.done)) return [3 /*break*/, 8];
                         resItem = connectionStoreNames_1_1.value;
-                        storeName_1 = resItem.storeName, item = resItem.item, instance = resItem.instance;
-                        id = item.id;
-                        return [4 /*yield*/, this.db.get(id, storeName_1)];
+                        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_SEPARATOR);
+                        return [4 /*yield*/, this.db.get(itemKeyValuesPath, storeName_1)];
                     case 5:
                         fromDB_1 = _b.sent();
                         opType = fromDB_1 ? OpType.UPDATE : OpType.INSERT;
-                        if (!(id === model.id || opType === OpType.INSERT)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.db.save(item, storeName_1)];
+                        modelKeyValues = this.getIndexKeyValues(model);
+                        keysEqual = this.keysEqual(itemKeyValues, modelKeyValues);
+                        if (!(keysEqual || opType === OpType.INSERT)) return [3 /*break*/, 7];
+                        return [4 /*yield*/, this.db.save(item, storeName_1, keys, itemKeyValuesPath)];
                     case 6:
                         _b.sent();
                         result.push([instance, opType]);
@@ -194,7 +239,7 @@ var AsyncStorageAdapter = /** @class */ (function () {
         var records_1, records_1_1, records_2, records_2_1;
         var e_2, _a, e_3, _b, e_4, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var namespace, relations, connectionStoreNames, modelConstructor, relations_1, relations_1_1, relation, fieldName, modelName, targetName, relationType, storeName, modelConstructor_1, _d, recordItem, getByfield, connectionRecord, e_3_1, recordItem, connectionRecord, e_4_1, e_2_1;
+            var namespace, relations, connectionStoreNames, modelConstructor, relations_1, relations_1_1, relation, fieldName, modelName, targetName, targetNames, relationType, storeName, modelConstructor_1, _d, recordItem, getByFields, allPresent, keys, connectionRecord, getByfield, key, connectionRecord, e_3_1, recordItem, allPresent, keys, connectionRecord, key, connectionRecord, e_4_1, e_2_1;
             var _this = this;
             return __generator(this, function (_e) {
                 switch (_e.label) {
@@ -213,121 +258,171 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         }
                         _e.label = 1;
                     case 1:
-                        _e.trys.push([1, 34, 35, 40]);
+                        _e.trys.push([1, 38, 39, 44]);
                         relations_1 = __asyncValues(relations);
                         _e.label = 2;
                     case 2: return [4 /*yield*/, relations_1.next()];
                     case 3:
-                        if (!(relations_1_1 = _e.sent(), !relations_1_1.done)) return [3 /*break*/, 33];
+                        if (!(relations_1_1 = _e.sent(), !relations_1_1.done)) return [3 /*break*/, 37];
                         relation = relations_1_1.value;
-                        fieldName = relation.fieldName, modelName = relation.modelName, targetName = relation.targetName, relationType = relation.relationType;
+                        fieldName = relation.fieldName, modelName = relation.modelName, targetName = relation.targetName, targetNames = relation.targetNames, relationType = relation.relationType;
                         storeName = this.getStorename(namespaceName, modelName);
                         modelConstructor_1 = this.getModelConstructorByModelName(namespaceName, modelName);
                         _d = relationType;
                         switch (_d) {
                             case 'HAS_ONE': return [3 /*break*/, 4];
-                            case 'BELONGS_TO': return [3 /*break*/, 17];
-                            case 'HAS_MANY': return [3 /*break*/, 30];
+                            case 'BELONGS_TO': return [3 /*break*/, 19];
+                            case 'HAS_MANY': return [3 /*break*/, 34];
                         }
-                        return [3 /*break*/, 31];
+                        return [3 /*break*/, 35];
                     case 4:
-                        _e.trys.push([4, 10, 11, 16]);
+                        _e.trys.push([4, 12, 13, 18]);
                         records_1 = __asyncValues(records);
                         _e.label = 5;
                     case 5: return [4 /*yield*/, records_1.next()];
                     case 6:
-                        if (!(records_1_1 = _e.sent(), !records_1_1.done)) return [3 /*break*/, 9];
+                        if (!(records_1_1 = _e.sent(), !records_1_1.done)) return [3 /*break*/, 11];
                         recordItem = records_1_1.value;
-                        getByfield = recordItem[targetName] ? targetName : fieldName;
-                        if (!recordItem[getByfield])
-                            return [3 /*break*/, 9];
-                        return [4 /*yield*/, this.db.get(recordItem[getByfield], storeName)];
+                        if (!(targetNames === null || targetNames === void 0 ? void 0 : targetNames.length)) return [3 /*break*/, 8];
+                        getByFields = [];
+                        allPresent = void 0;
+                        // iterate through all targetnames to make sure they are all present in the recordItem
+                        allPresent = targetNames.every(function (targetName) {
+                            return recordItem[targetName] != null;
+                        });
+                        if (!allPresent) {
+                            return [3 /*break*/, 11];
+                        }
+                        getByFields = targetNames;
+                        keys = getByFields
+                            .map(function (getByField) { return recordItem[getByField]; })
+                            .join(DEFAULT_PRIMARY_KEY_SEPARATOR);
+                        return [4 /*yield*/, this.db.get(keys, storeName)];
                     case 7:
                         connectionRecord = _e.sent();
                         recordItem[fieldName] =
                             connectionRecord &&
                                 this.modelInstanceCreator(modelConstructor_1, connectionRecord);
-                        _e.label = 8;
-                    case 8: return [3 /*break*/, 5];
-                    case 9: return [3 /*break*/, 16];
-                    case 10:
+                        return [3 /*break*/, 10];
+                    case 8:
+                        getByfield = recordItem[targetName]
+                            ? targetName
+                            : fieldName;
+                        if (!recordItem[getByfield])
+                            return [3 /*break*/, 11];
+                        key = recordItem[getByfield];
+                        return [4 /*yield*/, this.db.get(key, storeName)];
+                    case 9:
+                        connectionRecord = _e.sent();
+                        recordItem[fieldName] =
+                            connectionRecord &&
+                                this.modelInstanceCreator(modelConstructor_1, connectionRecord);
+                        _e.label = 10;
+                    case 10: return [3 /*break*/, 5];
+                    case 11: return [3 /*break*/, 18];
+                    case 12:
                         e_3_1 = _e.sent();
                         e_3 = { error: e_3_1 };
-                        return [3 /*break*/, 16];
-                    case 11:
-                        _e.trys.push([11, , 14, 15]);
-                        if (!(records_1_1 && !records_1_1.done && (_b = records_1.return))) return [3 /*break*/, 13];
+                        return [3 /*break*/, 18];
+                    case 13:
+                        _e.trys.push([13, , 16, 17]);
+                        if (!(records_1_1 && !records_1_1.done && (_b = records_1.return))) return [3 /*break*/, 15];
                         return [4 /*yield*/, _b.call(records_1)];
-                    case 12:
-                        _e.sent();
-                        _e.label = 13;
-                    case 13: return [3 /*break*/, 15];
                     case 14:
+                        _e.sent();
+                        _e.label = 15;
+                    case 15: return [3 /*break*/, 17];
+                    case 16:
                         if (e_3) throw e_3.error;
                         return [7 /*endfinally*/];
-                    case 15: return [7 /*endfinally*/];
-                    case 16: return [3 /*break*/, 32];
-                    case 17:
-                        _e.trys.push([17, 23, 24, 29]);
-                        records_2 = __asyncValues(records);
-                        _e.label = 18;
-                    case 18: return [4 /*yield*/, records_2.next()];
+                    case 17: return [7 /*endfinally*/];
+                    case 18: return [3 /*break*/, 36];
                     case 19:
-                        if (!(records_2_1 = _e.sent(), !records_2_1.done)) return [3 /*break*/, 22];
+                        _e.trys.push([19, 27, 28, 33]);
+                        records_2 = __asyncValues(records);
+                        _e.label = 20;
+                    case 20: return [4 /*yield*/, records_2.next()];
+                    case 21:
+                        if (!(records_2_1 = _e.sent(), !records_2_1.done)) return [3 /*break*/, 26];
                         recordItem = records_2_1.value;
-                        if (!recordItem[targetName]) return [3 /*break*/, 21];
-                        return [4 /*yield*/, this.db.get(recordItem[targetName], storeName)];
-                    case 20:
+                        if (!(targetNames === null || targetNames === void 0 ? void 0 : targetNames.length)) return [3 /*break*/, 23];
+                        allPresent = void 0;
+                        // iterate through all targetnames to make sure they are all present in the recordItem
+                        allPresent = targetNames.every(function (targetName) {
+                            return recordItem[targetName] != null;
+                        });
+                        // If not present, there is not yet a connected record
+                        if (!allPresent) {
+                            return [3 /*break*/, 26];
+                        }
+                        keys = targetNames
+                            .map(function (targetName) { return recordItem[targetName]; })
+                            .join(DEFAULT_PRIMARY_KEY_SEPARATOR);
+                        return [4 /*yield*/, this.db.get(keys, storeName)];
+                    case 22:
                         connectionRecord = _e.sent();
                         recordItem[fieldName] =
                             connectionRecord &&
                                 this.modelInstanceCreator(modelConstructor_1, connectionRecord);
-                        delete recordItem[targetName];
-                        _e.label = 21;
-                    case 21: return [3 /*break*/, 18];
-                    case 22: return [3 /*break*/, 29];
+                        targetNames === null || targetNames === void 0 ? void 0 : targetNames.map(function (targetName) {
+                            delete recordItem[targetName];
+                        });
+                        return [3 /*break*/, 25];
                     case 23:
+                        if (!recordItem[targetName]) return [3 /*break*/, 25];
+                        key = recordItem[targetName];
+                        return [4 /*yield*/, this.db.get(key, storeName)];
+                    case 24:
+                        connectionRecord = _e.sent();
+                        recordItem[fieldName] =
+                            connectionRecord &&
+                                this.modelInstanceCreator(modelConstructor_1, connectionRecord);
+                        delete recordItem[targetName];
+                        _e.label = 25;
+                    case 25: return [3 /*break*/, 20];
+                    case 26: return [3 /*break*/, 33];
+                    case 27:
                         e_4_1 = _e.sent();
                         e_4 = { error: e_4_1 };
-                        return [3 /*break*/, 29];
-                    case 24:
-                        _e.trys.push([24, , 27, 28]);
-                        if (!(records_2_1 && !records_2_1.done && (_c = records_2.return))) return [3 /*break*/, 26];
+                        return [3 /*break*/, 33];
+                    case 28:
+                        _e.trys.push([28, , 31, 32]);
+                        if (!(records_2_1 && !records_2_1.done && (_c = records_2.return))) return [3 /*break*/, 30];
                         return [4 /*yield*/, _c.call(records_2)];
-                    case 25:
+                    case 29:
                         _e.sent();
-                        _e.label = 26;
-                    case 26: return [3 /*break*/, 28];
-                    case 27:
+                        _e.label = 30;
+                    case 30: return [3 /*break*/, 32];
+                    case 31:
                         if (e_4) throw e_4.error;
                         return [7 /*endfinally*/];
-                    case 28: return [7 /*endfinally*/];
-                    case 29: return [3 /*break*/, 32];
-                    case 30: 
+                    case 32: return [7 /*endfinally*/];
+                    case 33: return [3 /*break*/, 36];
+                    case 34: 
                     // TODO: Lazy loading
-                    return [3 /*break*/, 32];
-                    case 31:
+                    return [3 /*break*/, 36];
+                    case 35:
                         exhaustiveCheck(relationType);
-                        return [3 /*break*/, 32];
-                    case 32: return [3 /*break*/, 2];
-                    case 33: return [3 /*break*/, 40];
-                    case 34:
+                        return [3 /*break*/, 36];
+                    case 36: return [3 /*break*/, 2];
+                    case 37: return [3 /*break*/, 44];
+                    case 38:
                         e_2_1 = _e.sent();
                         e_2 = { error: e_2_1 };
-                        return [3 /*break*/, 40];
-                    case 35:
-                        _e.trys.push([35, , 38, 39]);
-                        if (!(relations_1_1 && !relations_1_1.done && (_a = relations_1.return))) return [3 /*break*/, 37];
+                        return [3 /*break*/, 44];
+                    case 39:
+                        _e.trys.push([39, , 42, 43]);
+                        if (!(relations_1_1 && !relations_1_1.done && (_a = relations_1.return))) return [3 /*break*/, 41];
                         return [4 /*yield*/, _a.call(relations_1)];
-                    case 36:
+                    case 40:
                         _e.sent();
-                        _e.label = 37;
-                    case 37: return [3 /*break*/, 39];
-                    case 38:
+                        _e.label = 41;
+                    case 41: return [3 /*break*/, 43];
+                    case 42:
                         if (e_2) throw e_2.error;
                         return [7 /*endfinally*/];
-                    case 39: return [7 /*endfinally*/];
-                    case 40: return [2 /*return*/, records.map(function (record) {
+                    case 43: return [7 /*endfinally*/];
+                    case 44: return [2 /*return*/, records.map(function (record) {
                             return _this.modelInstanceCreator(modelConstructor, record);
                         })];
                 }
@@ -336,7 +431,7 @@ var AsyncStorageAdapter = /** @class */ (function () {
     };
     AsyncStorageAdapter.prototype.query = function (modelConstructor, predicate, pagination) {
         return __awaiter(this, void 0, void 0, function () {
-            var storeName, namespaceName, predicates, queryById, hasSort, hasPagination, records;
+            var storeName, namespaceName, predicates, keys, queryByKey, hasSort, hasPagination, records;
             var _this = this;
             return __generator(this, function (_a) {
                 switch (_a.label) {
@@ -344,7 +439,8 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         storeName = this.getStorenameForModel(modelConstructor);
                         namespaceName = this.namespaceResolver(modelConstructor);
                         predicates = predicate && ModelPredicateCreator.getPredicates(predicate);
-                        queryById = predicates && this.idFromPredicate(predicates);
+                        keys = this.getIndexKeys(namespaceName, modelConstructor.name);
+                        queryByKey = predicates && this.keyValueFromPredicate(predicates, keys);
                         hasSort = pagination && pagination.sort;
                         hasPagination = pagination && pagination.limit;
                         return [4 /*yield*/, (function () { return __awaiter(_this, void 0, void 0, function () {
@@ -352,8 +448,8 @@ var AsyncStorageAdapter = /** @class */ (function () {
                                 return __generator(this, function (_a) {
                                     switch (_a.label) {
                                         case 0:
-                                            if (!queryById) return [3 /*break*/, 2];
-                                            return [4 /*yield*/, this.getById(storeName, queryById)];
+                                            if (!queryByKey) return [3 /*break*/, 2];
+                                            return [4 /*yield*/, this.getByKey(storeName, queryByKey)];
                                         case 1:
                                             record = _a.sent();
                                             return [2 /*return*/, record ? [record] : []];
@@ -381,12 +477,12 @@ var AsyncStorageAdapter = /** @class */ (function () {
             });
         });
     };
-    AsyncStorageAdapter.prototype.getById = function (storeName, id) {
+    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(id, storeName)];
+                    case 0: return [4 /*yield*/, this.db.get(keyValuePath, storeName)];
                     case 1:
                         record = _a.sent();
                         return [2 /*return*/, record];
@@ -404,11 +500,33 @@ var AsyncStorageAdapter = /** @class */ (function () {
             });
         });
     };
-    AsyncStorageAdapter.prototype.idFromPredicate = function (predicates) {
+    AsyncStorageAdapter.prototype.keyValueFromPredicate = function (predicates, keys) {
+        var e_5, _a;
         var predicateObjs = predicates.predicates;
-        var idPredicate = predicateObjs.length === 1 &&
-            predicateObjs.find(function (p) { return isPredicateObj(p) && p.field === 'id' && p.operator === 'eq'; });
-        return idPredicate && idPredicate.operand;
+        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_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (keys_1_1 && !keys_1_1.done && (_a = keys_1.return)) _a.call(keys_1);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        return keyValues.length === keys.length
+            ? keyValues.join(DEFAULT_PRIMARY_KEY_SEPARATOR)
+            : undefined;
     };
     AsyncStorageAdapter.prototype.filterOnPredicate = function (storeName, predicates) {
         return __awaiter(this, void 0, void 0, function () {
@@ -462,7 +580,7 @@ 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, fromDB, msg, predicates, predicateObjs, type, isValid, msg, relations, relations, deletedModels;
+            var deleteQueue, modelConstructor, nameSpace, models, relations, deletedModels, deletedModels, model, modelConstructor, namespaceName, storeName, keyValuePath, fromDB, msg, predicates, predicateObjs, type, isValid, msg, relations, relations, deletedModels;
             return __generator(this, function (_a) {
                 switch (_a.label) {
                     case 0:
@@ -503,10 +621,11 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         model = modelOrModelConstructor;
                         modelConstructor = Object.getPrototypeOf(model)
                             .constructor;
-                        nameSpace = this.namespaceResolver(modelConstructor);
+                        namespaceName = this.namespaceResolver(modelConstructor);
                         storeName = this.getStorenameForModel(modelConstructor);
                         if (!condition) return [3 /*break*/, 11];
-                        return [4 /*yield*/, this.db.get(model.id, storeName)];
+                        keyValuePath = this.getIndexKeyValuesPath(model);
+                        return [4 /*yield*/, this.db.get(keyValuePath, storeName)];
                     case 9:
                         fromDB = _a.sent();
                         if (fromDB === undefined) {
@@ -522,16 +641,14 @@ var AsyncStorageAdapter = /** @class */ (function () {
                             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)];
+                        relations = this.schema.namespaces[namespaceName].relationships[modelConstructor.name].relationTypes;
+                        return [4 /*yield*/, this.deleteTraverse(relations, [model], modelConstructor.name, namespaceName, deleteQueue)];
                     case 10:
                         _a.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)];
+                        relations = this.schema.namespaces[namespaceName].relationships[modelConstructor.name].relationTypes;
+                        return [4 /*yield*/, this.deleteTraverse(relations, [model], modelConstructor.name, namespaceName, deleteQueue)];
                     case 12:
                         _a.sent();
                         _a.label = 13;
@@ -550,9 +667,9 @@ var AsyncStorageAdapter = /** @class */ (function () {
     };
     AsyncStorageAdapter.prototype.deleteItem = function (deleteQueue) {
         var deleteQueue_1, deleteQueue_1_1;
-        var e_5, _a, e_6, _b;
+        var e_6, _a, e_7, _b;
         return __awaiter(this, void 0, void 0, function () {
-            var deleteItem, storeName, items, items_1, items_1_1, item, id, e_6_1, e_5_1;
+            var deleteItem, storeName, items, items_1, items_1_1, item, keyValuesPath, e_7_1, e_6_1;
             return __generator(this, function (_c) {
                 switch (_c.label) {
                     case 0:
@@ -575,16 +692,16 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         item = items_1_1.value;
                         if (!item) return [3 /*break*/, 7];
                         if (!(typeof item === 'object')) return [3 /*break*/, 7];
-                        id = item['id'];
-                        return [4 /*yield*/, this.db.delete(id, storeName)];
+                        keyValuesPath = this.getIndexKeyValuesPath(item);
+                        return [4 /*yield*/, this.db.delete(keyValuesPath, storeName)];
                     case 6:
                         _c.sent();
                         _c.label = 7;
                     case 7: return [3 /*break*/, 4];
                     case 8: return [3 /*break*/, 15];
                     case 9:
-                        e_6_1 = _c.sent();
-                        e_6 = { error: e_6_1 };
+                        e_7_1 = _c.sent();
+                        e_7 = { error: e_7_1 };
                         return [3 /*break*/, 15];
                     case 10:
                         _c.trys.push([10, , 13, 14]);
@@ -595,14 +712,14 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         _c.label = 12;
                     case 12: return [3 /*break*/, 14];
                     case 13:
-                        if (e_6) throw e_6.error;
+                        if (e_7) throw e_7.error;
                         return [7 /*endfinally*/];
                     case 14: return [7 /*endfinally*/];
                     case 15: return [3 /*break*/, 1];
                     case 16: return [3 /*break*/, 23];
                     case 17:
-                        e_5_1 = _c.sent();
-                        e_5 = { error: e_5_1 };
+                        e_6_1 = _c.sent();
+                        e_6 = { error: e_6_1 };
                         return [3 /*break*/, 23];
                     case 18:
                         _c.trys.push([18, , 21, 22]);
@@ -613,7 +730,7 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         _c.label = 20;
                     case 20: return [3 /*break*/, 22];
                     case 21:
-                        if (e_5) throw e_5.error;
+                        if (e_6) throw e_6.error;
                         return [7 /*endfinally*/];
                     case 22: return [7 /*endfinally*/];
                     case 23: return [2 /*return*/];
@@ -631,21 +748,21 @@ var AsyncStorageAdapter = /** @class */ (function () {
      */
     AsyncStorageAdapter.prototype.deleteTraverse = function (relations, models, srcModel, nameSpace, deleteQueue) {
         var relations_2, relations_2_1, models_1, models_1_1, models_2, models_2_1;
-        var e_7, _a, e_8, _b, e_9, _c;
+        var e_8, _a, e_9, _b, e_10, _c;
         return __awaiter(this, void 0, void 0, function () {
-            var rel, relationType, modelName, targetName, storeName, index, _d, model, hasOneIndex, hasOneCustomField, value, allRecords, recordToDelete, e_8_1, model, allRecords, childrenArray, e_9_1, e_7_1;
+            var rel, relationType, modelName, targetName, targetNames, associatedWith, storeName, index, _d, model, hasOneIndex_1, hasConnectedModelFields, keyValuesPath, values_1, allRecords, recordToDelete, hasOneIndex_2, hasOneCustomField, keyValuesPath, value_1, allRecords, recordToDelete, e_9_1, model, keyValues, allRecords, indices, childrenArray, e_10_1, e_8_1;
             var _this = this;
             return __generator(this, function (_e) {
                 switch (_e.label) {
                     case 0:
-                        _e.trys.push([0, 35, 36, 41]);
+                        _e.trys.push([0, 38, 39, 44]);
                         relations_2 = __asyncValues(relations);
                         _e.label = 1;
                     case 1: return [4 /*yield*/, relations_2.next()];
                     case 2:
-                        if (!(relations_2_1 = _e.sent(), !relations_2_1.done)) return [3 /*break*/, 34];
+                        if (!(relations_2_1 = _e.sent(), !relations_2_1.done)) return [3 /*break*/, 37];
                         rel = relations_2_1.value;
-                        relationType = rel.relationType, modelName = rel.modelName, targetName = rel.targetName;
+                        relationType = rel.relationType, modelName = rel.modelName, targetName = rel.targetName, targetNames = rel.targetNames, associatedWith = rel.associatedWith;
                         storeName = this.getStorename(nameSpace, modelName);
                         index = getIndex(this.schema.namespaces[nameSpace].relationships[modelName]
                             .relationTypes, srcModel) ||
@@ -656,112 +773,159 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         _d = relationType;
                         switch (_d) {
                             case 'HAS_ONE': return [3 /*break*/, 3];
-                            case 'HAS_MANY': return [3 /*break*/, 17];
-                            case 'BELONGS_TO': return [3 /*break*/, 31];
+                            case 'HAS_MANY': return [3 /*break*/, 20];
+                            case 'BELONGS_TO': return [3 /*break*/, 34];
                         }
-                        return [3 /*break*/, 32];
+                        return [3 /*break*/, 35];
                     case 3:
-                        _e.trys.push([3, 10, 11, 16]);
+                        _e.trys.push([3, 13, 14, 19]);
                         models_1 = __asyncValues(models);
                         _e.label = 4;
                     case 4: return [4 /*yield*/, models_1.next()];
                     case 5:
-                        if (!(models_1_1 = _e.sent(), !models_1_1.done)) return [3 /*break*/, 9];
+                        if (!(models_1_1 = _e.sent(), !models_1_1.done)) return [3 /*break*/, 12];
                         model = models_1_1.value;
-                        hasOneIndex = index || 'byId';
-                        hasOneCustomField = targetName in model;
-                        value = hasOneCustomField ? model[targetName] : model.id;
-                        if (!value)
-                            return [3 /*break*/, 9];
+                        if (!(targetNames && (targetNames === null || targetNames === void 0 ? void 0 : targetNames.length))) return [3 /*break*/, 8];
+                        hasOneIndex_1 = index || associatedWith;
+                        hasConnectedModelFields = targetNames.every(function (targetName) {
+                            return model.hasOwnProperty(targetName);
+                        });
+                        keyValuesPath = this.getIndexKeyValuesPath(model);
+                        if (hasConnectedModelFields) {
+                            // Values will be that of the child model
+                            values_1 = targetNames.map(function (targetName) { return model[targetName]; });
+                        }
+                        else {
+                            // values will be that of the parent model
+                            values_1 = keyValuesPath;
+                        }
+                        if (values_1.length === 0)
+                            return [3 /*break*/, 12];
                         return [4 /*yield*/, this.db.getAll(storeName)];
                     case 6:
                         allRecords = _e.sent();
-                        recordToDelete = allRecords.filter(function (childItem) { return childItem[hasOneIndex] === value; });
+                        recordToDelete = void 0;
+                        // values === targetNames
+                        if (hasConnectedModelFields) {
+                            /**
+                             * Retrieve record by finding the record where all
+                             * targetNames are present on the connected model
+                             */
+                            recordToDelete = allRecords.filter(function (childItem) {
+                                return values_1.every(function (value) { return childItem[value] != null; });
+                            });
+                        }
+                        else {
+                            // values === keyValuePath
+                            recordToDelete = allRecords.filter(function (childItem) { return childItem[hasOneIndex_1] === values_1; });
+                        }
                         return [4 /*yield*/, this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName]
                                 .relationTypes, recordToDelete, modelName, nameSpace, deleteQueue)];
                     case 7:
                         _e.sent();
-                        _e.label = 8;
-                    case 8: return [3 /*break*/, 4];
-                    case 9: return [3 /*break*/, 16];
+                        return [3 /*break*/, 11];
+                    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*/, 12];
+                        return [4 /*yield*/, this.db.getAll(storeName)];
+                    case 9:
+                        allRecords = _e.sent();
+                        recordToDelete = allRecords.filter(function (childItem) { return childItem[hasOneIndex_2] === value_1; });
+                        return [4 /*yield*/, this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName]
+                                .relationTypes, recordToDelete, modelName, nameSpace, deleteQueue)];
                     case 10:
-                        e_8_1 = _e.sent();
-                        e_8 = { error: e_8_1 };
-                        return [3 /*break*/, 16];
-                    case 11:
-                        _e.trys.push([11, , 14, 15]);
-                        if (!(models_1_1 && !models_1_1.done && (_b = models_1.return))) return [3 /*break*/, 13];
-                        return [4 /*yield*/, _b.call(models_1)];
-                    case 12:
                         _e.sent();
-                        _e.label = 13;
-                    case 13: return [3 /*break*/, 15];
+                        _e.label = 11;
+                    case 11: return [3 /*break*/, 4];
+                    case 12: return [3 /*break*/, 19];
+                    case 13:
+                        e_9_1 = _e.sent();
+                        e_9 = { error: e_9_1 };
+                        return [3 /*break*/, 19];
                     case 14:
-                        if (e_8) throw e_8.error;
-                        return [7 /*endfinally*/];
-                    case 15: return [7 /*endfinally*/];
-                    case 16: return [3 /*break*/, 33];
+                        _e.trys.push([14, , 17, 18]);
+                        if (!(models_1_1 && !models_1_1.done && (_b = models_1.return))) return [3 /*break*/, 16];
+                        return [4 /*yield*/, _b.call(models_1)];
+                    case 15:
+                        _e.sent();
+                        _e.label = 16;
+                    case 16: return [3 /*break*/, 18];
                     case 17:
-                        _e.trys.push([17, 24, 25, 30]);
+                        if (e_9) throw e_9.error;
+                        return [7 /*endfinally*/];
+                    case 18: return [7 /*endfinally*/];
+                    case 19: return [3 /*break*/, 36];
+                    case 20:
+                        _e.trys.push([20, 27, 28, 33]);
                         models_2 = __asyncValues(models);
-                        _e.label = 18;
-                    case 18: return [4 /*yield*/, models_2.next()];
-                    case 19:
-                        if (!(models_2_1 = _e.sent(), !models_2_1.done)) return [3 /*break*/, 23];
+                        _e.label = 21;
+                    case 21: return [4 /*yield*/, models_2.next()];
+                    case 22:
+                        if (!(models_2_1 = _e.sent(), !models_2_1.done)) return [3 /*break*/, 26];
                         model = models_2_1.value;
+                        keyValues = this.getIndexKeyValues(model);
                         return [4 /*yield*/, this.db.getAll(storeName)];
-                    case 20:
+                    case 23:
                         allRecords = _e.sent();
-                        childrenArray = allRecords.filter(function (childItem) { return childItem[index] === model.id; });
+                        indices = index.split('-');
+                        childrenArray = allRecords.filter(function (childItem) {
+                            return indices.every(function (index) { return keyValues.includes(childItem[index]); });
+                        });
                         return [4 /*yield*/, this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName]
                                 .relationTypes, childrenArray, modelName, nameSpace, deleteQueue)];
-                    case 21:
-                        _e.sent();
-                        _e.label = 22;
-                    case 22: return [3 /*break*/, 18];
-                    case 23: return [3 /*break*/, 30];
                     case 24:
-                        e_9_1 = _e.sent();
-                        e_9 = { error: e_9_1 };
-                        return [3 /*break*/, 30];
-                    case 25:
-                        _e.trys.push([25, , 28, 29]);
-                        if (!(models_2_1 && !models_2_1.done && (_c = models_2.return))) return [3 /*break*/, 27];
-                        return [4 /*yield*/, _c.call(models_2)];
-                    case 26:
                         _e.sent();
-                        _e.label = 27;
-                    case 27: return [3 /*break*/, 29];
+                        _e.label = 25;
+                    case 25: return [3 /*break*/, 21];
+                    case 26: return [3 /*break*/, 33];
+                    case 27:
+                        e_10_1 = _e.sent();
+                        e_10 = { error: e_10_1 };
+                        return [3 /*break*/, 33];
                     case 28:
-                        if (e_9) throw e_9.error;
+                        _e.trys.push([28, , 31, 32]);
+                        if (!(models_2_1 && !models_2_1.done && (_c = models_2.return))) return [3 /*break*/, 30];
+                        return [4 /*yield*/, _c.call(models_2)];
+                    case 29:
+                        _e.sent();
+                        _e.label = 30;
+                    case 30: return [3 /*break*/, 32];
+                    case 31:
+                        if (e_10) throw e_10.error;
                         return [7 /*endfinally*/];
-                    case 29: return [7 /*endfinally*/];
-                    case 30: return [3 /*break*/, 33];
-                    case 31: 
+                    case 32: return [7 /*endfinally*/];
+                    case 33: return [3 /*break*/, 36];
+                    case 34: 
                     // Intentionally blank
-                    return [3 /*break*/, 33];
-                    case 32:
-                        exhaustiveCheck(relationType);
-                        return [3 /*break*/, 33];
-                    case 33: return [3 /*break*/, 1];
-                    case 34: return [3 /*break*/, 41];
+                    return [3 /*break*/, 36];
                     case 35:
-                        e_7_1 = _e.sent();
-                        e_7 = { error: e_7_1 };
-                        return [3 /*break*/, 41];
-                    case 36:
-                        _e.trys.push([36, , 39, 40]);
-                        if (!(relations_2_1 && !relations_2_1.done && (_a = relations_2.return))) return [3 /*break*/, 38];
+                        exhaustiveCheck(relationType);
+                        return [3 /*break*/, 36];
+                    case 36: return [3 /*break*/, 1];
+                    case 37: return [3 /*break*/, 44];
+                    case 38:
+                        e_8_1 = _e.sent();
+                        e_8 = { error: e_8_1 };
+                        return [3 /*break*/, 44];
+                    case 39:
+                        _e.trys.push([39, , 42, 43]);
+                        if (!(relations_2_1 && !relations_2_1.done && (_a = relations_2.return))) return [3 /*break*/, 41];
                         return [4 /*yield*/, _a.call(relations_2)];
-                    case 37:
+                    case 40:
                         _e.sent();
-                        _e.label = 38;
-                    case 38: return [3 /*break*/, 40];
-                    case 39:
-                        if (e_7) throw e_7.error;
+                        _e.label = 41;
+                    case 41: return [3 /*break*/, 43];
+                    case 42:
+                        if (e_8) throw e_8.error;
                         return [7 /*endfinally*/];
-                    case 40: return [7 /*endfinally*/];
-                    case 41:
+                    case 43: return [7 /*endfinally*/];
+                    case 44:
                         deleteQueue.push({
                             storeName: this.getStorename(nameSpace, srcModel),
                             items: models.map(function (record) {
@@ -789,21 +953,25 @@ var AsyncStorageAdapter = /** @class */ (function () {
     };
     AsyncStorageAdapter.prototype.batchSave = function (modelConstructor, items) {
         return __awaiter(this, void 0, void 0, function () {
-            var modelName, namespaceName, storeName, batch, _loop_1, this_1, items_2, items_2_1, item;
-            var e_10, _a;
+            var modelName, namespaceName, storeName, keys, batch, _loop_2, this_1, items_2, items_2_1, item;
+            var e_11, _a;
+            var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
                     case 0:
                         modelName = modelConstructor.name;
                         namespaceName = this.namespaceResolver(modelConstructor);
                         storeName = this.getStorename(namespaceName, modelName);
+                        keys = this.getIndexKeys(namespaceName, modelName);
                         batch = [];
-                        _loop_1 = function (item) {
-                            var id = item.id;
-                            var connectedModels = traverseModel(modelConstructor.name, this_1.modelInstanceCreator(modelConstructor, item), this_1.schema.namespaces[this_1.namespaceResolver(modelConstructor)], this_1.modelInstanceCreator, this_1.getModelConstructorByModelName);
+                        _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;
-                                return instance.id === id;
+                                var instanceKeyValuesPath = _this.getIndexKeyValuesPath(instance);
+                                return _this.keysEqual([instanceKeyValuesPath], [keyValuesPath]);
                             }).instance;
                             batch.push(instance);
                         };
@@ -811,17 +979,17 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         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_1(item);
+                                _loop_2(item);
                             }
                         }
-                        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+                        catch (e_11_1) { e_11 = { error: e_11_1 }; }
                         finally {
                             try {
                                 if (items_2_1 && !items_2_1.done && (_a = items_2.return)) _a.call(items_2);
                             }
-                            finally { if (e_10) throw e_10.error; }
+                            finally { if (e_11) throw e_11.error; }
                         }
-                        return [4 /*yield*/, this.db.batchSave(storeName, batch)];
+                        return [4 /*yield*/, this.db.batchSave(storeName, batch, keys)];
                     case 1: return [2 /*return*/, _b.sent()];
                 }
             });