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

package/dist/aws-amplify-datastore.js

@@ -81825,6 +81825,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony import */ var _sync__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ../sync */ "./lib-esm/sync/index.js");
 /* harmony import */ var _types__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ../types */ "./lib-esm/types.js");
 /* harmony import */ var _util__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ../util */ "./lib-esm/util.js");
+/* harmony import */ var _sync_utils__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ../sync/utils */ "./lib-esm/sync/utils.js");
 function _typeof(obj) {
   "@babel/helpers - typeof";
 
@@ -82072,6 +82073,7 @@ var __spread = undefined && undefined.__spread || function () {
 
 
 
+
 Object(immer__WEBPACK_IMPORTED_MODULE_4__["setAutoFreeze"])(true);
 Object(immer__WEBPACK_IMPORTED_MODULE_4__["enablePatches"])();
 var logger = new _aws_amplify_core__WEBPACK_IMPORTED_MODULE_1__["ConsoleLogger"]('DataStore');
@@ -82242,6 +82244,10 @@ function modelInstanceCreator(modelConstructor, init) {
   return new modelConstructor(init);
 }
 
+function isSchemaModel(m) {
+  return m.attributes !== undefined;
+}
+
 var validateModelFields = function validateModelFields(modelDefinition) {
   return function (k, v) {
     var fieldDefinition = modelDefinition.fields[k];
@@ -82257,6 +82263,18 @@ var validateModelFields = function validateModelFields(modelDefinition) {
         throw new Error("Field " + name_1 + " is required");
       }
 
+      if (isSchemaModel(modelDefinition) && !Object(_util__WEBPACK_IMPORTED_MODULE_12__["isIdManaged"])(modelDefinition)) {
+        var keys = Object(_util__WEBPACK_IMPORTED_MODULE_12__["extractPrimaryKeyFieldNames"])(modelDefinition);
+
+        if (keys.includes(k) && v === '') {
+          logger.error(_util__WEBPACK_IMPORTED_MODULE_12__["errorMessages"].idEmptyString, {
+            k: k,
+            value: v
+          });
+          throw new Error(_util__WEBPACK_IMPORTED_MODULE_12__["errorMessages"].idEmptyString);
+        }
+      }
+
       if (Object(_types__WEBPACK_IMPORTED_MODULE_11__["isGraphQLScalarType"])(type)) {
         var jsType_1 = _types__WEBPACK_IMPORTED_MODULE_11__["GraphQLScalarType"].getJSType(type);
         var validateScalar_1 = _types__WEBPACK_IMPORTED_MODULE_11__["GraphQLScalarType"].getValidationFunction(type);
@@ -83204,7 +83222,7 @@ function () {
                   }).subscribe({
                     next: function next(item) {
                       return __awaiter(_this, void 0, void 0, function () {
-                        var message, freshElement;
+                        var message, modelDefinition, keyFields, primaryKeysAndValues, freshElement;
                         return __generator(this, function (_a) {
                           switch (_a.label) {
                             case 0:
@@ -83212,9 +83230,12 @@ function () {
                               if (!(item.opType !== 'DELETE')) return [3
                               /*break*/
                               , 2];
+                              modelDefinition = getModelDefinition(item.model);
+                              keyFields = Object(_util__WEBPACK_IMPORTED_MODULE_12__["extractPrimaryKeyFieldNames"])(modelDefinition);
+                              primaryKeysAndValues = Object(_util__WEBPACK_IMPORTED_MODULE_12__["extractPrimaryKeysAndValues"])(item.element, keyFields);
                               return [4
                               /*yield*/
-                              , this.query(item.model, item.element.id)];
+                              , this.query(item.model, primaryKeysAndValues)];
 
                             case 1:
                               freshElement = _a.sent();
@@ -83327,7 +83348,15 @@ function () {
                 case 1:
                   // first, query and return any locally-available records
                   _a.sent().forEach(function (item) {
-                    return items.set(item.id, item);
+                    var record = item; // TODO: fix query
+
+                    if (Array.isArray(item)) {
+                      record = item[0];
+                    }
+
+                    var itemModelDefinition = getModelDefinition(model);
+                    var idOrPk = Object(_sync_utils__WEBPACK_IMPORTED_MODULE_13__["getIdentifierValue"])(itemModelDefinition, record);
+                    items.set(idOrPk, record);
                   }); // Observe the model and send a stream of updates (debounced).
                   // We need to post-filter results instead of passing criteria through
                   // to have visibility into items that move from in-set to out-of-set.
@@ -83341,13 +83370,22 @@ function () {
 
                     var _b, _c;
 
-                    if (hasPredicate && !Object(_util__WEBPACK_IMPORTED_MODULE_12__["validatePredicate"])(element, predicateGroupType, predicates)) {
-                      if (opType === 'UPDATE' && (items.has(element.id) || itemsChanged.has(element.id))) {
+                    var record = element; // TODO: fix query
+
+                    if (Array.isArray(element)) {
+                      record = element[0];
+                    }
+
+                    var itemModelDefinition = getModelDefinition(model);
+                    var idOrPk = Object(_sync_utils__WEBPACK_IMPORTED_MODULE_13__["getIdentifierValue"])(itemModelDefinition, record);
+
+                    if (hasPredicate && !Object(_util__WEBPACK_IMPORTED_MODULE_12__["validatePredicate"])(record, predicateGroupType, predicates)) {
+                      if (opType === 'UPDATE' && (items.has(idOrPk) || itemsChanged.has(idOrPk))) {
                         // tracking as a "deleted item" will include the item in
                         // page limit calculations and ensure it is removed from the
                         // final items collection, regardless of which collection(s)
                         // it is currently in. (I mean, it could be in both, right!?)
-                        deletedItemIds.push(element.id);
+                        deletedItemIds.push(idOrPk);
                       } else {
                         // ignore updates for irrelevant/filtered items.
                         return;
@@ -83359,9 +83397,9 @@ function () {
 
 
                     if (opType === 'DELETE') {
-                      deletedItemIds.push(element.id);
+                      deletedItemIds.push(idOrPk);
                     } else {
-                      itemsChanged.set(element.id, element);
+                      itemsChanged.set(idOrPk, record);
                     }
 
                     var isSynced = (_c = (_b = _this.sync) === null || _b === void 0 ? void 0 : _b.getModelSyncedStatus(model)) !== null && _c !== void 0 ? _c : false;
@@ -83416,11 +83454,20 @@ function () {
 
           items.clear();
           itemsArray.forEach(function (item) {
-            return items.set(item.id, item);
+            // CPK TODO: fix query
+            var record = item;
+
+            if (Array.isArray(item)) {
+              record = item[0];
+            }
+
+            var itemModelDefinition = getModelDefinition(model);
+            var idOrPk = Object(_sync_utils__WEBPACK_IMPORTED_MODULE_13__["getIdentifierValue"])(itemModelDefinition, record);
+            items.set(idOrPk, record);
           }); // remove deleted items from the final result set
 
-          deletedItemIds.forEach(function (id) {
-            return items["delete"](id);
+          deletedItemIds.forEach(function (idOrPk) {
+            return items["delete"](idOrPk);
           });
           return {
             items: Array.from(items.values()),
@@ -84417,9 +84464,10 @@ function () {
 
 
   AsyncStorageAdapter.prototype.getIndexKeys = function (namespaceName, modelName) {
-    var _a, _b;
+    var _a;
 
-    var keyPath = (_b = (_a = this.schema.namespaces[namespaceName]) === null || _a === void 0 ? void 0 : _a.keys[modelName]) === null || _b === void 0 ? void 0 : _b.primaryKey;
+    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;
@@ -84711,7 +84759,7 @@ function () {
     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, key, connectionRecord, e_3_1, recordItem, key, 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;
 
@@ -84737,7 +84785,7 @@ 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;
@@ -84750,9 +84798,9 @@ function () {
           case 3:
             if (!(relations_1_1 = _e.sent(), !relations_1_1.done)) return [3
             /*break*/
-            , 33];
+            , 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;
@@ -84766,20 +84814,20 @@ function () {
               case 'BELONGS_TO':
                 return [3
                 /*break*/
-                , 17];
+                , 19];
 
               case 'HAS_MANY':
                 return [3
                 /*break*/
-                , 30];
+                , 34];
             }
 
             return [3
             /*break*/
-            , 31];
+            , 35];
 
           case 4:
-            _e.trys.push([4, 10, 11, 16]);
+            _e.trys.push([4, 12, 13, 18]);
 
             records_1 = __asyncValues(records);
             _e.label = 5;
@@ -84792,225 +84840,290 @@ function () {
           case 6:
             if (!(records_1_1 = _e.sent(), !records_1_1.done)) return [3
             /*break*/
-            , 9];
+            , 11];
             recordItem = records_1_1.value;
+            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);
+            return [3
+            /*break*/
+            , 10];
+
+          case 8:
             getByfield = recordItem[targetName] ? targetName : fieldName;
             if (!recordItem[getByfield]) return [3
             /*break*/
-            , 9];
+            , 11];
             key = recordItem[getByfield];
             return [4
             /*yield*/
             , this.db.get(key, storeName)];
 
-          case 7:
+          case 9:
             connectionRecord = _e.sent();
             recordItem[fieldName] = connectionRecord && this.modelInstanceCreator(modelConstructor_1, connectionRecord);
-            _e.label = 8;
+            _e.label = 10;
 
-          case 8:
+          case 10:
             return [3
             /*break*/
             , 5];
 
-          case 9:
+          case 11:
             return [3
             /*break*/
-            , 16];
+            , 18];
 
-          case 10:
+          case 12:
             e_3_1 = _e.sent();
             e_3 = {
               error: e_3_1
             };
             return [3
             /*break*/
-            , 16];
+            , 18];
 
-          case 11:
-            _e.trys.push([11,, 14, 15]);
+          case 13:
+            _e.trys.push([13,, 16, 17]);
 
             if (!(records_1_1 && !records_1_1.done && (_b = records_1["return"]))) return [3
             /*break*/
-            , 13];
+            , 15];
             return [4
             /*yield*/
             , _b.call(records_1)];
 
-          case 12:
+          case 14:
             _e.sent();
 
-            _e.label = 13;
+            _e.label = 15;
 
-          case 13:
+          case 15:
             return [3
             /*break*/
-            , 15];
+            , 17];
 
-          case 14:
+          case 16:
             if (e_3) throw e_3.error;
             return [7
             /*endfinally*/
             ];
 
-          case 15:
+          case 17:
             return [7
             /*endfinally*/
             ];
 
-          case 16:
+          case 18:
             return [3
             /*break*/
-            , 32];
+            , 36];
 
-          case 17:
-            _e.trys.push([17, 23, 24, 29]);
+          case 19:
+            _e.trys.push([19, 27, 28, 33]);
 
             records_2 = __asyncValues(records);
-            _e.label = 18;
+            _e.label = 20;
 
-          case 18:
+          case 20:
             return [4
             /*yield*/
             , records_2.next()];
 
-          case 19:
+          case 21:
             if (!(records_2_1 = _e.sent(), !records_2_1.done)) return [3
             /*break*/
-            , 22];
+            , 26];
             recordItem = records_2_1.value;
+            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);
+            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*/
-            , 21];
+            , 25];
             key = recordItem[targetName];
             return [4
             /*yield*/
             , this.db.get(key, storeName)];
 
-          case 20:
+          case 24:
             connectionRecord = _e.sent();
             recordItem[fieldName] = connectionRecord && this.modelInstanceCreator(modelConstructor_1, connectionRecord);
             delete recordItem[targetName];
-            _e.label = 21;
+            _e.label = 25;
 
-          case 21:
+          case 25:
             return [3
             /*break*/
-            , 18];
+            , 20];
 
-          case 22:
+          case 26:
             return [3
             /*break*/
-            , 29];
+            , 33];
 
-          case 23:
+          case 27:
             e_4_1 = _e.sent();
             e_4 = {
               error: e_4_1
             };
             return [3
             /*break*/
-            , 29];
+            , 33];
 
-          case 24:
-            _e.trys.push([24,, 27, 28]);
+          case 28:
+            _e.trys.push([28,, 31, 32]);
 
             if (!(records_2_1 && !records_2_1.done && (_c = records_2["return"]))) return [3
             /*break*/
-            , 26];
+            , 30];
             return [4
             /*yield*/
             , _c.call(records_2)];
 
-          case 25:
+          case 29:
             _e.sent();
 
-            _e.label = 26;
+            _e.label = 30;
 
-          case 26:
+          case 30:
             return [3
             /*break*/
-            , 28];
+            , 32];
 
-          case 27:
+          case 31:
             if (e_4) throw e_4.error;
             return [7
             /*endfinally*/
             ];
 
-          case 28:
+          case 32:
             return [7
             /*endfinally*/
             ];
 
-          case 29:
+          case 33:
             return [3
             /*break*/
-            , 32];
+            , 36];
 
-          case 30:
+          case 34:
             // TODO: Lazy loading
             return [3
             /*break*/
-            , 32];
+            , 36];
 
-          case 31:
+          case 35:
             Object(_util__WEBPACK_IMPORTED_MODULE_4__["exhaustiveCheck"])(relationType);
             return [3
             /*break*/
-            , 32];
+            , 36];
 
-          case 32:
+          case 36:
             return [3
             /*break*/
             , 2];
 
-          case 33:
+          case 37:
             return [3
             /*break*/
-            , 40];
+            , 44];
 
-          case 34:
+          case 38:
             e_2_1 = _e.sent();
             e_2 = {
               error: e_2_1
             };
             return [3
             /*break*/
-            , 40];
+            , 44];
 
-          case 35:
-            _e.trys.push([35,, 38, 39]);
+          case 39:
+            _e.trys.push([39,, 42, 43]);
 
             if (!(relations_1_1 && !relations_1_1.done && (_a = relations_1["return"]))) return [3
             /*break*/
-            , 37];
+            , 41];
             return [4
             /*yield*/
             , _a.call(relations_1)];
 
-          case 36:
+          case 40:
             _e.sent();
 
-            _e.label = 37;
+            _e.label = 41;
 
-          case 37:
+          case 41:
             return [3
             /*break*/
-            , 39];
+            , 43];
 
-          case 38:
+          case 42:
             if (e_2) throw e_2.error;
             return [7
             /*endfinally*/
             ];
 
-          case 39:
+          case 43:
             return [7
             /*endfinally*/
             ];
 
-          case 40:
+          case 44:
             return [2
             /*return*/
             , records.map(function (record) {
@@ -85602,14 +85715,14 @@ function () {
     var e_8, _a, e_9, _b, e_10, _c;
 
     return __awaiter(this, void 0, void 0, function () {
-      var rel, relationType, modelName, targetName, targetNames, associatedWith, storeName, index, _d, model, hasOneIndex, hasOneCustomField, keyValuesPath, value, allRecords, recordToDelete, e_9_1, model, keyValuesPath, allRecords, childrenArray, e_10_1, e_8_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;
@@ -85622,7 +85735,7 @@ function () {
           case 2:
             if (!(relations_2_1 = _e.sent(), !relations_2_1.done)) return [3
             /*break*/
-            , 34];
+            , 37];
             rel = relations_2_1.value;
             relationType = rel.relationType, modelName = rel.modelName, targetName = rel.targetName, targetNames = rel.targetNames, associatedWith = rel.associatedWith;
             storeName = this.getStorename(nameSpace, modelName);
@@ -85641,20 +85754,20 @@ function () {
               case 'HAS_MANY':
                 return [3
                 /*break*/
-                , 17];
+                , 20];
 
               case 'BELONGS_TO':
                 return [3
                 /*break*/
-                , 31];
+                , 34];
             }
 
             return [3
             /*break*/
-            , 32];
+            , 35];
 
           case 3:
-            _e.trys.push([3, 10, 11, 16]);
+            _e.trys.push([3, 13, 14, 19]);
 
             models_1 = __asyncValues(models);
             _e.label = 4;
@@ -85667,24 +85780,55 @@ function () {
           case 5:
             if (!(models_1_1 = _e.sent(), !models_1_1.done)) return [3
             /*break*/
-            , 9];
+            , 12];
             model = models_1_1.value;
-            hasOneIndex = index || associatedWith;
-            hasOneCustomField = targetName in model;
+            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);
-            value = hasOneCustomField ? model[targetName] : keyValuesPath;
-            if (!value) return [3
+
+            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*/
-            , 9];
+            , 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)];
@@ -85692,216 +85836,247 @@ function () {
           case 7:
             _e.sent();
 
-            _e.label = 8;
+            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.sent();
+
+            _e.label = 11;
+
+          case 11:
             return [3
             /*break*/
             , 4];
 
-          case 9:
+          case 12:
             return [3
             /*break*/
-            , 16];
+            , 19];
 
-          case 10:
+          case 13:
             e_9_1 = _e.sent();
             e_9 = {
               error: e_9_1
             };
             return [3
             /*break*/
-            , 16];
+            , 19];
 
