@aws-amplify/datastore 3.12.6-next.20 → 3.12.6-next.36

package/lib-esm/util.js

@@ -5,6 +5,27 @@ import { v4 as uuid } from 'uuid';
 import { produce, applyPatches } from 'immer';
 import { isPredicateGroup, isPredicateObj, SortDirection, isModelAttributeKey, isModelAttributePrimaryKey, isModelAttributeCompositeKey, LimitTimerRaceResolvedValues, } from './types';
 import { WordArray } from 'amazon-cognito-identity-js';
+export var ID = 'id';
+/**
+ * Used by the Async Storage Adapter to concatenate key values
+ * for a record. For instance, if a model has the following keys:
+ * `customId: ID! @primaryKey(sortKeyFields: ["createdAt"])`,
+ * we concatenate the `customId` and `createdAt` as:
+ * `12-234-5#2022-09-28T00:00:00.000Z`
+ */
+export var DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR = '#';
+/**
+ * Used for generating spinal-cased index name from an array of
+ * key field names.
+ * E.g. for keys `[id, title]` => 'id-title'
+ */
+export var IDENTIFIER_KEY_SEPARATOR = '-';
+export var errorMessages = {
+    idEmptyString: 'An index field cannot contain an empty string value',
+    queryByPkWithCompositeKeyPresent: 'Models with composite primary keys cannot be queried by a single key value. Use object literal syntax for composite keys instead: https://docs.amplify.aws/lib/datastore/advanced-workflows/q/platform/js/#querying-records-with-custom-primary-keys',
+    deleteByPkWithCompositeKeyPresent: 'Models with composite primary keys cannot be deleted by a single key value, unless using a predicate. Use object literal syntax for composite keys instead: https://docs.amplify.aws/lib/datastore/advanced-workflows/q/platform/js/#querying-records-with-custom-primary-keys',
+    observeWithObjectLiteral: 'Object literal syntax cannot be used with observe. Use a predicate instead: https://docs.amplify.aws/lib/datastore/data-access/q/platform/js/#predicates',
+};
 export var NAMESPACES;
 (function (NAMESPACES) {
     NAMESPACES["DATASTORE"] = "datastore";
@@ -102,148 +123,6 @@ export function registerNonModelClass(clazz) {
 export var isNonModelConstructor = function (obj) {
     return nonModelClasses.has(obj);
 };
-/*
-  When we have GSI(s) with composite sort keys defined on a model
-    There are some very particular rules regarding which fields must be included in the update mutation input
-    The field selection becomes more complex as the number of GSIs with composite sort keys grows
-
-    To summarize: any time we update a field that is part of the composite sort key of a GSI, we must include:
-     1. all of the other fields in that composite sort key
-     2. all of the fields from any other composite sort key that intersect with the fields from 1.
-
-     E.g.,
-     Model @model
-        @key(name: 'key1' fields: ['hk', 'a', 'b', 'c'])
-        @key(name: 'key2' fields: ['hk', 'a', 'b', 'd'])
-        @key(name: 'key3' fields: ['hk', 'x', 'y', 'z'])
-
-    Model.a is updated => include ['a', 'b', 'c', 'd']
-    Model.c is updated => include ['a', 'b', 'c', 'd']
-    Model.d is updated => include ['a', 'b', 'c', 'd']
-    Model.x is updated => include ['x', 'y', 'z']
-
-    This function accepts a model's attributes and returns grouped sets of composite key fields
-    Using our example Model above, the function will return:
-    [
-        Set('a', 'b', 'c', 'd'),
-        Set('x', 'y', 'z'),
-    ]
-
-    This gives us the opportunity to correctly include the required fields for composite keys
-    When crafting the mutation input in Storage.getUpdateMutationInput
-
-    See 'processCompositeKeys' test in util.test.ts for more examples
-*/
-export var processCompositeKeys = function (attributes) {
-    var extractCompositeSortKey = function (_c) {
-        var 
-        // ignore the HK (fields[0]) we only need to include the composite sort key fields[1...n]
-        _d = __read(_c.properties.fields), sortKeyFields = _d.slice(1);
-        return sortKeyFields;
-    };
-    var compositeKeyFields = attributes
-        .filter(isModelAttributeCompositeKey)
-        .map(extractCompositeSortKey);
-    /*
-        if 2 sets of fields have any intersecting fields => combine them into 1 union set
-        e.g., ['a', 'b', 'c'] and ['a', 'b', 'd'] => ['a', 'b', 'c', 'd']
-    */
-    var combineIntersecting = function (fields) {
-        return fields.reduce(function (combined, sortKeyFields) {
-            var sortKeyFieldsSet = new Set(sortKeyFields);
-            if (combined.length === 0) {
-                combined.push(sortKeyFieldsSet);
-                return combined;
-            }
-            // does the current set share values with another set we've already added to `combined`?
-            var intersectingSetIdx = combined.findIndex(function (existingSet) {
-                return __spread(existingSet).some(function (f) { return sortKeyFieldsSet.has(f); });
-            });
-            if (intersectingSetIdx > -1) {
-                var union = new Set(__spread(combined[intersectingSetIdx], sortKeyFieldsSet));
-                // combine the current set with the intersecting set we found above
-                combined[intersectingSetIdx] = union;
-            }
-            else {
-                // none of the sets in `combined` have intersecting values with the current set
-                combined.push(sortKeyFieldsSet);
-            }
-            return combined;
-        }, []);
-    };
-    var initial = combineIntersecting(compositeKeyFields);
-    // a single pass pay not be enough to correctly combine all the fields
-    // call the function once more to get a final merged list of sets
-    var combined = combineIntersecting(initial);
-    return combined;
-};
-export var establishRelationAndKeys = function (namespace) {
-    var relationship = {};
-    var keys = {};
-    Object.keys(namespace.models).forEach(function (mKey) {
-        var e_1, _c, e_2, _d;
-        relationship[mKey] = { indexes: [], relationTypes: [] };
-        keys[mKey] = {};
-        var model = namespace.models[mKey];
-        Object.keys(model.fields).forEach(function (attr) {
-            var fieldAttribute = model.fields[attr];
-            if (typeof fieldAttribute.type === 'object' &&
-                'model' in fieldAttribute.type) {
-                var connectionType = fieldAttribute.association.connectionType;
-                relationship[mKey].relationTypes.push({
-                    fieldName: fieldAttribute.name,
-                    modelName: fieldAttribute.type.model,
-                    relationType: connectionType,
-                    targetName: fieldAttribute.association['targetName'],
-                    associatedWith: fieldAttribute.association['associatedWith'],
-                });
-                if (connectionType === 'BELONGS_TO') {
-                    relationship[mKey].indexes.push(fieldAttribute.association['targetName']);
-                }
-            }
-        });
-        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;
-                    if (!isModelAttributeKey(attribute)) {
-                        continue;
-                    }
-                    if (isModelAttributePrimaryKey(attribute)) {
-                        keys[mKey].primaryKey = attribute.properties.fields;
-                    }
-                    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 exists = relationship[mKey].indexes.includes(field);
-                            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; }
-                    }
-                }
-            }
-            catch (e_1_1) { e_1 = { error: e_1_1 }; }
-            finally {
-                try {
-                    if (_f && !_f.done && (_c = _e.return)) _c.call(_e);
-                }
-                finally { if (e_1) throw e_1.error; }
-            }
-        }
-    });
-    return [relationship, keys];
-};
 var topologicallySortedModels = new WeakMap();
 export var traverseModel = function (srcModelName, instance, namespace, modelInstanceCreator, getModelConstructorByModelName) {
     var relationships = namespace.relationships;
@@ -269,12 +148,26 @@ export var traverseModel = function (srcModelName, instance, namespace, modelIns
                             item: instance[rItem.fieldName],
                             instance: modelInstance,
                         });
