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

package/lib/util.js

@@ -1,97 +1,14 @@
 "use strict";
-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));
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getIndexFromAssociation = exports.getIndex = exports.establishRelationAndKeys = exports.isIdOptionallyManaged = exports.isIdManaged = exports.extractPrimaryKeysAndValues = exports.extractPrimaryKeyValues = exports.extractPrimaryKeyFieldNames = exports.extractKeyIfExists = exports.processCompositeKeys = exports.getStorename = exports.mergePatches = exports.DeferredCallbackResolver = exports.DeferredPromise = exports.isAWSIPAddress = exports.isAWSPhone = exports.isAWSURL = exports.isAWSJSON = exports.isAWSEmail = exports.isAWSTimestamp = exports.isAWSDateTime = exports.isAWSTime = exports.isAWSDate = exports.asyncFilter = exports.asyncEvery = exports.asyncSome = exports.inMemoryPagination = exports.valuesEqual = exports.sortCompareFunction = exports.getNow = exports.monotonicUlidFactory = exports.isSafariCompatabilityMode = exports.isPrivateMode = exports.traverseModel = exports.isNonModelConstructor = exports.registerNonModelClass = exports.isModelConstructor = exports.validatePredicateField = exports.validatePredicate = exports.isNullOrUndefined = exports.exhaustiveCheck = exports.DATASTORE = exports.STORAGE = exports.SYNC = exports.USER = exports.NAMESPACES = exports.errorMessages = exports.IDENTIFIER_KEY_SEPARATOR = exports.DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR = exports.ID = void 0;
 exports.getTimestampFields = exports.getIndexKeys = exports.keysEqual = exports.indexNameFromKeys = exports.extractTargetNamesFromSrc = void 0;
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-var ulid_1 = require("ulid");
-var utils_1 = require("@aws-amplify/core/internals/utils");
-var immer_1 = require("immer");
-var types_1 = require("./types");
-var predicates_1 = require("./predicates");
+const ulid_1 = require("ulid");
+const utils_1 = require("@aws-amplify/core/internals/utils");
+const immer_1 = require("immer");
+const types_1 = require("./types");
+const predicates_1 = require("./predicates");
 exports.ID = 'id';
 /**
  * Used by the Async Storage Adapter to concatenate key values
@@ -120,28 +37,27 @@ var NAMESPACES;
     NAMESPACES["SYNC"] = "sync";
     NAMESPACES["STORAGE"] = "storage";
 })(NAMESPACES = exports.NAMESPACES || (exports.NAMESPACES = {}));
-var DATASTORE = NAMESPACES.DATASTORE;
+const DATASTORE = NAMESPACES.DATASTORE;
 exports.DATASTORE = DATASTORE;
-var USER = NAMESPACES.USER;
+const USER = NAMESPACES.USER;
 exports.USER = USER;
-var SYNC = NAMESPACES.SYNC;
+const SYNC = NAMESPACES.SYNC;
 exports.SYNC = SYNC;
-var STORAGE = NAMESPACES.STORAGE;
+const STORAGE = NAMESPACES.STORAGE;
 exports.STORAGE = STORAGE;
-var exhaustiveCheck = function (obj, throwOnError) {
-    if (throwOnError === void 0) { throwOnError = true; }
+const exhaustiveCheck = (obj, throwOnError = true) => {
     if (throwOnError) {
-        throw new Error("Invalid ".concat(obj));
+        throw new Error(`Invalid ${obj}`);
     }
 };
 exports.exhaustiveCheck = exhaustiveCheck;
-var isNullOrUndefined = function (val) {
+const isNullOrUndefined = (val) => {
     return typeof val === 'undefined' || val === undefined || val === null;
 };
 exports.isNullOrUndefined = isNullOrUndefined;
-var validatePredicate = function (model, groupType, predicatesOrGroups) {
-    var filterType;
-    var isNegation = false;
+const validatePredicate = (model, groupType, predicatesOrGroups) => {
+    let filterType;
+    let isNegation = false;
     if (predicatesOrGroups.length === 0) {
         return true;
     }
@@ -157,16 +73,16 @@ 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 ((0, types_1.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 (0, exports.validatePredicateField)(value, operator, operand);
         }
         if ((0, types_1.isPredicateGroup)(predicateOrGroup)) {
-            var type = predicateOrGroup.type, predicates = predicateOrGroup.predicates;
+            const { type, predicates } = predicateOrGroup;
             return (0, exports.validatePredicate)(model, type, predicates);
         }
         throw new Error('Not a predicate or group');
@@ -174,7 +90,7 @@ var validatePredicate = function (model, groupType, predicatesOrGroups) {
     return isNegation ? !result : result;
 };
 exports.validatePredicate = validatePredicate;
-var validatePredicateField = function (value, operator, operand) {
+const validatePredicateField = (value, operator, operand) => {
     switch (operator) {
         case 'ne':
             return value !== operand;
@@ -189,7 +105,7 @@ 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 (!(0, exports.isNullOrUndefined)(value) &&
@@ -205,24 +121,24 @@ var validatePredicateField = function (value, operator, operand) {
     }
 };
 exports.validatePredicateField = validatePredicateField;
-var isModelConstructor = function (obj) {
+const isModelConstructor = (obj) => {
     return (obj && typeof obj.copyOf === 'function');
 };
 exports.isModelConstructor = isModelConstructor;
-var nonModelClasses = new WeakSet();
+const nonModelClasses = new WeakSet();
 function registerNonModelClass(clazz) {
     nonModelClasses.add(clazz);
 }
 exports.registerNonModelClass = registerNonModelClass;
-var isNonModelConstructor = function (obj) {
+const isNonModelConstructor = (obj) => {
     return nonModelClasses.has(obj);
 };
 exports.isNonModelConstructor = isNonModelConstructor;
-var topologicallySortedModels = new WeakMap();
-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();
+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,
@@ -231,39 +147,30 @@ var traverseModel = function (srcModelName, instance, namespace, modelInstanceCr
     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;
 };
 exports.traverseModel = traverseModel;
-var privateModeCheckResult;
-var isPrivateMode = function () {
-    return new Promise(function (resolve) {
-        var dbname = (0, utils_1.amplifyUuid)();
-        var db;
-        var isPrivate = function () {
+let privateModeCheckResult;
+const isPrivateMode = () => {
+    return new Promise(resolve => {
+        const dbname = (0, utils_1.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();
         }
@@ -278,7 +185,7 @@ var isPrivateMode = function () {
     });
 };
 exports.isPrivateMode = isPrivateMode;
-var safariCompatabilityModeResult;
+let safariCompatabilityModeResult;
 /**
  * Whether the browser's implementation of IndexedDB breaks on array lookups
  * against composite indexes whose keypath contains a single column.
@@ -289,93 +196,100 @@ 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.
  */