-          case 11:
-            _e.trys.push([11,, 14, 15]);
+          case 14:
+            _e.trys.push([14,, 17, 18]);
 
             if (!(models_1_1 && !models_1_1.done && (_b = models_1["return"]))) return [3
             /*break*/
-            , 13];
+            , 16];
             return [4
             /*yield*/
             , _b.call(models_1)];
 
-          case 12:
+          case 15:
             _e.sent();
 
-            _e.label = 13;
+            _e.label = 16;
 
-          case 13:
+          case 16:
             return [3
             /*break*/
-            , 15];
+            , 18];
 
-          case 14:
+          case 17:
             if (e_9) throw e_9.error;
             return [7
             /*endfinally*/
             ];
 
-          case 15:
+          case 18:
             return [7
             /*endfinally*/
             ];
 
-          case 16:
+          case 19:
             return [3
             /*break*/
-            , 33];
+            , 36];
 
-          case 17:
-            _e.trys.push([17, 24, 25, 30]);
+          case 20:
+            _e.trys.push([20, 27, 28, 33]);
 
             models_2 = __asyncValues(models);
-            _e.label = 18;
+            _e.label = 21;
 
-          case 18:
+          case 21:
             return [4
             /*yield*/
             , models_2.next()];
 
-          case 19:
+          case 22:
             if (!(models_2_1 = _e.sent(), !models_2_1.done)) return [3
             /*break*/
-            , 23];
+            , 26];
             model = models_2_1.value;