-                        // targetName will be defined for Has One if feature flag
+                        var targetNames = extractTargetNamesFromSrc(rItem);
+                        // `targetName` will be defined for Has One if feature flag
                         // https://docs.amplify.aws/cli/reference/feature-flags/#useAppsyncModelgenPlugin
                         // is true (default as of 5/7/21)
                         // Making this conditional for backward-compatibility
-                        if (rItem.targetName) {
-                            draftInstance[rItem.targetName] = (draftInstance[rItem.fieldName]).id;
+                        if (targetNames) {
+                            targetNames.forEach(function (targetName, idx) {
+                                // Get the connected record
+                                var relatedRecordInProxy = (draftInstance[rItem.fieldName]);
+                                // Previously, we used the hardcoded 'id' as they key,
+                                // now we need the value of the key to get the PK (and SK)
+                                // values from the related record
+                                var primaryKey = namespace.keys[modelConstructor.name].primaryKey;
+                                var keyField = primaryKey && primaryKey[idx];
+                                // Get the value
+                                var relatedRecordInProxyPkValue = relatedRecordInProxy[keyField];
+                                // Set the targetName value
+                                draftInstance[targetName] = relatedRecordInProxyPkValue;
+                            });
+                            // Delete the instance from the proxy
                             delete draftInstance[rItem.fieldName];
                         }
                         else {
@@ -301,8 +194,25 @@ export var traverseModel = function (srcModelName, instance, namespace, modelIns
                         }
                     }
                     if (draftInstance[rItem.fieldName]) {
-                        draftInstance[rItem.targetName] = (draftInstance[rItem.fieldName]).id;
-                        delete draftInstance[rItem.fieldName];
+                        var targetNames = extractTargetNamesFromSrc(rItem);
+                        if (targetNames) {
+                            targetNames.forEach(function (targetName, idx) {
+                                // Get the connected record
+                                var relatedRecordInProxy = (draftInstance[rItem.fieldName]);
+                                // Previously, we used the hardcoded `id` for the key.
+                                // Now, we need the value of the key to get the PK (and SK)
+                                // values from the related record
+                                var primaryKey = namespace.keys[modelConstructor.name].primaryKey;
+                                // fall back to ID if
+                                var keyField = primaryKey && primaryKey[idx];
+                                // Get the value
+                                var relatedRecordInProxyPkValue = relatedRecordInProxy[keyField];
+                                // Set the targetName value
+                                draftInstance[targetName] = relatedRecordInProxyPkValue;
+                            });
+                            // Delete the instance from the proxy
+                            delete draftInstance[rItem.fieldName];
+                        }
                     }
                     break;
                 case 'HAS_MANY':
@@ -328,19 +238,6 @@ export var traverseModel = function (srcModelName, instance, namespace, modelIns
     });
     return result;
 };