-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 = (0, utils_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,
+const isSafariCompatabilityMode = async () => {
+    try {
+        const dbName = (0, utils_1.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');
         }
-    });
-}); };
+        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;
+};
 exports.isSafariCompatabilityMode = isSafariCompatabilityMode;
-// 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 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 utils_1.WordArray().random(nBytes).toString();
+    return getBytesFromHex(str);
+};
+const prng = () => randomBytes(1)[0] / 0xff;
 function monotonicUlidFactory(seed) {
-    var ulid = (0, ulid_1.monotonicFactory)(prng);
-    return function () {
+    const ulid = (0, ulid_1.monotonicFactory)(prng);
+    return () => {
         return ulid(seed);
     };
 }
@@ -405,29 +319,18 @@ function getNow() {
 exports.getNow = getNow;
 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 === types_1.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 === types_1.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;
     };
@@ -438,12 +341,10 @@ exports.sortCompareFunction = sortCompareFunction;
 // 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
-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) {
+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
@@ -464,15 +365,15 @@ 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;
@@ -480,23 +381,13 @@ 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;
 }
@@ -511,15 +402,15 @@ exports.valuesEqual = valuesEqual;
 function inMemoryPagination(records, pagination) {
     if (pagination && records.length > 1) {
         if (pagination.sort) {
-            var sortPredicates = predicates_1.ModelSortPredicateCreator.getPredicates(pagination.sort);
+            const sortPredicates = predicates_1.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;
@@ -532,43 +423,13 @@ exports.inMemoryPagination = inMemoryPagination;
  * return Promise<boolean>: `true` for a matching item, `false` otherwise.
  * @returns A `Promise<boolean>`, `true` if "some" items match; `false` otherwise.
  */
-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];
-            }
-        });
-    });
+async function asyncSome(items, matches) {
+    for (const item of items) {
+        if (await matches(item)) {
+            return true;
+        }
+    }
+    return false;
 }
 exports.asyncSome = asyncSome;
 /**
@@ -578,43 +439,13 @@ exports.asyncSome = asyncSome;
  * return Promise<boolean>: `true` for a matching item, `false` otherwise.
  * @returns A `Promise<boolean>`, `true` if every item matches; `false` otherwise.
  */
