@aws-amplify/datastore 5.0.1-api-v6-models.c1977f8.0 → 5.0.1-api-v6-models.891fe0d.0

package/lib-esm/util.js

@@ -1,94 +1,11 @@
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-var __generator = (this && this.__generator) || function (thisArg, body) {
-    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-    function verb(n) { return function (v) { return step([n, v]); }; }
-    function step(op) {
-        if (f) throw new TypeError("Generator is already executing.");
-        while (g && (g = 0, op[0] && (_ = 0)), _) try {
-            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-            if (y = 0, t) op = [op[0] & 2, t.value];
-            switch (op[0]) {
-                case 0: case 1: t = op; break;
-                case 4: _.label++; return { value: op[1], done: false };
-                case 5: _.label++; y = op[1]; op = [0]; continue;
-                case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                default:
-                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                    if (t[2]) _.ops.pop();
-                    _.trys.pop(); continue;
-            }
-            op = body.call(thisArg, _);
-        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-    }
-};
-var __read = (this && this.__read) || function (o, n) {
-    var m = typeof Symbol === "function" && o[Symbol.iterator];
-    if (!m) return o;
-    var i = m.call(o), r, ar = [], e;
-    try {
-        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-    }
-    catch (error) { e = { error: error }; }
-    finally {
-        try {
-            if (r && !r.done && (m = i["return"])) m.call(i);
-        }
-        finally { if (e) throw e.error; }
-    }
-    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);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
-    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
-        if (ar || !(i in from)) {
-            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
-            ar[i] = from[i];
-        }
-    }
-    return to.concat(ar || Array.prototype.slice.call(from));
-};
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 import { monotonicFactory } from 'ulid';
-import { amplifyUuid, AmplifyUrl } from '@aws-amplify/core/internals/utils';
+import { amplifyUuid, AmplifyUrl, WordArray, } from '@aws-amplify/core/internals/utils';
 import { produce, applyPatches } from 'immer';
 import { isPredicateGroup, isPredicateObj, SortDirection, isModelAttributeKey, isModelAttributePrimaryKey, isModelAttributeCompositeKey, LimitTimerRaceResolvedValues, } from './types';
 import { ModelSortPredicateCreator } from './predicates';
-export var ID = 'id';
+export const ID = 'id';
 /**
  * Used by the Async Storage Adapter to concatenate key values
  * for a record. For instance, if a model has the following keys:
@@ -96,14 +13,14 @@ export var ID = 'id';
  * we concatenate the `customId` and `createdAt` as:
  * `12-234-5#2022-09-28T00:00:00.000Z`
  */
-export var DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR = '#';
+export const 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 = {
+export const IDENTIFIER_KEY_SEPARATOR = '-';
+export const 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',
@@ -116,23 +33,22 @@ export var NAMESPACES;
     NAMESPACES["SYNC"] = "sync";
     NAMESPACES["STORAGE"] = "storage";
 })(NAMESPACES || (NAMESPACES = {}));
-var DATASTORE = NAMESPACES.DATASTORE;
-var USER = NAMESPACES.USER;
-var SYNC = NAMESPACES.SYNC;
-var STORAGE = NAMESPACES.STORAGE;
+const DATASTORE = NAMESPACES.DATASTORE;
+const USER = NAMESPACES.USER;
+const SYNC = NAMESPACES.SYNC;
+const STORAGE = NAMESPACES.STORAGE;
 export { USER, SYNC, STORAGE, DATASTORE };
