@aws-amplify/datastore 3.12.12 → 3.12.13-custom-pk.1

package/lib/storage/adapter/AsyncStorageAdapter.js

@@ -69,11 +69,19 @@ var AsyncStorageAdapter = /** @class */ (function () {
     AsyncStorageAdapter.prototype.getStorenameForModel = function (modelConstructor) {
         var namespace = this.namespaceResolver(modelConstructor);
         var modelName = modelConstructor.name;
-        return this.getStorename(namespace, modelName);
+        return util_1.getStorename(namespace, modelName);
     };
-    AsyncStorageAdapter.prototype.getStorename = function (namespace, modelName) {
-        var storeName = namespace + "_" + modelName;
-        return storeName;
+    // 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 = util_1.getIndexKeys(this.schema.namespaces[namespaceName], modelConstructor.name);
+        return util_1.extractPrimaryKeyValues(model, keys);
+    };
+    // Retrieves concatenated primary key values from a model
+    AsyncStorageAdapter.prototype.getIndexKeyValuesPath = function (model) {
+        return this.getIndexKeyValuesFromModel(model).join(util_1.DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
     };
     AsyncStorageAdapter.prototype.setUp = function (theSchema, namespaceResolver, modelInstanceCreator, getModelConstructorByModelName) {
         return __awaiter(this, void 0, void 0, function () {
@@ -120,7 +128,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, e_1_1;
             var _this = this;
             return __generator(this, function (_b) {
                 switch (_b.label) {
@@ -128,16 +136,18 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         modelConstructor = Object.getPrototypeOf(model)
                             .constructor;
                         storeName = this.getStorenameForModel(modelConstructor);
-                        connectedModels = util_1.traverseModel(modelConstructor.name, model, this.schema.namespaces[this.namespaceResolver(modelConstructor)], this.modelInstanceCreator, this.getModelConstructorByModelName);
                         namespaceName = this.namespaceResolver(modelConstructor);
+                        connectedModels = util_1.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);
+                            var storeName = util_1.getStorename(namespaceName, modelName);
                             set.add(storeName);
-                            return { storeName: storeName, item: item, instance: instance };
+                            var keys = util_1.getIndexKeys(_this.schema.namespaces[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) {
@@ -160,14 +170,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(util_1.DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+                        return [4 /*yield*/, this.db.get(itemKeyValuesPath, storeName_1)];
                     case 5:
                         fromDB_1 = _b.sent();
                         opType = fromDB_1 ? types_1.OpType.UPDATE : types_1.OpType.INSERT;
-                        if (!(id === model.id || opType === types_1.OpType.INSERT)) return [3 /*break*/, 7];
-                        return [4 /*yield*/, this.db.save(item, storeName_1)];
+                        modelKeyValues = this.getIndexKeyValuesFromModel(model);
+                        if (!(util_1.keysEqual(itemKeyValues, modelKeyValues) ||
+                            opType === types_1.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]);
@@ -199,7 +212,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) {
@@ -208,7 +221,7 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         relations = namespace.relationships[srcModelName].relationTypes;
                         connectionStoreNames = relations.map(function (_a) {
                             var modelName = _a.modelName;
-                            return _this.getStorename(namespaceName, modelName);
+                            return util_1.getStorename(namespaceName, modelName);
                         });
                         modelConstructor = this.getModelConstructorByModelName(namespaceName, srcModelName);
                         if (connectionStoreNames.length === 0) {
@@ -218,121 +231,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;
-                        storeName = this.getStorename(namespaceName, modelName);
+                        fieldName = relation.fieldName, modelName = relation.modelName, targetName = relation.targetName, targetNames = relation.targetNames, relationType = relation.relationType;
+                        storeName = util_1.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(util_1.DEFAULT_PRIMARY_KEY_VALUE_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(util_1.DEFAULT_PRIMARY_KEY_VALUE_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:
                         util_1.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);
                         })];
                 }
@@ -341,7 +404,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) {
@@ -349,7 +412,8 @@ var AsyncStorageAdapter = /** @class */ (function () {
                         storeName = this.getStorenameForModel(modelConstructor);
                         namespaceName = this.namespaceResolver(modelConstructor);
                         predicates = predicate && predicates_1.ModelPredicateCreator.getPredicates(predicate);
-                        queryById = predicates && this.idFromPredicate(predicates);
+                        keys = util_1.getIndexKeys(this.schema.namespaces[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 () {
@@ -357,8 +421,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] : []];
@@ -386,12 +450,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];
@@ -409,11 +473,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 types_1.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 types_1.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(util_1.DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR)
+            : undefined;
     };
     AsyncStorageAdapter.prototype.filterOnPredicate = function (storeName, predicates) {
         return __awaiter(this, void 0, void 0, function () {
@@ -467,7 +553,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:
@@ -508,10 +594,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) {
@@ -527,16 +614,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;
@@ -555,9 +640,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:
@@ -580,16 +665,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]);
@@ -600,14 +685,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]);
@@ -618,7 +703,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*/];
@@ -636,22 +721,22 @@ 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, isUnidirectionalConnection, 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;
-                        storeName = this.getStorename(nameSpace, modelName);
+                        relationType = rel.relationType, modelName = rel.modelName, targetName = rel.targetName, targetNames = rel.targetNames, associatedWith = rel.associatedWith;
+                        storeName = util_1.getStorename(nameSpace, modelName);
                         index = util_1.getIndex(this.schema.namespaces[nameSpace].relationships[modelName]
                             .relationTypes, srcModel) ||
                             // if we were unable to find an index via relationTypes
@@ -661,114 +746,176 @@ 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];
+                        if (index) {
+                            hasOneIndex_1 = index.split(util_1.IDENTIFIER_KEY_SEPARATOR);
+                        }
+                        else if (associatedWith) {
+                            if (Array.isArray(associatedWith)) {
+                                hasOneIndex_1 = associatedWith;
+                            }
+                            else {
+                                hasOneIndex_1 = [associatedWith];
+                            }
+                        }
+                        hasConnectedModelFields = targetNames.every(function (targetName) {
+                            return model.hasOwnProperty(targetName);
+                        });
+                        keyValuesPath = this.getIndexKeyValuesPath(model);
+                        isUnidirectionalConnection = hasOneIndex_1 === associatedWith;
+                        if (hasConnectedModelFields && isUnidirectionalConnection) {
+                            // 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.split(util_1.DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+                        }
+                        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(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]); });
+                            });
+                        }
+                        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.getIndexKeyValuesFromModel(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(util_1.IDENTIFIER_KEY_SEPARATOR);
+                        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:
-                        util_1.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];
+                        util_1.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),
+                            storeName: util_1.getStorename(nameSpace, srcModel),
                             items: models.map(function (record) {
                                 return _this.modelInstanceCreator(_this.getModelConstructorByModelName(nameSpace, srcModel), record);
                             }),
@@ -794,21 +941,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);
+                        storeName = util_1.getStorename(namespaceName, modelName);
+                        keys = util_1.getIndexKeys(this.schema.namespaces[namespaceName], modelName);
                         batch = [];
-                        _loop_1 = function (item) {
-                            var id = item.id;
-                            var connectedModels = util_1.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 = util_1.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 util_1.keysEqual([instanceKeyValuesPath], [keyValuesPath]);
                             }).instance;
                             batch.push(instance);
                         };
@@ -816,17 +967,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()];
                 }
             });