@aws-amplify/datastore 3.7.4-custom-pk.79 → 3.7.4-custom-pk.87

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);
@@ -82412,7 +82430,6 @@ var createModelClass = function createModelClass(modelDefinition) {
       var model = Object(immer__WEBPACK_IMPORTED_MODULE_4__["produce"])(source, function (draft) {
         fn(draft);
         var keyNames = Object(_util__WEBPACK_IMPORTED_MODULE_12__["extractPrimaryKeyFieldNames"])(modelDefinition); // Keys are immutable
-        // CPK TODO: Previous comment from Ivan:
         // @ts-ignore TODO: fix type
 
         keyNames.forEach(function (key) {
@@ -83205,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:
@@ -83213,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();
@@ -83328,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.
@@ -83342,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;
@@ -83360,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;
@@ -83417,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()),
@@ -84418,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;
@@ -84712,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;
 
@@ -84738,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;
@@ -84751,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;
@@ -84767,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;
@@ -84793,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) {
@@ -85603,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;
@@ -85623,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);
@@ -85642,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;
@@ -85668,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)];
@@ -85693,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) {
@@ -86392,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
@@ -87463,9 +87638,10 @@ function () {
   };
 
   IndexedDBAdapter.prototype.getIndexKeyPath = 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;
@@ -89108,7 +89284,7 @@ function () {
     var e_10, _a, e_11, _b, e_12, _c;
 
     return __awaiter(this, void 0, void 0, function () {
-      var rel, relationType, fieldName, modelName, targetName, targetNames, storeName, index, _d, model, hasOneIndex, hasConnectedModelFields, keyValues, values, recordToDelete, hasOneIndex_1, hasOneCustomField, keyValues, value, recordToDelete, e_11_1, model, keyValues, hasManyIndex, childrenArray, e_12_1, e_10_1;
+      var rel, relationType, fieldName, modelName, targetName, targetNames, storeName, index, _d, model, hasOneIndex, hasConnectedModelFields, keyValues, values, recordToDelete, hasOneIndex_1, hasOneCustomField, keyValues, value, recordToDelete, e_11_1, model, keyValues, childrenArray, e_12_1, e_10_1;
 
       var _this = this;
 
@@ -89219,13 +89395,7 @@ function () {
             hasOneIndex_1 = index || 'byPk';
             hasOneCustomField = targetName in model;
             keyValues = this.getIndexKeyValues(model);
-            value = hasOneCustomField ? model[targetName] : keyValues[0];
-
-            if (hasOneIndex_1 === 'byPk') {
-              // byPk requires an array keyValue
-              value = [value];
-            }
-
+            value = hasOneCustomField ? [model[targetName]] : keyValues;
             if (!value) return [3
             /*break*/
             , 12];
@@ -89316,20 +89486,17 @@ function () {
             , 26];
             model = models_2_1.value;
             keyValues = this.getIndexKeyValues(model);
-            hasManyIndex = index || 'byPk';
             return [4
             /*yield*/
-            , this.db.transaction(storeName, 'readwrite').objectStore(storeName).index(hasManyIndex).getAll(keyValues[0])];
+            , this.db.transaction(storeName, 'readwrite').objectStore(storeName).index(index).getAll(keyValues)];
 
           case 23:
-            childrenArray = _e.sent(); // .getAll(keyValues); // TODO
-
+            childrenArray = _e.sent();
             return [4
             /*yield*/
             , this.deleteTraverse(this.schema.namespaces[nameSpace].relationships[modelName].relationTypes, childrenArray, modelName, nameSpace, deleteQueue)];
 
           case 24:
-            // .getAll(keyValues); // TODO
             _e.sent();
 
             _e.label = 25;
@@ -89660,18 +89827,19 @@ function () {
 
   IndexedDBAdapter.prototype.createObjectStoreForModel = function (db, namespaceName, storeName, modelName) {
     return __awaiter(this, void 0, void 0, function () {
-      var store, indexes, keyPath;
+      var store, indexes;
       return __generator(this, function (_a) {
         store = db.createObjectStore(storeName, {
           autoIncrement: true
         });
         indexes = this.schema.namespaces[namespaceName].relationships[modelName].indexes;
-        indexes.forEach(function (index) {
-          return store.createIndex(index, index);
-        });
-        keyPath = this.getIndexKeyPath(namespaceName, modelName);
-        store.createIndex('byPk', keyPath, {
-          unique: true
+        indexes.forEach(function (_a) {
+          var _b = __read(_a, 3),
+              idxName = _b[0],
+              keyPath = _b[1],
+              options = _b[2];
+
+          store.createIndex(idxName, keyPath, options);
         });
         return [2
         /*return*/
@@ -96161,11 +96329,17 @@ function getConnectionFields(modelDefinition, namespace) {
             var _b = __read(Object(_util__WEBPACK_IMPORTED_MODULE_4__["establishRelationAndKeys"])(namespace), 1),
                 relations = _b[0];
 
-            var connectedModelName = modelDefinition.fields[name].type['model']; // keyFields are fields of the connected model
+            var connectedModelName = modelDefinition.fields[name].type['model'];
+            var byPkIndex = relations[connectedModelName].indexes.find(function (_a) {
+              var _b = __read(_a, 1),
+                  name = _b[0];
 
-            var keyFields = relations[connectedModelName].indexes; // We rely on `_deleted` when we process the sync query (e.g. in batchSave in the adapters)
+              return name === 'byPk';
+            });
+            var keyFields = byPkIndex && byPkIndex[1];
+            var keyFieldSelectionSet = keyFields === null || keyFields === void 0 ? void 0 : keyFields.join(' '); // We rely on `_deleted` when we process the sync query (e.g. in batchSave in the adapters)
 
-            result.push(name + " { " + keyFields + " _deleted }");
+            result.push(name + " { " + keyFieldSelectionSet + " _deleted }");
           } else {
             // backwards-compatability for schema generated prior to custom primary key support
             result.push(name + " { id _deleted }");
@@ -97094,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 */
+/*! 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; });
@@ -97140,6 +97316,7 @@ __webpack_require__.r(__webpack_exports__);
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "DeferredCallbackResolver", function() { return DeferredCallbackResolver; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mergePatches", function() { return mergePatches; });
 /* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "extractTargetNamesFromSrc", function() { return extractTargetNamesFromSrc; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "indexNameFromKeys", function() { return indexNameFromKeys; });
 /* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! buffer */ "../../node_modules/buffer/index.js");
 /* harmony import */ var buffer__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(buffer__WEBPACK_IMPORTED_MODULE_0__);
 /* harmony import */ var ulid__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ulid */ "../../node_modules/ulid/dist/index.esm.js");
@@ -97360,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;
 
@@ -97379,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
 
@@ -97616,7 +97803,7 @@ var establishRelationAndKeys = function establishRelationAndKeys(namespace) {
   var relationship = {};
   var keys = {};
   Object.keys(namespace.models).forEach(function (mKey) {
-    var e_1, _c, e_2, _d;
+    var e_1, _c;
 
     relationship[mKey] = {
       indexes: [],
@@ -97639,20 +97826,11 @@ var establishRelationAndKeys = function establishRelationAndKeys(namespace) {
         });
 
         if (connectionType === 'BELONGS_TO') {
-          // const targetNames: string[] = extractTargetNamesFromSrc(
-          // 	fieldAttribute.association
-          // );
-          // targetNames.forEach((targetName: string) => {
-          // 	relationship[mKey].indexes.push(targetName);
-          // });
-          if (fieldAttribute.association.targetName) {
-            // backwards-compatability for schema generated prior to custom primary key support
-            relationship[mKey].indexes.push(fieldAttribute.association['targetName']);
-          } else {
-            // iterate through fieldAttribute.association.targetNames, and push to relationship[mKey].indexes
-            fieldAttribute.association.targetNames.forEach(function (targetName) {
-              relationship[mKey].indexes.push(targetName);
-            });
+          var targetNames = extractTargetNamesFromSrc(fieldAttribute.association);
+
+          if (targetNames) {
+            var idxName = indexNameFromKeys(targetNames);
+            relationship[mKey].indexes.push([idxName, targetNames]);
           }
         }
       }
@@ -97661,41 +97839,37 @@ var establishRelationAndKeys = function establishRelationAndKeys(namespace) {
     if (model.attributes) {
       keys[mKey].compositeKeys = processCompositeKeys(model.attributes);
 
-      try {
-        for (var _e = __values(model.attributes), _f = _e.next(); !_f.done; _f = _e.next()) {
-          var attribute = _f.value;
+      var _loop_1 = function _loop_1(attribute) {
+        if (!Object(_types__WEBPACK_IMPORTED_MODULE_4__["isModelAttributeKey"])(attribute)) {
+          return "continue";
+        }
 
-          if (!Object(_types__WEBPACK_IMPORTED_MODULE_4__["isModelAttributeKey"])(attribute)) {
-            continue;
-          }
+        var fields = attribute.properties.fields;
 
-          if (Object(_types__WEBPACK_IMPORTED_MODULE_4__["isModelAttributePrimaryKey"])(attribute)) {
-            keys[mKey].primaryKey = attribute.properties.fields;
-          }
+        if (Object(_types__WEBPACK_IMPORTED_MODULE_4__["isModelAttributePrimaryKey"])(attribute)) {
+          keys[mKey].primaryKey = fields;
+          return "continue";
+        } // create indexes for all other keys
 
-          var fields = attribute.properties.fields;
 
-          try {
-            for (var fields_1 = (e_2 = void 0, __values(fields)), fields_1_1 = fields_1.next(); !fields_1_1.done; fields_1_1 = fields_1.next()) {
-              var field = fields_1_1.value; // only add index if it hasn't already been added
+        var idxName = indexNameFromKeys(fields);
+        var idxExists = relationship[mKey].indexes.find(function (_c) {
+          var _d = __read(_c, 1),
+              index = _d[0];
 
-              var exists = relationship[mKey].indexes.includes(field);
+          return index === idxName;
+        });
 
-              if (!exists) {
-                relationship[mKey].indexes.push(field);
-              }
-            }
-          } catch (e_2_1) {
-            e_2 = {
-              error: e_2_1
-            };
-          } finally {
-            try {
-              if (fields_1_1 && !fields_1_1.done && (_d = fields_1["return"])) _d.call(fields_1);
-            } finally {
-              if (e_2) throw e_2.error;
-            }
-          }
+        if (!idxExists) {
+          relationship[mKey].indexes.push([idxName, fields]);
+        }
+      };
+
+      try {
+        for (var _d = __values(model.attributes), _e = _d.next(); !_e.done; _e = _d.next()) {
+          var attribute = _e.value;
+
+          _loop_1(attribute);
         }
       } catch (e_1_1) {
         e_1 = {
@@ -97703,16 +97877,22 @@ var establishRelationAndKeys = function establishRelationAndKeys(namespace) {
         };
       } finally {
         try {
-          if (_f && !_f.done && (_c = _e["return"])) _c.call(_e);
+          if (_e && !_e.done && (_c = _d["return"])) _c.call(_d);
         } finally {
           if (e_1) throw e_1.error;
         }
       }
+    } // set 'id' as the PK for models without a custom PK explicitly defined
 
-      if (!keys[mKey].primaryKey) {
-        keys[mKey].primaryKey = [ID];
-      }
-    }
+
+    if (!keys[mKey].primaryKey) {
+      keys[mKey].primaryKey = [ID];
+    } // create primary index
+
+
+    relationship[mKey].indexes.push(['byPk', keys[mKey].primaryKey, {
+      unique: true
+    }]);
   });
   return [relationship, keys];
 };
@@ -97852,10 +98032,21 @@ var getIndex = function getIndex(rel, src) {
   return index;
 };
 var getIndexFromAssociation = function getIndexFromAssociation(indexes, src) {
-  var index = indexes.find(function (idx) {
-    return idx === src;
+  var indexName;
+
+  if (Array.isArray(src)) {
+    indexName = indexNameFromKeys(src);
+  } else {
+    indexName = src;
+  }
+
+  var associationIndex = indexes.find(function (_c) {
+    var _d = __read(_c, 1),
+        idxName = _d[0];
+
+    return idxName === indexName;
   });
-  return index;
+  return associationIndex && associationIndex[0];
 };
 var privateModeCheckResult;
 var isPrivateMode = function isPrivateMode() {
@@ -97953,7 +98144,7 @@ function getNow() {
 }
 function sortCompareFunction(sortPredicates) {
   return function compareFunction(a, b) {
-    var e_3, _c;
+    var e_2, _c;
 
     try {
       // enable multi-field sort by iterating over predicates until
@@ -97973,15 +98164,15 @@ function sortCompareFunction(sortPredicates) {
           return 1 * sortMultiplier;
         }
       }
-    } catch (e_3_1) {
-      e_3 = {
-        error: e_3_1
+    } catch (e_2_1) {
+      e_2 = {
+        error: e_2_1
       };
     } finally {
       try {
         if (sortPredicates_1_1 && !sortPredicates_1_1.done && (_c = sortPredicates_1["return"])) _c.call(sortPredicates_1);
       } finally {
-        if (e_3) throw e_3.error;
+        if (e_2) throw e_2.error;
       }
     }
 
@@ -97994,7 +98185,7 @@ function sortCompareFunction(sortPredicates) {
 // to normalize for GQL response values for undefined fields
 
 function valuesEqual(valA, valB, nullish) {
-  var e_4, _c;
+  var e_3, _c;
 
   if (nullish === void 0) {
     nullish = false;
@@ -98058,15 +98249,15 @@ function valuesEqual(valA, valB, nullish) {
         return false;
       }
     }
-  } catch (e_4_1) {
-    e_4 = {
-      error: e_4_1
+  } catch (e_3_1) {
+    e_3 = {
+      error: e_3_1
     };
   } finally {
     try {
       if (keys_1_1 && !keys_1_1.done && (_c = keys_1["return"])) _c.call(keys_1);
     } finally {
-      if (e_4) throw e_4.error;
+      if (e_3) throw e_3.error;
     }
   }
 
@@ -98262,6 +98453,17 @@ function extractTargetNamesFromSrc(src) {
   } else {
     return undefined;
   }
+} // Generates snake-cased index name from an aray of key field names
+// E.g. for keys `[id, title]` => 'id-title'
+
+function indexNameFromKeys(keys) {
+  return keys.reduce(function (prev, cur, idx) {
+    if (idx === 0) {
+      return cur;
+    }
+
+    return prev + "-" + cur;
+  }, '');
 }
 
 /***/ }),