-export var getIndex = function (rel, src) {
-    var index = '';
-    rel.some(function (relItem) {
-        if (relItem.modelName === src) {
-            index = relItem.targetName;
-        }
-    });
-    return index;
-};
-export var getIndexFromAssociation = function (indexes, src) {
-    var index = indexes.find(function (idx) { return idx === src; });
-    return index;
-};
 var privateModeCheckResult;
 export var isPrivateMode = function () {
     return new Promise(function (resolve) {
@@ -380,6 +277,95 @@ export var isPrivateMode = function () {
         db.onsuccess = isNotPrivate;
     });
 };
+var safariCompatabilityModeResult;
+/**
+ * Whether the browser's implementation of IndexedDB breaks on array lookups
+ * against composite indexes whose keypath contains a single column.
+ *
+ * E.g., Whether `store.createIndex(indexName, ['id'])` followed by
+ * `store.index(indexName).get([1])` will *ever* return records.
+ *
+ * In all known, modern Safari browsers as of Q4 2022, the query against an index like
+ * this will *always* return `undefined`. So, the index needs to be created as a scalar.
+ */
+export var isSafariCompatabilityMode = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var dbName_1, storeName_1, indexName_1, db_1, rwTx, rwStore, result, error_1;
+    return __generator(this, function (_c) {
+        switch (_c.label) {
+            case 0:
+                _c.trys.push([0, 6, , 7]);
+                dbName_1 = uuid();
+                storeName_1 = 'indexedDBFeatureProbeStore';
+                indexName_1 = 'idx';
+                if (indexedDB === null)
+                    return [2 /*return*/, false];
+                if (safariCompatabilityModeResult !== undefined) {
+                    return [2 /*return*/, safariCompatabilityModeResult];
+                }
+                return [4 /*yield*/, new Promise(function (resolve) {
+                        var dbOpenRequest = indexedDB.open(dbName_1);
+                        dbOpenRequest.onerror = function () { return resolve(false); };
+                        dbOpenRequest.onsuccess = function () {
+                            var db = dbOpenRequest.result;
+                            resolve(db);
+                        };
+                        dbOpenRequest.onupgradeneeded = function (event) {
+                            var _c;
+                            var db = (_c = event === null || event === void 0 ? void 0 : event.target) === null || _c === void 0 ? void 0 : _c.result;
+                            db.onerror = function () { return resolve(false); };
+                            var store = db.createObjectStore(storeName_1, {
+                                autoIncrement: true,
+                            });
+                            store.createIndex(indexName_1, ['id']);
+                        };
+                    })];
+            case 1:
+                db_1 = _c.sent();
+                if (!db_1) {
+                    throw new Error('Could not open probe DB');
+                }
+                rwTx = db_1.transaction(storeName_1, 'readwrite');
+                rwStore = rwTx.objectStore(storeName_1);
+                rwStore.add({
+                    id: 1,
+                });
+                rwTx.commit();
+                return [4 /*yield*/, new Promise(function (resolve) {
+                        var tx = db_1.transaction(storeName_1, 'readonly');
+                        var store = tx.objectStore(storeName_1);
+                        var index = store.index(indexName_1);
+                        var getRequest = index.get([1]);
+                        getRequest.onerror = function () { return resolve(false); };
+                        getRequest.onsuccess = function (event) {
+                            var _c;
+                            resolve((_c = event === null || event === void 0 ? void 0 : event.target) === null || _c === void 0 ? void 0 : _c.result);
+                        };
+                    })];
+            case 2:
+                result = _c.sent();
+                if (!(db_1 && typeof db_1.close === 'function')) return [3 /*break*/, 4];
+                return [4 /*yield*/, db_1.close()];
+            case 3:
+                _c.sent();
+                _c.label = 4;
+            case 4: return [4 /*yield*/, indexedDB.deleteDatabase(dbName_1)];
+            case 5:
+                _c.sent();
+                if (result === undefined) {
+                    safariCompatabilityModeResult = true;
+                }
+                else {
+                    safariCompatabilityModeResult = false;
+                }
+                return [3 /*break*/, 7];
+            case 6:
+                error_1 = _c.sent();
+                safariCompatabilityModeResult = false;
+                return [3 /*break*/, 7];
+            case 7: return [2 /*return*/, safariCompatabilityModeResult];
+        }
+    });
+}); };
 var randomBytes = function (nBytes) {
     return Buffer.from(new WordArray().random(nBytes).toString(), 'hex');
 };