-            keyValuesPath = this.getIndexKeyValuesPath(model);
+            keyValues = this.getIndexKeyValues(model);
             return [4
             /*yield*/
             , this.db.getAll(storeName)];
 
-          case 20:
+          case 23:
             allRecords = _e.sent();
+            indices = index.split('-');
             childrenArray = allRecords.filter(function (childItem) {
-              return childItem[index] === keyValuesPath;
+              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:
+          case 24:
             _e.sent();
 
-            _e.label = 22;
+            _e.label = 25;
 
-          case 22:
+          case 25:
             return [3
             /*break*/
-            , 18];
+            , 21];
 
-          case 23:
+          case 26:
             return [3
             /*break*/
-            , 30];
+            , 33];
 
-          case 24:
+          case 27:
             e_10_1 = _e.sent();
             e_10 = {
               error: e_10_1
             };
             return [3
             /*break*/
-            , 30];
+            , 33];
 
-          case 25:
-            _e.trys.push([25,, 28, 29]);
+          case 28:
+            _e.trys.push([28,, 31, 32]);
 
             if (!(models_2_1 && !models_2_1.done && (_c = models_2["return"]))) return [3
             /*break*/
-            , 27];
+            , 30];
             return [4
             /*yield*/
             , _c.call(models_2)];
 