-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];
-            }
-        });
-    });
+async function asyncEvery(items, matches) {
+    for (const item of items) {
+        if (!(await matches(item))) {
+            return false;
+        }
+    }
+    return true;
 }
 exports.asyncEvery = asyncEvery;
 /**
@@ -625,171 +456,125 @@ exports.asyncEvery = asyncEvery;
  * return Promise<boolean>: `true` for a matching item, `false` otherwise.
  * @returns A `Promise<T>` of matching items.
  */
-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];
-            }
-        });
-    });
+async function asyncFilter(items, matches) {
+    const results = [];
+    for (const item of items) {
+        if (await matches(item)) {
+            results.push(item);
+        }
+    }
+    return results;
 }
 exports.asyncFilter = asyncFilter;
-var isAWSDate = function (val) {
+const isAWSDate = (val) => {
     return !!/^\d{4}-\d{2}-\d{2}(Z|[+-]\d{2}:\d{2}($|:\d{2}))?$/.exec(val);
 };
 exports.isAWSDate = isAWSDate;
-var isAWSTime = function (val) {
+const isAWSTime = (val) => {
     return !!/^\d{2}:\d{2}(:\d{2}(.\d+)?)?(Z|[+-]\d{2}:\d{2}($|:\d{2}))?$/.exec(val);
 };
 exports.isAWSTime = isAWSTime;
-var isAWSDateTime = function (val) {
+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);
 };
 exports.isAWSDateTime = isAWSDateTime;
-var isAWSTimestamp = function (val) {
+const isAWSTimestamp = (val) => {
     return !!/^\d+$/.exec(String(val));
 };
 exports.isAWSTimestamp = isAWSTimestamp;
-var isAWSEmail = function (val) {
+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);
 };
 exports.isAWSEmail = isAWSEmail;
-var isAWSJSON = function (val) {
+const isAWSJSON = (val) => {
     try {
         JSON.parse(val);
         return true;
     }
-    catch (_c) {
+    catch {
         return false;
     }
 };
 exports.isAWSJSON = isAWSJSON;
-var isAWSURL = function (val) {
+const isAWSURL = (val) => {
     try {
         return !!new utils_1.AmplifyUrl(val);
     }
-    catch (_c) {
+    catch {
         return false;
     }
 };
 exports.isAWSURL = isAWSURL;
-var isAWSPhone = function (val) {
+const isAWSPhone = (val) => {
     return !!/^\+?\d[\d\s-]+$/.exec(val);
 };
 exports.isAWSPhone = isAWSPhone;
-var isAWSIPAddress = function (val) {
+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);
 };
 exports.isAWSIPAddress = isAWSIPAddress;
-var DeferredPromise = /** @class */ (function () {
-    function DeferredPromise() {
-        var self = this;
-        this.promise = new Promise(function (resolve, reject) {
+class DeferredPromise {
+    constructor() {
+        const self = this;
+        this.promise = new Promise((resolve, reject) => {
             self.resolve = resolve;
             self.reject = reject;
         });
     }
-    return DeferredPromise;
-}());
+}
 exports.DeferredPromise = DeferredPromise;
-var DeferredCallbackResolver = /** @class */ (function () {
-    function DeferredCallbackResolver(options) {
+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(types_1.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(types_1.LimitTimerRaceResolvedValues.LIMIT);
-    };
-    return DeferredCallbackResolver;
-}());
+    }
+}
 exports.DeferredCallbackResolver = DeferredCallbackResolver;
 /**
  * merge two sets of patches created by immer produce.
@@ -809,18 +594,18 @@ exports.DeferredCallbackResolver = DeferredCallbackResolver;
  * @return merged patches
  */
 function mergePatches(originalSource, oldPatches, newPatches) {
-    var patchesToMerge = oldPatches.concat(newPatches);
-    var patches;
-    (0, immer_1.produce)(originalSource, function (draft) {
+    const patchesToMerge = oldPatches.concat(newPatches);
+    let patches;
+    (0, immer_1.produce)(originalSource, draft => {
         (0, immer_1.applyPatches)(draft, patchesToMerge);
-    }, function (p) {
+    }, p => {
         patches = p;
     });
     return patches;
 }
 exports.mergePatches = mergePatches;
-var getStorename = function (namespace, modelName) {
-    var storeName = "".concat(namespace, "_").concat(modelName);
+const getStorename = (namespace, modelName) => {
+    const storeName = `${namespace}_${modelName}`;
     return storeName;
 };
 exports.getStorename = getStorename;
@@ -857,78 +642,75 @@ exports.getStorename = getStorename;
 
     See 'processCompositeKeys' test in util.test.ts for more examples
 */
-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
+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(types_1.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;
 };
 exports.processCompositeKeys = processCompositeKeys;
-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(types_1.isModelAttributeKey);
+const extractKeyIfExists = (modelDefinition) => {
+    const keyAttribute = modelDefinition?.attributes?.find(types_1.isModelAttributeKey);
     return keyAttribute;
 };
 exports.extractKeyIfExists = extractKeyIfExists;
-var extractPrimaryKeyFieldNames = function (modelDefinition) {
-    var keyAttribute = (0, exports.extractKeyIfExists)(modelDefinition);
+const extractPrimaryKeyFieldNames = (modelDefinition) => {
+    const keyAttribute = (0, exports.extractKeyIfExists)(modelDefinition);
     if (keyAttribute && (0, types_1.isModelAttributePrimaryKey)(keyAttribute)) {
         return keyAttribute.properties.fields;
     }
     return [exports.ID];
 };
 exports.extractPrimaryKeyFieldNames = extractPrimaryKeyFieldNames;
-var extractPrimaryKeyValues = function (model, keyFields) {
-    return keyFields.map(function (key) { return model[key]; });
+const extractPrimaryKeyValues = (model, keyFields) => {
+    return keyFields.map(key => model[key]);
 };
 exports.extractPrimaryKeyValues = extractPrimaryKeyValues;
-var extractPrimaryKeysAndValues = function (model, keyFields) {
-    var primaryKeysAndValues = {};
-    keyFields.forEach(function (key) { return (primaryKeysAndValues[key] = model[key]); });
+const extractPrimaryKeysAndValues = (model, keyFields) => {
+    const primaryKeysAndValues = {};
+    keyFields.forEach(key => (primaryKeysAndValues[key] = model[key]));
     return primaryKeysAndValues;
 };
 exports.extractPrimaryKeysAndValues = extractPrimaryKeysAndValues;
 // IdentifierFields<ManagedIdentifier>
 // Default behavior without explicit @primaryKey defined
-var isIdManaged = function (modelDefinition) {
-    var keyAttribute = (0, exports.extractKeyIfExists)(modelDefinition);
+const isIdManaged = (modelDefinition) => {
+    const keyAttribute = (0, exports.extractKeyIfExists)(modelDefinition);
     if (keyAttribute && (0, types_1.isModelAttributePrimaryKey)(keyAttribute)) {
         return false;
     }
@@ -937,27 +719,26 @@ var isIdManaged = function (modelDefinition) {
 exports.isIdManaged = isIdManaged;
 // IdentifierFields<OptionallyManagedIdentifier>
 // @primaryKey with explicit `id` in the PK. Single key or composite
-var isIdOptionallyManaged = function (modelDefinition) {
-    var keyAttribute = (0, exports.extractKeyIfExists)(modelDefinition);
+const isIdOptionallyManaged = (modelDefinition) => {
+    const keyAttribute = (0, exports.extractKeyIfExists)(modelDefinition);
     if (keyAttribute && (0, types_1.isModelAttributePrimaryKey)(keyAttribute)) {
         return keyAttribute.properties.fields[0] === exports.ID;
     }
     return false;
 };
 exports.isIdOptionallyManaged = isIdOptionallyManaged;
-var establishRelationAndKeys = function (namespace) {
-    var relationship = {};
-    var keys = {};
-    Object.keys(namespace.models).forEach(function (mKey) {
-        var e_6, _c;
+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,
@@ -967,15 +748,12 @@ var establishRelationAndKeys = function (namespace) {
                     associatedWith: fieldAttribute.association['associatedWith'],
                 });
                 if (connectionType === 'BELONGS_TO') {
-                    var targetNames = (0, exports.extractTargetNamesFromSrc)(fieldAttribute.association);
+                    const targetNames = (0, exports.extractTargetNamesFromSrc)(fieldAttribute.association);
                     if (targetNames) {
-                        var idxName_1 = (0, exports.indexNameFromKeys)(targetNames);
-                        var idxExists = relationship[mKey].indexes.find(function (_c) {
-                            var _d = __read(_c, 1), index = _d[0];
-                            return index === idxName_1;
-                        });
+                        const idxName = (0, exports.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]);
                         }
                     }
                 }
@@ -983,37 +761,21 @@ var establishRelationAndKeys = function (namespace) {
         });
         if (model.attributes) {
             keys[mKey].compositeKeys = (0, exports.processCompositeKeys)(model.attributes);
-            var _loop_1 = function (attribute) {
+            for (const attribute of model.attributes) {
                 if (!(0, types_1.isModelAttributeKey)(attribute)) {
-                    return "continue";
+                    continue;
                 }
-                var fields = attribute.properties.fields;
+                const { fields } = attribute.properties;
                 if ((0, types_1.isModelAttributePrimaryKey)(attribute)) {
                     keys[mKey].primaryKey = fields;
-                    return "continue";
+                    continue;
                 }
                 // create indexes for all other keys
-                var idxName = (0, exports.indexNameFromKeys)(fields);
-                var idxExists = relationship[mKey].indexes.find(function (_c) {
-                    var _d = __read(_c, 1), index = _d[0];
-                    return index === idxName;
-                });
+                const idxName = (0, exports.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
@@ -1030,11 +792,11 @@ var establishRelationAndKeys = function (namespace) {
     return [relationship, keys];
 };
 exports.establishRelationAndKeys = establishRelationAndKeys;
-var getIndex = function (rel, src) {
-    var indexName;
-    rel.some(function (relItem) {
+const getIndex = (rel, src) => {
+    let indexName;
+    rel.some((relItem) => {
         if (relItem.modelName === src) {
-            var targetNames = (0, exports.extractTargetNamesFromSrc)(relItem);
+            const targetNames = (0, exports.extractTargetNamesFromSrc)(relItem);
             indexName = targetNames && (0, exports.indexNameFromKeys)(targetNames);
             return true;
         }
@@ -1042,18 +804,15 @@ var getIndex = function (rel, src) {
     return indexName;
 };
 exports.getIndex = getIndex;
-var getIndexFromAssociation = function (indexes, src) {
-    var indexName;
+const getIndexFromAssociation = (indexes, src) => {
+    let indexName;
     if (Array.isArray(src)) {
         indexName = (0, exports.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];
 };
 exports.getIndexFromAssociation = getIndexFromAssociation;
@@ -1064,9 +823,9 @@ the single field `targetName` has been replaced with an array of `targetNames`.
  * @param src {RelationType | ModelAssociation | undefined}
  * @returns array of targetNames, or `undefined`
  */
-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;
+const extractTargetNamesFromSrc = (src) => {
+    const targetName = src?.targetName;
+    const targetNames = src?.targetNames;
     if (Array.isArray(targetNames)) {
         return targetNames;
     }
@@ -1080,26 +839,25 @@ var extractTargetNamesFromSrc = function (src) {
 exports.extractTargetNamesFromSrc = extractTargetNamesFromSrc;
 // Generates spinal-cased index name from an array of key field names
 // E.g. for keys `[id, title]` => 'id-title'
-var indexNameFromKeys = function (keys) {
-    return keys.reduce(function (prev, cur, idx) {
+const indexNameFromKeys = (keys) => {
+    return keys.reduce((prev, cur, idx) => {
         if (idx === 0) {
             return cur;
         }
-        return "".concat(prev).concat(exports.IDENTIFIER_KEY_SEPARATOR).concat(cur);
+        return `${prev}${exports.IDENTIFIER_KEY_SEPARATOR}${cur}`;
     }, '');
 };
 exports.indexNameFromKeys = indexNameFromKeys;
-var keysEqual = function (keysA, keysB) {
+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]);
 };
 exports.keysEqual = keysEqual;
 // Returns primary keys for a model
-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;
+const getIndexKeys = (namespace, modelName) => {
+    const keyPath = namespace?.keys?.[modelName]?.primaryKey;
     if (keyPath) {
         return keyPath;
     }
@@ -1119,15 +877,17 @@ exports.getIndexKeys = getIndexKeys;
  * @param definition modelDefinition to inspect.
  * @returns An object mapping `createdAt` and `updatedAt` to their field names.
  */
-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 = {
+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,
+    };
 };
 exports.getTimestampFields = getTimestampFields;