@@ -414,7 +400,7 @@ export function getNow() {
 }
 export function sortCompareFunction(sortPredicates) {
     return function compareFunction(a, b) {
-        var e_3, _c;
+        var e_1, _c;
         try {
             // enable multi-field sort by iterating over predicates until
             // a comparison returns -1 or 1
@@ -431,12 +417,12 @@ export function sortCompareFunction(sortPredicates) {
                 }
             }
         }
-        catch (e_3_1) { e_3 = { error: e_3_1 }; }
+        catch (e_1_1) { e_1 = { error: e_1_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; }
+            finally { if (e_1) throw e_1.error; }
         }
         return 0;
     };
@@ -447,7 +433,7 @@ export function sortCompareFunction(sortPredicates) {
 // if nullish is true, treat undefined and null values as equal
 // to normalize for GQL response values for undefined fields
 export function valuesEqual(valA, valB, nullish) {
-    var e_4, _c;
+    var e_2, _c;
     if (nullish === void 0) { nullish = false; }
     var a = valA;
     var b = valB;
@@ -499,12 +485,12 @@ export function valuesEqual(valA, valB, nullish) {
             }
         }
     }
-    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+    catch (e_2_1) { e_2 = { error: e_2_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; }
+        finally { if (e_2) throw e_2.error; }
     }
     return true;
 }
@@ -650,4 +636,271 @@ export function mergePatches(originalSource, oldPatches, newPatches) {
     });
     return patches;
 }