-          case 26:
+          case 29:
             _e.sent();
 
-            _e.label = 27;
+            _e.label = 30;
 
-          case 27:
+          case 30:
             return [3
             /*break*/
-            , 29];
+            , 32];
 
-          case 28:
+          case 31:
             if (e_10) throw e_10.error;
             return [7
             /*endfinally*/
             ];
 
-          case 29:
+          case 32:
             return [7
             /*endfinally*/
             ];
 
-          case 30:
+          case 33:
             return [3
             /*break*/
-            , 33];
+            , 36];
 
-          case 31:
+          case 34:
             // Intentionally blank
             return [3
             /*break*/
-            , 33];
+            , 36];
 
-          case 32:
+          case 35:
             Object(_util__WEBPACK_IMPORTED_MODULE_4__["exhaustiveCheck"])(relationType);
             return [3
             /*break*/
-            , 33];
+            , 36];
 
-          case 33:
+          case 36:
             return [3
             /*break*/
             , 1];
 
-          case 34:
+          case 37:
             return [3
             /*break*/
-            , 41];
+            , 44];
 
-          case 35:
+          case 38:
             e_8_1 = _e.sent();
             e_8 = {
               error: e_8_1
             };
             return [3
             /*break*/
-            , 41];
+            , 44];
 
-          case 36:
-            _e.trys.push([36,, 39, 40]);
+          case 39:
+            _e.trys.push([39,, 42, 43]);
 
             if (!(relations_2_1 && !relations_2_1.done && (_a = relations_2["return"]))) return [3
             /*break*/
-            , 38];
+            , 41];
             return [4
             /*yield*/
             , _a.call(relations_2)];
 
