@aws-amplify/datastore 3.12.11 → 3.12.13-unstable.1

package/lib-esm/util.js

@@ -50,10 +50,6 @@ var __read = (this && this.__read) || function (o, n) {
     }
     return ar;
 };
-var __spread = (this && this.__spread) || function () {
-    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
-    return ar;
-};
 var __values = (this && this.__values) || function(o) {
     var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
     if (m) return m.call(o);
@@ -65,12 +61,37 @@ var __values = (this && this.__values) || function(o) {
     };
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
+var __spread = (this && this.__spread) || function () {
+    for (var ar = [], i = 0; i < arguments.length; i++) ar = ar.concat(__read(arguments[i]));
+    return ar;
+};
 import { Buffer } from 'buffer';
 import { monotonicFactory } from 'ulid';
 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";
@@ -168,148 +189,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;
@@ -335,12 +214,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 {
@@ -367,8 +260,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':
@@ -394,19 +304,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) {
@@ -480,7 +377,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
@@ -497,12 +394,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;
     };
@@ -513,7 +410,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;
@@ -565,12 +462,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;
 }
@@ -716,4 +613,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