+export var getStorename = function (namespace, modelName) {
+    var storeName = namespace + "_" + modelName;
+    return storeName;
+};
+//#region Key Utils
+/*
+  When we have GSI(s) with composite sort keys defined on a model
+    There are some very particular rules regarding which fields must be included in the update mutation input
+    The field selection becomes more complex as the number of GSIs with composite sort keys grows
+
+    To summarize: any time we update a field that is part of the composite sort key of a GSI, we must include:
+     1. all of the other fields in that composite sort key
+     2. all of the fields from any other composite sort key that intersect with the fields from 1.
+
+     E.g.,
+     Model @model
+        @key(name: 'key1' fields: ['hk', 'a', 'b', 'c'])
+        @key(name: 'key2' fields: ['hk', 'a', 'b', 'd'])
+        @key(name: 'key3' fields: ['hk', 'x', 'y', 'z'])
+
+    Model.a is updated => include ['a', 'b', 'c', 'd']
+    Model.c is updated => include ['a', 'b', 'c', 'd']
+    Model.d is updated => include ['a', 'b', 'c', 'd']
+    Model.x is updated => include ['x', 'y', 'z']
+
+    This function accepts a model's attributes and returns grouped sets of composite key fields
+    Using our example Model above, the function will return:
+    [
+        Set('a', 'b', 'c', 'd'),
+        Set('x', 'y', 'z'),
+    ]
+
+    This gives us the opportunity to correctly include the required fields for composite keys
+    When crafting the mutation input in Storage.getUpdateMutationInput
+
+    See 'processCompositeKeys' test in util.test.ts for more examples
+*/
+export var processCompositeKeys = function (attributes) {
+    var extractCompositeSortKey = function (_c) {
+        var 
+        // ignore the HK (fields[0]) we only need to include the composite sort key fields[1...n]
+        _d = __read(_c.properties.fields), sortKeyFields = _d.slice(1);
+        return sortKeyFields;
+    };
+    var compositeKeyFields = attributes
+        .filter(isModelAttributeCompositeKey)
+        .map(extractCompositeSortKey);
+    /*
+        if 2 sets of fields have any intersecting fields => combine them into 1 union set
+        e.g., ['a', 'b', 'c'] and ['a', 'b', 'd'] => ['a', 'b', 'c', 'd']
+    */
+    var combineIntersecting = function (fields) {
+        return fields.reduce(function (combined, sortKeyFields) {
+            var sortKeyFieldsSet = new Set(sortKeyFields);
+            if (combined.length === 0) {
+                combined.push(sortKeyFieldsSet);
+                return combined;
+            }
+            // does the current set share values with another set we've already added to `combined`?
+            var intersectingSetIdx = combined.findIndex(function (existingSet) {
+                return __spread(existingSet).some(function (f) { return sortKeyFieldsSet.has(f); });
+            });
+            if (intersectingSetIdx > -1) {
+                var union = new Set(__spread(combined[intersectingSetIdx], sortKeyFieldsSet));
+                // combine the current set with the intersecting set we found above
+                combined[intersectingSetIdx] = union;
+            }
+            else {
+                // none of the sets in `combined` have intersecting values with the current set
+                combined.push(sortKeyFieldsSet);
+            }
+            return combined;
+        }, []);
+    };
+    var initial = combineIntersecting(compositeKeyFields);
+    // a single pass pay not be enough to correctly combine all the fields
+    // call the function once more to get a final merged list of sets
+    var combined = combineIntersecting(initial);
+    return combined;
+};
+export var extractKeyIfExists = function (modelDefinition) {
+    var _c;
+    var keyAttribute = (_c = modelDefinition === null || modelDefinition === void 0 ? void 0 : modelDefinition.attributes) === null || _c === void 0 ? void 0 : _c.find(isModelAttributeKey);
+    return keyAttribute;
+};
+export var extractPrimaryKeyFieldNames = function (modelDefinition) {
+    var keyAttribute = extractKeyIfExists(modelDefinition);
+    if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
+        return keyAttribute.properties.fields;
+    }
+    return [ID];
+};
+export var extractPrimaryKeyValues = function (model, keyFields) {
+    return keyFields.map(function (key) { return model[key]; });
+};
+export var extractPrimaryKeysAndValues = function (model, keyFields) {
+    var primaryKeysAndValues = {};
+    keyFields.forEach(function (key) { return (primaryKeysAndValues[key] = model[key]); });
+    return primaryKeysAndValues;
+};
+// IdentifierFields<ManagedIdentifier>
+// Default behavior without explicit @primaryKey defined
+export var isIdManaged = function (modelDefinition) {
+    var keyAttribute = extractKeyIfExists(modelDefinition);
+    if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
+        return false;
+    }
+    return true;
+};
+// IdentifierFields<OptionallyManagedIdentifier>
+// @primaryKey with explicit `id` in the PK. Single key or composite
+export var isIdOptionallyManaged = function (modelDefinition) {
+    var keyAttribute = extractKeyIfExists(modelDefinition);
+    if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
+        return keyAttribute.properties.fields[0] === ID;
+    }
+    return false;
+};
+export var establishRelationAndKeys = function (namespace) {
+    var relationship = {};
+    var keys = {};
+    Object.keys(namespace.models).forEach(function (mKey) {
+        var e_3, _c;
+        relationship[mKey] = { indexes: [], relationTypes: [] };
+        keys[mKey] = {};
+        var model = namespace.models[mKey];
+        Object.keys(model.fields).forEach(function (attr) {
+            var fieldAttribute = model.fields[attr];
+            if (typeof fieldAttribute.type === 'object' &&
+                'model' in fieldAttribute.type) {
+                var connectionType = fieldAttribute.association.connectionType;
+                relationship[mKey].relationTypes.push({
+                    fieldName: fieldAttribute.name,
+                    modelName: fieldAttribute.type.model,
+                    relationType: connectionType,
+                    targetName: fieldAttribute.association['targetName'],
+                    targetNames: fieldAttribute.association['targetNames'],
+                    associatedWith: fieldAttribute.association['associatedWith'],
+                });
+                if (connectionType === 'BELONGS_TO') {
+                    var targetNames = extractTargetNamesFromSrc(fieldAttribute.association);
+                    if (targetNames) {
+                        var idxName = indexNameFromKeys(targetNames);
+                        relationship[mKey].indexes.push([idxName, targetNames]);
+                    }
+                }
+            }
+        });
+        if (model.attributes) {
+            keys[mKey].compositeKeys = processCompositeKeys(model.attributes);
+            var _loop_1 = function (attribute) {
+                if (!isModelAttributeKey(attribute)) {
+                    return "continue";
+                }
+                var fields = attribute.properties.fields;
+                if (isModelAttributePrimaryKey(attribute)) {
+                    keys[mKey].primaryKey = fields;
+                    return "continue";
+                }
+                // create indexes for all other keys
+                var idxName = indexNameFromKeys(fields);
+                var idxExists = relationship[mKey].indexes.find(function (_c) {
+                    var _d = __read(_c, 1), index = _d[0];
+                    return index === idxName;
+                });
+                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_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+        }
+        // set 'id' as the PK for models without a custom PK explicitly defined
+        if (!keys[mKey].primaryKey) {
+            keys[mKey].primaryKey = [ID];
+        }
+        // create primary index
+        relationship[mKey].indexes.push([
+            'byPk',
+            keys[mKey].primaryKey,
+            { unique: true },
+        ]);
+    });
+    return [relationship, keys];
+};
+export var getIndex = function (rel, src) {
+    var indexName;
+    rel.some(function (relItem) {
+        if (relItem.modelName === src) {
+            var targetNames = extractTargetNamesFromSrc(relItem);
+            indexName = targetNames && indexNameFromKeys(targetNames);
+            return true;
+        }
+    });
+    return indexName;
+};
+export var getIndexFromAssociation = function (indexes, 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 associationIndex && associationIndex[0];
+};
+/**
+ * Backwards-compatability for schema generated prior to custom primary key support:
+the single field `targetName` has been replaced with an array of `targetNames`.
+`targetName` and `targetNames` are exclusive (will never exist on the same schema)
+ * @param src {RelationType | ModelAssociation | undefined}
+ * @returns array of targetNames, or `undefined`
+ */
+export var extractTargetNamesFromSrc = function (src) {
+    var targetName = src === null || src === void 0 ? void 0 : src.targetName;
+    var targetNames = src === null || src === void 0 ? void 0 : src.targetNames;
+    if (Array.isArray(targetNames)) {
+        return targetNames;
+    }
+    else if (typeof targetName === 'string') {
+        return [targetName];
+    }
+    else {
+        return undefined;
+    }
+};
+// Generates spinal-cased index name from an array of key field names
+// E.g. for keys `[id, title]` => 'id-title'
+export var indexNameFromKeys = function (keys) {
+    return keys.reduce(function (prev, cur, idx) {
+        if (idx === 0) {
+            return cur;
+        }
+        return "" + prev + IDENTIFIER_KEY_SEPARATOR + cur;
+    }, '');
+};
+export var keysEqual = function (keysA, keysB) {
+    if (keysA.length !== keysB.length) {
+        return false;
+    }
+    return keysA.every(function (key, idx) { return key === keysB[idx]; });
+};
+// Returns primary keys for a model
+export var getIndexKeys = function (namespace, modelName) {
+    var _c;
+    var keyPath = (_c = namespace === null || namespace === void 0 ? void 0 : namespace.keys[modelName]) === null || _c === void 0 ? void 0 : _c.primaryKey;
+    if (keyPath) {
+        return keyPath;
+    }
+    return [ID];
+};
+//#endregion
 //# sourceMappingURL=util.js.map