-          case 37:
+          case 40:
             _e.sent();
 
-            _e.label = 38;
+            _e.label = 41;
 
-          case 38:
+          case 41:
             return [3
             /*break*/
-            , 40];
+            , 43];
 
-          case 39:
+          case 42:
             if (e_8) throw e_8.error;
             return [7
             /*endfinally*/
             ];
 
-          case 40:
+          case 43:
             return [7
             /*endfinally*/
             ];
 
-          case 41:
+          case 44:
             deleteQueue.push({
               storeName: this.getStorename(nameSpace, srcModel),
               items: models.map(function (record) {
@@ -86391,11 +86566,12 @@ function () {
 
   AsyncStorageDatabase.prototype.save = function (item, storeName, keys, keyValuesPath) {
     return __awaiter(this, void 0, void 0, function () {
-      var ulid, itemKey;
+      var idxName, ulid, itemKey;
       return __generator(this, function (_a) {
         switch (_a.label) {
           case 0:
-            ulid = this.getCollectionIndex(storeName).get(keys[0]) || this.getMonotonicFactory(storeName)();
+            idxName = Object(_util__WEBPACK_IMPORTED_MODULE_1__["indexNameFromKeys"])(keys);
+            ulid = this.getCollectionIndex(storeName).get(idxName) || this.getMonotonicFactory(storeName)();
             itemKey = this.getKeyForItem(storeName, keyValuesPath, ulid); // Set key in collection index
 
             this.getCollectionIndex(storeName).set(keyValuesPath, ulid); // Save item in db
@@ -97092,14 +97268,16 @@ var LimitTimerRaceResolvedValues;
 /*!*************************!*\
   !*** ./lib-esm/util.js ***!
   \*************************/
-/*! exports provided: extractKeyIfExists, extractPrimaryKeyFieldNames, extractPrimaryKeyValues, isIdManaged, isIdOptionallyManaged, NAMESPACES, USER, SYNC, STORAGE, DATASTORE, USER_AGENT_SUFFIX_DATASTORE, exhaustiveCheck, isNullOrUndefined, validatePredicate, validatePredicateField, isModelConstructor, registerNonModelClass, isNonModelConstructor, processCompositeKeys, establishRelationAndKeys, traverseModel, getIndex, getIndexFromAssociation, isPrivateMode, monotonicUlidFactory, getNow, sortCompareFunction, valuesEqual, isAWSDate, isAWSTime, isAWSDateTime, isAWSTimestamp, isAWSEmail, isAWSJSON, isAWSURL, isAWSPhone, isAWSIPAddress, DeferredPromise, DeferredCallbackResolver, mergePatches, extractTargetNamesFromSrc, indexNameFromKeys */
+/*! exports provided: errorMessages, extractKeyIfExists, extractPrimaryKeyFieldNames, extractPrimaryKeyValues, extractPrimaryKeysAndValues, isIdManaged, isIdOptionallyManaged, NAMESPACES, USER, SYNC, STORAGE, DATASTORE, USER_AGENT_SUFFIX_DATASTORE, exhaustiveCheck, isNullOrUndefined, validatePredicate, validatePredicateField, isModelConstructor, registerNonModelClass, isNonModelConstructor, processCompositeKeys, establishRelationAndKeys, traverseModel, getIndex, getIndexFromAssociation, isPrivateMode, monotonicUlidFactory, getNow, sortCompareFunction, valuesEqual, isAWSDate, isAWSTime, isAWSDateTime, isAWSTimestamp, isAWSEmail, isAWSJSON, isAWSURL, isAWSPhone, isAWSIPAddress, DeferredPromise, DeferredCallbackResolver, mergePatches, extractTargetNamesFromSrc, indexNameFromKeys */
 /***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
 __webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "errorMessages", function() { return errorMessages; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extractKeyIfExists", function() { return extractKeyIfExists; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extractPrimaryKeyFieldNames", function() { return extractPrimaryKeyFieldNames; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extractPrimaryKeyValues", function() { return extractPrimaryKeyValues; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extractPrimaryKeysAndValues", function() { return extractPrimaryKeysAndValues; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isIdManaged", function() { return isIdManaged; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "isIdOptionallyManaged", function() { return isIdOptionallyManaged; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "NAMESPACES", function() { return NAMESPACES; });
@@ -97359,6 +97537,9 @@ var __values = undefined && undefined.__values || function (o) {
 
 
 var ID = 'id';
+var errorMessages = {
+  idEmptyString: 'An index field cannot contain an empty string value'
+};
 function extractKeyIfExists(modelDefinition) {
   var _c;
 
@@ -97378,6 +97559,13 @@ function extractPrimaryKeyValues(model, keyFields) {
   return keyFields.map(function (key) {
     return model[key];
   });
+}
+function extractPrimaryKeysAndValues(model, keyFields) {
+  var primaryKeysAndValues = {};
+  keyFields.forEach(function (key) {
+    return primaryKeysAndValues[key] = model[key];
+  });
+  return primaryKeysAndValues;
 } // IdentifierFields<ManagedIdentifier>
 // Default behavior without explicit @primaryKey defined