-export var exhaustiveCheck = function (obj, throwOnError) {
-    if (throwOnError === void 0) { throwOnError = true; }
+export const exhaustiveCheck = (obj, throwOnError = true) => {
     if (throwOnError) {
-        throw new Error("Invalid ".concat(obj));
+        throw new Error(`Invalid ${obj}`);
     }
 };
-export var isNullOrUndefined = function (val) {
+export const isNullOrUndefined = (val) => {
     return typeof val === 'undefined' || val === undefined || val === null;
 };
-export var validatePredicate = function (model, groupType, predicatesOrGroups) {
-    var filterType;
-    var isNegation = false;
+export const validatePredicate = (model, groupType, predicatesOrGroups) => {
+    let filterType;
+    let isNegation = false;
     if (predicatesOrGroups.length === 0) {
         return true;
     }
@@ -148,23 +64,23 @@ export var validatePredicate = function (model, groupType, predicatesOrGroups) {
             filterType = 'some';
             break;
         default:
-            throw new Error("Invalid ".concat(groupType));
+            throw new Error(`Invalid ${groupType}`);
     }
-    var result = predicatesOrGroups[filterType](function (predicateOrGroup) {
+    const result = predicatesOrGroups[filterType](predicateOrGroup => {
         if (isPredicateObj(predicateOrGroup)) {
-            var field = predicateOrGroup.field, operator = predicateOrGroup.operator, operand = predicateOrGroup.operand;
-            var value = model[field];
+            const { field, operator, operand } = predicateOrGroup;
+            const value = model[field];
             return validatePredicateField(value, operator, operand);
         }
         if (isPredicateGroup(predicateOrGroup)) {
-            var type = predicateOrGroup.type, predicates = predicateOrGroup.predicates;
+            const { type, predicates } = predicateOrGroup;
             return validatePredicate(model, type, predicates);
         }
         throw new Error('Not a predicate or group');
     });
     return isNegation ? !result : result;
 };
-export var validatePredicateField = function (value, operator, operand) {
+export const validatePredicateField = (value, operator, operand) => {
     switch (operator) {
         case 'ne':
             return value !== operand;
@@ -179,7 +95,7 @@ export var validatePredicateField = function (value, operator, operand) {
         case 'gt':
             return value > operand;
         case 'between':
-            var _c = __read(operand, 2), min = _c[0], max = _c[1];
+            const [min, max] = operand;
             return value >= min && value <= max;
         case 'beginsWith':
             return (!isNullOrUndefined(value) &&
@@ -194,21 +110,21 @@ export var validatePredicateField = function (value, operator, operand) {
             return false;
     }
 };
-export var isModelConstructor = function (obj) {
+export const isModelConstructor = (obj) => {
     return (obj && typeof obj.copyOf === 'function');
 };
-var nonModelClasses = new WeakSet();
+const nonModelClasses = new WeakSet();
 export function registerNonModelClass(clazz) {
     nonModelClasses.add(clazz);
 }
-export var isNonModelConstructor = function (obj) {
+export const isNonModelConstructor = (obj) => {
     return nonModelClasses.has(obj);
 };
-var topologicallySortedModels = new WeakMap();
-export var traverseModel = function (srcModelName, instance, namespace, modelInstanceCreator, getModelConstructorByModelName) {
-    var modelConstructor = getModelConstructorByModelName(namespace.name, srcModelName);
-    var result = [];
-    var newInstance = modelConstructor.copyOf(instance, function () { });
+const topologicallySortedModels = new WeakMap();
+export const traverseModel = (srcModelName, instance, namespace, modelInstanceCreator, getModelConstructorByModelName) => {
+    const modelConstructor = getModelConstructorByModelName(namespace.name, srcModelName);
+    const result = [];
+    const newInstance = modelConstructor.copyOf(instance, () => { });
     result.unshift({
         modelName: srcModelName,
         item: newInstance,
@@ -217,38 +133,29 @@ export var traverseModel = function (srcModelName, instance, namespace, modelIns
     if (!topologicallySortedModels.has(namespace)) {
         topologicallySortedModels.set(namespace, Array.from(namespace.modelTopologicalOrdering.keys()));
     }
-    var sortedModels = topologicallySortedModels.get(namespace);
-    result.sort(function (a, b) {
+    const sortedModels = topologicallySortedModels.get(namespace);
+    result.sort((a, b) => {
         return (sortedModels.indexOf(a.modelName) - sortedModels.indexOf(b.modelName));
     });
     return result;
 };
-var privateModeCheckResult;
-export var isPrivateMode = function () {
-    return new Promise(function (resolve) {
-        var dbname = amplifyUuid();
-        var db;
-        var isPrivate = function () {
+let privateModeCheckResult;
+export const isPrivateMode = () => {
+    return new Promise(resolve => {
+        const dbname = amplifyUuid();
+        let db;
+        const isPrivate = () => {
             privateModeCheckResult = false;
             resolve(true);
         };
-        var isNotPrivate = function () { return __awaiter(void 0, void 0, void 0, function () {
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        if (!(db && db.result && typeof db.result.close === 'function')) return [3 /*break*/, 2];
-                        return [4 /*yield*/, db.result.close()];
-                    case 1:
-                        _c.sent();
-                        _c.label = 2;
-                    case 2: return [4 /*yield*/, indexedDB.deleteDatabase(dbname)];
-                    case 3:
-                        _c.sent();
-                        privateModeCheckResult = true;
-                        return [2 /*return*/, resolve(false)];
-                }
-            });
-        }); };
+        const isNotPrivate = async () => {
+            if (db && db.result && typeof db.result.close === 'function') {
+                await db.result.close();
+            }
+            await indexedDB.deleteDatabase(dbname);
+            privateModeCheckResult = true;
+            return resolve(false);
+        };
         if (privateModeCheckResult === true) {
             return isNotPrivate();
         }
@@ -262,7 +169,7 @@ export var isPrivateMode = function () {
         db.onsuccess = isNotPrivate;
     });
 };
-var safariCompatabilityModeResult;
+let safariCompatabilityModeResult;
 /**
  * Whether the browser's implementation of IndexedDB breaks on array lookups
  * against composite indexes whose keypath contains a single column.
@@ -273,92 +180,99 @@ var safariCompatabilityModeResult;
  * 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 = amplifyUuid();
-                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,
+export const isSafariCompatabilityMode = async () => {
+    try {
+        const dbName = amplifyUuid();
+        const storeName = 'indexedDBFeatureProbeStore';
+        const indexName = 'idx';
+        if (indexedDB === null)
+            return false;
+        if (safariCompatabilityModeResult !== undefined) {
+            return safariCompatabilityModeResult;
+        }
+        const db = await new Promise(resolve => {
+            const dbOpenRequest = indexedDB.open(dbName);
+            dbOpenRequest.onerror = () => resolve(false);
+            dbOpenRequest.onsuccess = () => {
+                const db = dbOpenRequest.result;
+                resolve(db);
+            };
+            dbOpenRequest.onupgradeneeded = (event) => {
+                const db = event?.target?.result;
+                db.onerror = () => resolve(false);
+                const store = db.createObjectStore(storeName, {
+                    autoIncrement: true,
                 });
-                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];
+                store.createIndex(indexName, ['id']);
+            };
+        });
+        if (!db) {
+            throw new Error('Could not open probe DB');
         }
-    });
-}); };
-// TODO(v6): refactor this random number logic  auth -> core
-// const randomBytes = (nBytes: number): Buffer => {
-// 	return Buffer.from(new WordArray().random(nBytes).toString(), 'hex');
-// };
-var prng = function () { return 10 / 0xff; };
+        const rwTx = db.transaction(storeName, 'readwrite');
+        const rwStore = rwTx.objectStore(storeName);
+        rwStore.add({
+            id: 1,
+        });
+        rwTx.commit();
+        const result = await new Promise(resolve => {
+            const tx = db.transaction(storeName, 'readonly');
+            const store = tx.objectStore(storeName);
+            const index = store.index(indexName);
+            const getRequest = index.get([1]);
+            getRequest.onerror = () => resolve(false);
+            getRequest.onsuccess = (event) => {
+                resolve(event?.target?.result);
+            };
+        });
+        if (db && typeof db.close === 'function') {
+            await db.close();
+        }
+        await indexedDB.deleteDatabase(dbName);
+        if (result === undefined) {
+            safariCompatabilityModeResult = true;
+        }
+        else {
+            safariCompatabilityModeResult = false;
+        }
+    }
+    catch (error) {
+        safariCompatabilityModeResult = false;
+    }
+    return safariCompatabilityModeResult;
+};
+const HEX_TO_SHORT = {};
+for (let i = 0; i < 256; i++) {
+    let encodedByte = i.toString(16).toLowerCase();
+    if (encodedByte.length === 1) {
+        encodedByte = `0${encodedByte}`;
+    }
+    HEX_TO_SHORT[encodedByte] = i;
+}
+const getBytesFromHex = (encoded) => {
+    if (encoded.length % 2 !== 0) {
+        throw new Error('Hex encoded strings must have an even number length');
+    }
+    const out = new Uint8Array(encoded.length / 2);
+    for (let i = 0; i < encoded.length; i += 2) {
+        const encodedByte = encoded.slice(i, i + 2).toLowerCase();
+        if (encodedByte in HEX_TO_SHORT) {
+            out[i / 2] = HEX_TO_SHORT[encodedByte];
+        }
+        else {
+            throw new Error(`Cannot decode unrecognized sequence ${encodedByte} as hexadecimal`);
+        }
+    }
+    return out;
+};
+const randomBytes = (nBytes) => {
+    const str = new WordArray().random(nBytes).toString();
+    return getBytesFromHex(str);
+};
+const prng = () => randomBytes(1)[0] / 0xff;
 export function monotonicUlidFactory(seed) {
-    var ulid = monotonicFactory(prng);
-    return function () {
+    const ulid = monotonicFactory(prng);
+    return () => {
         return ulid(seed);
     };
 }
@@ -386,29 +300,18 @@ export function getNow() {
 }
 export function sortCompareFunction(sortPredicates) {
     return function compareFunction(a, b) {
-        var e_1, _c;
-        try {
-            // enable multi-field sort by iterating over predicates until
-            // a comparison returns -1 or 1
-            for (var sortPredicates_1 = __values(sortPredicates), sortPredicates_1_1 = sortPredicates_1.next(); !sortPredicates_1_1.done; sortPredicates_1_1 = sortPredicates_1.next()) {
-                var predicate = sortPredicates_1_1.value;
-                var field = predicate.field, sortDirection = predicate.sortDirection;
-                // reverse result when direction is descending
-                var sortMultiplier = sortDirection === SortDirection.ASCENDING ? 1 : -1;
-                if (a[field] < b[field]) {
-                    return -1 * sortMultiplier;
-                }
-                if (a[field] > b[field]) {
-                    return 1 * sortMultiplier;
-                }
+        // enable multi-field sort by iterating over predicates until
+        // a comparison returns -1 or 1
+        for (const predicate of sortPredicates) {
+            const { field, sortDirection } = predicate;
+            // reverse result when direction is descending
+            const sortMultiplier = sortDirection === SortDirection.ASCENDING ? 1 : -1;
+            if (a[field] < b[field]) {
+                return -1 * sortMultiplier;
             }
-        }
-        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);
+            if (a[field] > b[field]) {
+                return 1 * sortMultiplier;
             }
-            finally { if (e_1) throw e_1.error; }
         }
         return 0;
     };
@@ -418,12 +321,10 @@ export function sortCompareFunction(sortPredicates) {
 // returns true if equal by value
 // 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_2, _c;
-    if (nullish === void 0) { nullish = false; }
-    var a = valA;
-    var b = valB;
-    var nullishCompare = function (_a, _b) {
+export function valuesEqual(valA, valB, nullish = false) {
+    let a = valA;
+    let b = valB;
+    const nullishCompare = (_a, _b) => {
         return ((_a === undefined || _a === null) && (_b === undefined || _b === null));
     };
     // if one of the values is a primitive and the other is an object
@@ -444,15 +345,15 @@ export function valuesEqual(valA, valB, nullish) {
         return false;
     }
     if (a instanceof Set && b instanceof Set) {
-        a = __spreadArray([], __read(a), false);
-        b = __spreadArray([], __read(b), false);
+        a = [...a];
+        b = [...b];
     }
     if (a instanceof Map && b instanceof Map) {
         a = Object.fromEntries(a);
         b = Object.fromEntries(b);
     }
-    var aKeys = Object.keys(a);
-    var bKeys = Object.keys(b);
+    const aKeys = Object.keys(a);
+    const bKeys = Object.keys(b);
     // last condition is to ensure that [] !== [null] even if nullish. However [undefined] === [null] when nullish
     if (aKeys.length !== bKeys.length && (!nullish || Array.isArray(a))) {
         return false;
@@ -460,23 +361,13 @@ export function valuesEqual(valA, valB, nullish) {
     // iterate through the longer set of keys
     // e.g., for a nullish comparison of a={ a: 1 } and b={ a: 1, b: null }
     // we want to iterate through bKeys
-    var keys = aKeys.length >= bKeys.length ? aKeys : bKeys;
-    try {
-        for (var keys_1 = __values(keys), keys_1_1 = keys_1.next(); !keys_1_1.done; keys_1_1 = keys_1.next()) {
-            var key = keys_1_1.value;
-            var aVal = a[key];
-            var bVal = b[key];
-            if (!valuesEqual(aVal, bVal, nullish)) {
-                return false;
-            }
-        }
-    }
-    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);
+    const keys = aKeys.length >= bKeys.length ? aKeys : bKeys;
+    for (const key of keys) {
+        const aVal = a[key];
+        const bVal = b[key];
+        if (!valuesEqual(aVal, bVal, nullish)) {
+            return false;
         }
-        finally { if (e_2) throw e_2.error; }
     }
     return true;
 }
@@ -490,15 +381,15 @@ export function valuesEqual(valA, valB, nullish) {
 export function inMemoryPagination(records, pagination) {
     if (pagination && records.length > 1) {
         if (pagination.sort) {
-            var sortPredicates = ModelSortPredicateCreator.getPredicates(pagination.sort);
+            const sortPredicates = ModelSortPredicateCreator.getPredicates(pagination.sort);
             if (sortPredicates.length) {
-                var compareFn = sortCompareFunction(sortPredicates);
+                const compareFn = sortCompareFunction(sortPredicates);
                 records.sort(compareFn);
             }
         }
-        var _c = pagination.page, page = _c === void 0 ? 0 : _c, _d = pagination.limit, limit = _d === void 0 ? 0 : _d;
-        var start = Math.max(0, page * limit) || 0;
-        var end = limit > 0 ? start + limit : records.length;
+        const { page = 0, limit = 0 } = pagination;
+        const start = Math.max(0, page * limit) || 0;
+        const end = limit > 0 ? start + limit : records.length;
         return records.slice(start, end);
     }
     return records;
@@ -510,43 +401,13 @@ export function inMemoryPagination(records, pagination) {
  * return Promise<boolean>: `true` for a matching item, `false` otherwise.
  * @returns A `Promise<boolean>`, `true` if "some" items match; `false` otherwise.
  */
-export function asyncSome(items, matches) {
-    return __awaiter(this, void 0, void 0, function () {
-        var items_1, items_1_1, item, e_3_1;
-        var e_3, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _d.trys.push([0, 5, 6, 7]);
-                    items_1 = __values(items), items_1_1 = items_1.next();
-                    _d.label = 1;
-                case 1:
-                    if (!!items_1_1.done) return [3 /*break*/, 4];
-                    item = items_1_1.value;
-                    return [4 /*yield*/, matches(item)];
-                case 2:
-                    if (_d.sent()) {
-                        return [2 /*return*/, true];
-                    }
-                    _d.label = 3;
-                case 3:
-                    items_1_1 = items_1.next();
-                    return [3 /*break*/, 1];
-                case 4: return [3 /*break*/, 7];
-                case 5:
-                    e_3_1 = _d.sent();
-                    e_3 = { error: e_3_1 };
-                    return [3 /*break*/, 7];
-                case 6:
-                    try {
-                        if (items_1_1 && !items_1_1.done && (_c = items_1.return)) _c.call(items_1);
-                    }
-                    finally { if (e_3) throw e_3.error; }
-                    return [7 /*endfinally*/];
-                case 7: return [2 /*return*/, false];
-            }
-        });
-    });
+export async function asyncSome(items, matches) {
+    for (const item of items) {
+        if (await matches(item)) {
+            return true;
+        }
+    }
+    return false;
 }
 /**
  * An `aysnc` implementation of `Array.every()`. Returns as soon as a non-match is found.
@@ -555,43 +416,13 @@ export function asyncSome(items, matches) {
  * return Promise<boolean>: `true` for a matching item, `false` otherwise.
  * @returns A `Promise<boolean>`, `true` if every item matches; `false` otherwise.
  */
-export function asyncEvery(items, matches) {
-    return __awaiter(this, void 0, void 0, function () {
-        var items_2, items_2_1, item, e_4_1;
-        var e_4, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _d.trys.push([0, 5, 6, 7]);
-                    items_2 = __values(items), items_2_1 = items_2.next();
-                    _d.label = 1;
-                case 1:
-                    if (!!items_2_1.done) return [3 /*break*/, 4];
-                    item = items_2_1.value;
-                    return [4 /*yield*/, matches(item)];
-                case 2:
-                    if (!(_d.sent())) {
-                        return [2 /*return*/, false];
-                    }
-                    _d.label = 3;
-                case 3:
-                    items_2_1 = items_2.next();
-                    return [3 /*break*/, 1];
-                case 4: return [3 /*break*/, 7];
-                case 5:
-                    e_4_1 = _d.sent();
-                    e_4 = { error: e_4_1 };
-                    return [3 /*break*/, 7];
-                case 6:
-                    try {
-                        if (items_2_1 && !items_2_1.done && (_c = items_2.return)) _c.call(items_2);
-                    }
-                    finally { if (e_4) throw e_4.error; }
-                    return [7 /*endfinally*/];
-                case 7: return [2 /*return*/, true];
-            }
-        });
-    });
+export async function asyncEvery(items, matches) {
+    for (const item of items) {
+        if (!(await matches(item))) {
+            return false;
+        }
+    }
+    return true;
 }
 /**
  * An `async` implementation of `Array.filter()`. Returns after all items have been filtered.
@@ -601,162 +432,114 @@ export function asyncEvery(items, matches) {
  * return Promise<boolean>: `true` for a matching item, `false` otherwise.
  * @returns A `Promise<T>` of matching items.
  */
-export function asyncFilter(items, matches) {
-    return __awaiter(this, void 0, void 0, function () {
-        var results, items_3, items_3_1, item, e_5_1;
-        var e_5, _c;
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    results = [];
-                    _d.label = 1;
-                case 1:
-                    _d.trys.push([1, 6, 7, 8]);
-                    items_3 = __values(items), items_3_1 = items_3.next();
-                    _d.label = 2;
-                case 2:
-                    if (!!items_3_1.done) return [3 /*break*/, 5];
-                    item = items_3_1.value;
-                    return [4 /*yield*/, matches(item)];
-                case 3:
-                    if (_d.sent()) {
-                        results.push(item);
-                    }
-                    _d.label = 4;
-                case 4:
-                    items_3_1 = items_3.next();
-                    return [3 /*break*/, 2];
-                case 5: return [3 /*break*/, 8];
-                case 6:
-                    e_5_1 = _d.sent();
-                    e_5 = { error: e_5_1 };
-                    return [3 /*break*/, 8];
-                case 7:
-                    try {
-                        if (items_3_1 && !items_3_1.done && (_c = items_3.return)) _c.call(items_3);
-                    }
-                    finally { if (e_5) throw e_5.error; }
-                    return [7 /*endfinally*/];
-                case 8: return [2 /*return*/, results];
-            }
-        });
-    });
+export async function asyncFilter(items, matches) {
+    const results = [];
+    for (const item of items) {
+        if (await matches(item)) {
+            results.push(item);
+        }
+    }
+    return results;
 }
-export var isAWSDate = function (val) {
+export const isAWSDate = (val) => {
     return !!/^\d{4}-\d{2}-\d{2}(Z|[+-]\d{2}:\d{2}($|:\d{2}))?$/.exec(val);
 };
-export var isAWSTime = function (val) {
+export const isAWSTime = (val) => {
     return !!/^\d{2}:\d{2}(:\d{2}(.\d+)?)?(Z|[+-]\d{2}:\d{2}($|:\d{2}))?$/.exec(val);
 };
-export var isAWSDateTime = function (val) {
+export const isAWSDateTime = (val) => {
     return !!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(.\d+)?)?(Z|[+-]\d{2}:\d{2}($|:\d{2}))?$/.exec(val);
 };
-export var isAWSTimestamp = function (val) {
+export const isAWSTimestamp = (val) => {
     return !!/^\d+$/.exec(String(val));
 };
-export var isAWSEmail = function (val) {
+export const isAWSEmail = (val) => {
     return !!/^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/.exec(val);
 };
-export var isAWSJSON = function (val) {
+export const isAWSJSON = (val) => {
     try {
         JSON.parse(val);
         return true;
     }
-    catch (_c) {
+    catch {
         return false;
     }
 };
-export var isAWSURL = function (val) {
+export const isAWSURL = (val) => {
     try {
         return !!new AmplifyUrl(val);
     }
-    catch (_c) {
+    catch {
         return false;
     }
 };
-export var isAWSPhone = function (val) {
+export const isAWSPhone = (val) => {
     return !!/^\+?\d[\d\s-]+$/.exec(val);
 };
-export var isAWSIPAddress = function (val) {
+export const isAWSIPAddress = (val) => {
     return !!/((^((([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5])\.){3}([0-9]|[1-9][0-9]|1[0-9]{2}|2[0-4][0-9]|25[0-5]))$)|(^((([0-9A-Fa-f]{1,4}:){7}([0-9A-Fa-f]{1,4}|:))|(([0-9A-Fa-f]{1,4}:){6}(:[0-9A-Fa-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){5}(((:[0-9A-Fa-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9A-Fa-f]{1,4}:){4}(((:[0-9A-Fa-f]{1,4}){1,3})|((:[0-9A-Fa-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){3}(((:[0-9A-Fa-f]{1,4}){1,4})|((:[0-9A-Fa-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){2}(((:[0-9A-Fa-f]{1,4}){1,5})|((:[0-9A-Fa-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9A-Fa-f]{1,4}:){1}(((:[0-9A-Fa-f]{1,4}){1,6})|((:[0-9A-Fa-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9A-Fa-f]{1,4}){1,7})|((:[0-9A-Fa-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))(%.+)?$))$/.exec(val);
 };
-var DeferredPromise = /** @class */ (function () {
-    function DeferredPromise() {
-        var self = this;
-        this.promise = new Promise(function (resolve, reject) {
+export class DeferredPromise {
+    constructor() {
+        const self = this;
+        this.promise = new Promise((resolve, reject) => {
             self.resolve = resolve;
             self.reject = reject;
         });
     }
-    return DeferredPromise;
-}());
-export { DeferredPromise };
-var DeferredCallbackResolver = /** @class */ (function () {
-    function DeferredCallbackResolver(options) {
+}
+export class DeferredCallbackResolver {
+    constructor(options) {
         this.limitPromise = new DeferredPromise();
         this.raceInFlight = false;
-        this.callback = function () { };
-        this.defaultErrorHandler = function (msg) {
-            if (msg === void 0) { msg = 'DeferredCallbackResolver error'; }
+        this.callback = () => { };
+        this.defaultErrorHandler = (msg = 'DeferredCallbackResolver error') => {
             throw new Error(msg);
         };
         this.callback = options.callback;
         this.errorHandler = options.errorHandler || this.defaultErrorHandler;
         this.maxInterval = options.maxInterval || 2000;
     }
-    DeferredCallbackResolver.prototype.startTimer = function () {
-        var _this = this;
-        this.timerPromise = new Promise(function (resolve, reject) {
-            _this.timer = setTimeout(function () {
+    startTimer() {
+        this.timerPromise = new Promise((resolve, reject) => {
+            this.timer = setTimeout(() => {
                 resolve(LimitTimerRaceResolvedValues.TIMER);
-            }, _this.maxInterval);
+            }, this.maxInterval);
         });
-    };
-    DeferredCallbackResolver.prototype.racePromises = function () {
-        return __awaiter(this, void 0, void 0, function () {
-            var winner, err_1;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
-                    case 0:
-                        _c.trys.push([0, 2, 3, 4]);
-                        this.raceInFlight = true;
-                        this.startTimer();
-                        return [4 /*yield*/, Promise.race([
-                                this.timerPromise,
-                                this.limitPromise.promise,
-                            ])];
-                    case 1:
-                        winner = _c.sent();
-                        this.callback();
-                        return [3 /*break*/, 4];
-                    case 2:
-                        err_1 = _c.sent();
-                        this.errorHandler(err_1);
-                        return [3 /*break*/, 4];
-                    case 3:
-                        // reset for the next race
-                        this.clear();
-                        this.raceInFlight = false;
-                        this.limitPromise = new DeferredPromise();
-                        return [2 /*return*/, winner];
-                    case 4: return [2 /*return*/];
-                }
-            });
-        });
-    };
-    DeferredCallbackResolver.prototype.start = function () {
+    }
+    async racePromises() {
+        let winner;
+        try {
+            this.raceInFlight = true;
+            this.startTimer();
+            winner = await Promise.race([
+                this.timerPromise,
+                this.limitPromise.promise,
+            ]);
+            this.callback();
+        }
+        catch (err) {
+            this.errorHandler(err);
+        }
+        finally {
+            // reset for the next race
+            this.clear();
+            this.raceInFlight = false;
+            this.limitPromise = new DeferredPromise();
+            return winner;
+        }
+    }
+    start() {
         if (!this.raceInFlight)
             this.racePromises();
-    };
-    DeferredCallbackResolver.prototype.clear = function () {
+    }
+    clear() {
         clearTimeout(this.timer);
-    };
-    DeferredCallbackResolver.prototype.resolve = function () {
+    }
+    resolve() {
         this.limitPromise.resolve(LimitTimerRaceResolvedValues.LIMIT);
-    };
-    return DeferredCallbackResolver;
-}());
-export { DeferredCallbackResolver };
+    }
+}
 /**
  * merge two sets of patches created by immer produce.
  * newPatches take precedent over oldPatches for patches modifying the same path.
@@ -775,17 +558,17 @@ export { DeferredCallbackResolver };
  * @return merged patches
  */
 export function mergePatches(originalSource, oldPatches, newPatches) {
-    var patchesToMerge = oldPatches.concat(newPatches);
-    var patches;
-    produce(originalSource, function (draft) {
+    const patchesToMerge = oldPatches.concat(newPatches);
+    let patches;
+    produce(originalSource, draft => {
         applyPatches(draft, patchesToMerge);
-    }, function (p) {
+    }, p => {
         patches = p;
     });
     return patches;
 }
-export var getStorename = function (namespace, modelName) {
-    var storeName = "".concat(namespace, "_").concat(modelName);
+export const getStorename = (namespace, modelName) => {
+    const storeName = `${namespace}_${modelName}`;
     return storeName;
 };
 //#region Key Utils
@@ -821,73 +604,70 @@ export var getStorename = function (namespace, modelName) {
 
     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
+export const processCompositeKeys = (attributes) => {
+    const extractCompositeSortKey = ({ properties: { 
+    // ignore the HK (fields[0]) we only need to include the composite sort key fields[1...n]
+    fields: [, ...sortKeyFields], }, }) => sortKeyFields;
+    const 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 __spreadArray([], __read(existingSet), false).some(function (f) { return sortKeyFieldsSet.has(f); });
-            });
-            if (intersectingSetIdx > -1) {
-                var union = new Set(__spreadArray(__spreadArray([], __read(combined[intersectingSetIdx]), false), __read(sortKeyFieldsSet), false));
-                // 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);
-            }
+    const combineIntersecting = (fields) => fields.reduce((combined, sortKeyFields) => {
+        const sortKeyFieldsSet = new Set(sortKeyFields);
+        if (combined.length === 0) {
+            combined.push(sortKeyFieldsSet);
             return combined;
-        }, []);
-    };
-    var initial = combineIntersecting(compositeKeyFields);
+        }
+        // does the current set share values with another set we've already added to `combined`?
+        const intersectingSetIdx = combined.findIndex(existingSet => {
+            return [...existingSet].some(f => sortKeyFieldsSet.has(f));
+        });
+        if (intersectingSetIdx > -1) {
+            const union = new Set([
+                ...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;
+    }, []);
+    const 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);
+    const 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);
+export const extractKeyIfExists = (modelDefinition) => {
+    const keyAttribute = modelDefinition?.attributes?.find(isModelAttributeKey);
     return keyAttribute;
 };
-export var extractPrimaryKeyFieldNames = function (modelDefinition) {
-    var keyAttribute = extractKeyIfExists(modelDefinition);
+export const extractPrimaryKeyFieldNames = (modelDefinition) => {
+    const 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 const extractPrimaryKeyValues = (model, keyFields) => {
+    return keyFields.map(key => model[key]);
 };
-export var extractPrimaryKeysAndValues = function (model, keyFields) {
-    var primaryKeysAndValues = {};
-    keyFields.forEach(function (key) { return (primaryKeysAndValues[key] = model[key]); });
+export const extractPrimaryKeysAndValues = (model, keyFields) => {
+    const primaryKeysAndValues = {};
+    keyFields.forEach(key => (primaryKeysAndValues[key] = model[key]));
     return primaryKeysAndValues;
 };
 // IdentifierFields<ManagedIdentifier>
 // Default behavior without explicit @primaryKey defined
-export var isIdManaged = function (modelDefinition) {
-    var keyAttribute = extractKeyIfExists(modelDefinition);
+export const isIdManaged = (modelDefinition) => {
+    const keyAttribute = extractKeyIfExists(modelDefinition);
     if (keyAttribute && isModelAttributePrimaryKey(keyAttribute)) {
         return false;
     }
@@ -895,26 +675,25 @@ export var isIdManaged = function (modelDefinition) {
 };
 // IdentifierFields<OptionallyManagedIdentifier>
 // @primaryKey with explicit `id` in the PK. Single key or composite
-export var isIdOptionallyManaged = function (modelDefinition) {
-    var keyAttribute = extractKeyIfExists(modelDefinition);
+export const isIdOptionallyManaged = (modelDefinition) => {
+    const 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_6, _c;
+export const establishRelationAndKeys = (namespace) => {
+    const relationship = {};
+    const keys = {};
+    Object.keys(namespace.models).forEach((mKey) => {
         relationship[mKey] = { indexes: [], relationTypes: [] };
         keys[mKey] = {};
-        var model = namespace.models[mKey];
-        Object.keys(model.fields).forEach(function (attr) {
-            var fieldAttribute = model.fields[attr];
+        const model = namespace.models[mKey];
+        Object.keys(model.fields).forEach((attr) => {
+            const fieldAttribute = model.fields[attr];
             if (typeof fieldAttribute.type === 'object' &&
                 'model' in fieldAttribute.type) {
-                var connectionType = fieldAttribute.association.connectionType;
+                const connectionType = fieldAttribute.association.connectionType;
                 relationship[mKey].relationTypes.push({
                     fieldName: fieldAttribute.name,
                     modelName: fieldAttribute.type.model,
@@ -924,15 +703,12 @@ export var establishRelationAndKeys = function (namespace) {
                     associatedWith: fieldAttribute.association['associatedWith'],
                 });
                 if (connectionType === 'BELONGS_TO') {
-                    var targetNames = extractTargetNamesFromSrc(fieldAttribute.association);
+                    const targetNames = extractTargetNamesFromSrc(fieldAttribute.association);
                     if (targetNames) {
-                        var idxName_1 = indexNameFromKeys(targetNames);
-                        var idxExists = relationship[mKey].indexes.find(function (_c) {
-                            var _d = __read(_c, 1), index = _d[0];
-                            return index === idxName_1;
-                        });
+                        const idxName = indexNameFromKeys(targetNames);
+                        const idxExists = relationship[mKey].indexes.find(([index]) => index === idxName);
                         if (!idxExists) {
-                            relationship[mKey].indexes.push([idxName_1, targetNames]);
+                            relationship[mKey].indexes.push([idxName, targetNames]);
                         }
                     }
                 }
@@ -940,37 +716,21 @@ export var establishRelationAndKeys = function (namespace) {
         });
         if (model.attributes) {
             keys[mKey].compositeKeys = processCompositeKeys(model.attributes);
-            var _loop_1 = function (attribute) {
+            for (const attribute of model.attributes) {
                 if (!isModelAttributeKey(attribute)) {
-                    return "continue";
+                    continue;
                 }
-                var fields = attribute.properties.fields;
+                const { fields } = attribute.properties;
                 if (isModelAttributePrimaryKey(attribute)) {
                     keys[mKey].primaryKey = fields;
-                    return "continue";
+                    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;
-                });
+                const idxName = indexNameFromKeys(fields);
+                const idxExists = relationship[mKey].indexes.find(([index]) => 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_6_1) { e_6 = { error: e_6_1 }; }
-            finally {
-                try {
-                    if (_e && !_e.done && (_c = _d.return)) _c.call(_d);
-                }
-                finally { if (e_6) throw e_6.error; }
             }
         }
         // set 'id' as the PK for models without a custom PK explicitly defined
@@ -986,29 +746,26 @@ export var establishRelationAndKeys = function (namespace) {
     });
     return [relationship, keys];
 };
-export var getIndex = function (rel, src) {
-    var indexName;
-    rel.some(function (relItem) {
+export const getIndex = (rel, src) => {
+    let indexName;
+    rel.some((relItem) => {
         if (relItem.modelName === src) {
-            var targetNames = extractTargetNamesFromSrc(relItem);
+            const targetNames = extractTargetNamesFromSrc(relItem);
             indexName = targetNames && indexNameFromKeys(targetNames);
             return true;
         }
     });
     return indexName;
 };
-export var getIndexFromAssociation = function (indexes, src) {
-    var indexName;
+export const getIndexFromAssociation = (indexes, src) => {
+    let 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;
-    });
+    const associationIndex = indexes.find(([idxName]) => idxName === indexName);
     return associationIndex && associationIndex[0];
 };
 /**
@@ -1018,9 +775,9 @@ the single field `targetName` has been replaced with an array of `targetNames`.
  * @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;
+export const extractTargetNamesFromSrc = (src) => {
+    const targetName = src?.targetName;
+    const targetNames = src?.targetNames;
     if (Array.isArray(targetNames)) {
         return targetNames;
     }
@@ -1033,24 +790,23 @@ export var extractTargetNamesFromSrc = function (src) {
 };
 // 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) {
+export const indexNameFromKeys = (keys) => {
+    return keys.reduce((prev, cur, idx) => {
         if (idx === 0) {
             return cur;
         }
-        return "".concat(prev).concat(IDENTIFIER_KEY_SEPARATOR).concat(cur);
+        return `${prev}${IDENTIFIER_KEY_SEPARATOR}${cur}`;
     }, '');
 };
-export var keysEqual = function (keysA, keysB) {
+export const keysEqual = (keysA, keysB) => {
     if (keysA.length !== keysB.length) {
         return false;
     }
-    return keysA.every(function (key, idx) { return key === keysB[idx]; });
+    return keysA.every((key, idx) => key === keysB[idx]);
 };
 // Returns primary keys for a model
-export var getIndexKeys = function (namespace, modelName) {
-    var _c, _d;
-    var keyPath = (_d = (_c = namespace === null || namespace === void 0 ? void 0 : namespace.keys) === null || _c === void 0 ? void 0 : _c[modelName]) === null || _d === void 0 ? void 0 : _d.primaryKey;
+export const getIndexKeys = (namespace, modelName) => {
+    const keyPath = namespace?.keys?.[modelName]?.primaryKey;
     if (keyPath) {
         return keyPath;
     }
@@ -1069,14 +825,16 @@ export var getIndexKeys = function (namespace, modelName) {
  * @param definition modelDefinition to inspect.
  * @returns An object mapping `createdAt` and `updatedAt` to their field names.
  */
-export var getTimestampFields = function (definition) {
-    var _c, _d;
-    var modelAttributes = (_c = definition.attributes) === null || _c === void 0 ? void 0 : _c.find(function (attr) { return attr.type === 'model'; });
-    var timestampFieldsMap = (_d = modelAttributes === null || modelAttributes === void 0 ? void 0 : modelAttributes.properties) === null || _d === void 0 ? void 0 : _d.timestamps;
-    var defaultFields = {
+export const getTimestampFields = (definition) => {
+    const modelAttributes = definition.attributes?.find(attr => attr.type === 'model');
+    const timestampFieldsMap = modelAttributes?.properties?.timestamps;
+    const defaultFields = {
         createdAt: 'createdAt',
         updatedAt: 'updatedAt',
     };
-    var customFields = timestampFieldsMap || {};
-    return __assign(__assign({}, defaultFields), customFields);
+    const customFields = timestampFieldsMap || {};
+    return {
+        ...defaultFields,
+        ...customFields,
+    };
 };