@aws-amplify/datastore 4.1.1 → 4.1.2

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -1,14 +1,10 @@
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
 import * as idb from 'idb';
-import { ModelInstanceCreator } from '../../datastore/datastore';
-import { ModelPredicateCreator } from '../../predicates';
 import {
-	InternalSchema,
 	isPredicateObj,
 	isPredicateGroup,
 	ModelInstanceMetadata,
 	ModelPredicate,
-	NamespaceResolver,
 	OpType,
 	PaginationInput,
 	PersistentModel,
@@ -20,8 +16,6 @@ import {
 } from '../../types';
 import {
 	getIndex,
-	getIndexFromAssociation,
-	isModelConstructor,
 	isPrivateMode,
 	traverseModel,
 	validatePredicate,
@@ -29,11 +23,9 @@ import {
 	NAMESPACES,
 	keysEqual,
 	getStorename,
-	getIndexKeys,
-	extractPrimaryKeyValues,
 	isSafariCompatabilityMode,
 } from '../../util';
-import { Adapter } from './index';
+import { StorageAdapterBase } from './StorageAdapterBase';
 
 const logger = new Logger('DataStore');
 
@@ -59,229 +51,135 @@ const logger = new Logger('DataStore');
  *
  */
 const MULTI_OR_CONDITION_SCAN_BREAKPOINT = 7;
+//
+const DB_VERSION = 3;
 
-const DB_NAME = 'amplify-datastore';
-class IndexedDBAdapter implements Adapter {
-	private schema!: InternalSchema;
-	private namespaceResolver!: NamespaceResolver;
-	private modelInstanceCreator!: ModelInstanceCreator;
-	private getModelConstructorByModelName?: (
-		namsespaceName: NAMESPACES,
-		modelName: string
-	) => PersistentModelConstructor<any>;
-	private db!: idb.IDBPDatabase;
-	private initPromise!: Promise<void>;
-	private resolve!: (value?: any) => void;
-	private reject!: (value?: any) => void;
-	private dbName: string = DB_NAME;
+class IndexedDBAdapter extends StorageAdapterBase {
+	protected db!: idb.IDBPDatabase;
 	private safariCompatabilityMode: boolean = false;
 
-	private getStorenameForModel(
-		modelConstructor: PersistentModelConstructor<any>
-	) {
-		const namespace = this.namespaceResolver(modelConstructor);
-		const { name: modelName } = modelConstructor;
-
-		return getStorename(namespace, modelName);
-	}
-
-	// Retrieves primary key values from a model
-	private getIndexKeyValuesFromModel<T extends PersistentModel>(
-		model: T
-	): string[] {
-		const modelConstructor = Object.getPrototypeOf(model)
-			.constructor as PersistentModelConstructor<T>;
-		const namespaceName = this.namespaceResolver(modelConstructor);
-
-		const keys = getIndexKeys(
-			this.schema.namespaces[namespaceName],
-			modelConstructor.name
-		);
-
-		return extractPrimaryKeyValues(model, keys);
+	// checks are called by StorageAdapterBase class
+	protected async preSetUpChecks() {
+		await this.checkPrivate();
+		await this.setSafariCompatabilityMode();
 	}
 
-	private async checkPrivate() {
-		const isPrivate = await isPrivateMode().then(isPrivate => {
-			return isPrivate;
-		});
-		if (isPrivate) {
-			logger.error("IndexedDB not supported in this browser's private mode");
-			return Promise.reject(
-				"IndexedDB not supported in this browser's private mode"
-			);
-		} else {
-			return Promise.resolve();
-		}
+	protected async preOpCheck() {
+		await this.checkPrivate();
 	}
 
 	/**
-	 * Whether the browser's implementation of IndexedDB is coercing single-field
-	 * indexes to a scalar key.
+	 * Initialize IndexedDB database
+	 * Create new DB if one doesn't exist
+	 * Upgrade outdated DB
 	 *
-	 * If this returns `true`, we need to treat indexes containing a single field
-	 * as scalars.
+	 * Called by `StorageAdapterBase.setUp()`
 	 *
-	 * See PR description for reference:
-	 * https://github.com/aws-amplify/amplify-js/pull/10527
+	 * @returns IDB Database instance
 	 */
-	private async setSafariCompatabilityMode() {
-		this.safariCompatabilityMode = await isSafariCompatabilityMode();
+	protected async initDb(): Promise<idb.IDBPDatabase> {
+		return await idb.openDB(this.dbName, DB_VERSION, {
+			upgrade: async (db, oldVersion, newVersion, txn) => {
+				// create new database
+				if (oldVersion === 0) {
+					Object.keys(this.schema.namespaces).forEach(namespaceName => {
+						const namespace = this.schema.namespaces[namespaceName];
+
+						Object.keys(namespace.models).forEach(modelName => {
+							const storeName = getStorename(namespaceName, modelName);
+							this.createObjectStoreForModel(
+								db,
+								namespaceName,
+								storeName,
+								modelName
+							);
+						});
+					});
 
-		if (this.safariCompatabilityMode === true) {
-			logger.debug('IndexedDB Adapter is running in Safari Compatability Mode');
-		}
-	}
+					return;
+				}
 
-	private getNamespaceAndModelFromStorename(storeName: string) {
-		const [namespaceName, ...modelNameArr] = storeName.split('_');
-		return {
-			namespaceName,
-			modelName: modelNameArr.join('_'),
-		};
-	}
+				// migrate existing database to latest schema
+				if ((oldVersion === 1 || oldVersion === 2) && newVersion === 3) {
+					try {
+						for (const storeName of txn.objectStoreNames) {
+							const origStore = txn.objectStore(storeName);
 
-	async setUp(
-		theSchema: InternalSchema,
-		namespaceResolver: NamespaceResolver,
-		modelInstanceCreator: ModelInstanceCreator,
-		getModelConstructorByModelName: (
-			namsespaceName: NAMESPACES,
-			modelName: string
-		) => PersistentModelConstructor<any>,
-		sessionId?: string
-	) {
-		await this.checkPrivate();
-		await this.setSafariCompatabilityMode();
+							// rename original store
+							const tmpName = `tmp_${storeName}`;
+							origStore.name = tmpName;
 
-		if (!this.initPromise) {
-			this.initPromise = new Promise((res, rej) => {
-				this.resolve = res;
-				this.reject = rej;
-			});
-		} else {
-			await this.initPromise;
-		}
-		if (sessionId) {
-			this.dbName = `${DB_NAME}-${sessionId}`;
-		}
-		this.schema = theSchema;
-		this.namespaceResolver = namespaceResolver;
-		this.modelInstanceCreator = modelInstanceCreator;
-		this.getModelConstructorByModelName = getModelConstructorByModelName;
-
-		try {
-			if (!this.db) {
-				const VERSION = 3;
-				this.db = await idb.openDB(this.dbName, VERSION, {
-					upgrade: async (db, oldVersion, newVersion, txn) => {
-						if (oldVersion === 0) {
-							Object.keys(theSchema.namespaces).forEach(namespaceName => {
-								const namespace = theSchema.namespaces[namespaceName];
-
-								Object.keys(namespace.models).forEach(modelName => {
-									const storeName = getStorename(namespaceName, modelName);
-									this.createObjectStoreForModel(
-										db,
-										namespaceName,
-										storeName,
-										modelName
-									);
-								});
-							});
+							const { namespaceName, modelName } =
+								this.getNamespaceAndModelFromStorename(storeName);
 
-							return;
-						}
+							const modelInCurrentSchema =
+								modelName in this.schema.namespaces[namespaceName].models;
+
+							if (!modelInCurrentSchema) {
+								// delete original
+								db.deleteObjectStore(tmpName);
+								continue;
+							}
 
-						if ((oldVersion === 1 || oldVersion === 2) && newVersion === 3) {
-							try {
-								for (const storeName of txn.objectStoreNames) {
-									const origStore = txn.objectStore(storeName);
+							const newStore = this.createObjectStoreForModel(
+								db,
+								namespaceName,
+								storeName,
+								modelName
+							);
 
-									// rename original store
-									const tmpName = `tmp_${storeName}`;
-									origStore.name = tmpName;
+							let cursor = await origStore.openCursor();
+							let count = 0;
 
-									const { namespaceName, modelName } =
-										this.getNamespaceAndModelFromStorename(storeName);
+							// Copy data from original to new
+							while (cursor && cursor.value) {
+								// we don't pass key, since they are all new entries in the new store
+								await newStore.put(cursor.value);
 
-									const modelInCurrentSchema =
-										modelName in this.schema.namespaces[namespaceName].models;
+								cursor = await cursor.continue();
+								count++;
+							}
 
-									if (!modelInCurrentSchema) {
-										// delete original
-										db.deleteObjectStore(tmpName);
-										continue;
-									}
+							// delete original
+							db.deleteObjectStore(tmpName);
+
+							logger.debug(`${count} ${storeName} records migrated`);
+						}
 
-									const newStore = this.createObjectStoreForModel(
+						// add new models created after IndexedDB, but before migration
+						// this case may happen when a user has not opened an app for
+						// some time and a new model is added during that time
+						Object.keys(this.schema.namespaces).forEach(namespaceName => {
+							const namespace = this.schema.namespaces[namespaceName];
+							const objectStoreNames = new Set(txn.objectStoreNames);
+
+							Object.keys(namespace.models)
+								.map(modelName => {
+									return [modelName, getStorename(namespaceName, modelName)];
+								})
+								.filter(([, storeName]) => !objectStoreNames.has(storeName))
+								.forEach(([modelName, storeName]) => {
+									this.createObjectStoreForModel(
 										db,
 										namespaceName,
 										storeName,
 										modelName
 									);
-
-									let cursor = await origStore.openCursor();
-									let count = 0;
-
-									// Copy data from original to new
-									while (cursor && cursor.value) {
-										// we don't pass key, since they are all new entries in the new store
-										await newStore.put(cursor.value);
-
-										cursor = await cursor.continue();
-										count++;
-									}
-
-									// delete original
-									db.deleteObjectStore(tmpName);
-
-									logger.debug(`${count} ${storeName} records migrated`);
-								}
-
-								// add new models created after IndexedDB, but before migration
-								// this case may happen when a user has not opened an app for
-								// some time and a new model is added during that time
-								Object.keys(theSchema.namespaces).forEach(namespaceName => {
-									const namespace = theSchema.namespaces[namespaceName];
-									const objectStoreNames = new Set(txn.objectStoreNames);
-
-									Object.keys(namespace.models)
-										.map(modelName => {
-											return [
-												modelName,
-												getStorename(namespaceName, modelName),
-											];
-										})
-										.filter(([, storeName]) => !objectStoreNames.has(storeName))
-										.forEach(([modelName, storeName]) => {
-											this.createObjectStoreForModel(
-												db,
-												namespaceName,
-												storeName,
-												modelName
-											);
-										});
 								});
-							} catch (error) {
-								logger.error('Error migrating IndexedDB data', error);
-								txn.abort();
-								throw error;
-							}
-
-							return;
-						}
-					},
-				});
+						});
+					} catch (error) {
+						logger.error('Error migrating IndexedDB data', error);
+						txn.abort();
+						throw error;
+					}
 
-				this.resolve();
-			}
-		} catch (error) {
-			this.reject(error);
-		}
+					return;
+				}
+			},
+		});
 	}
 
-	private async _get<T>(
+	protected async _get<T>(
 		storeOrStoreName: idb.IDBPObjectStore | string,
 		keyArr: string[]
 	): Promise<T> {
@@ -297,7 +195,17 @@ class IndexedDBAdapter implements Adapter {
 
 		const result = await index.get(this.canonicalKeyPath(keyArr));
 
-		return result;
+		return <T>result;
+	}
+
+	async clear(): Promise<void> {
+		await this.checkPrivate();
+
+		this.db?.close();
+		await idb.deleteDB(this.dbName);
+
+		this.db = undefined!;
+		this.initPromise = undefined!;
 	}
 
 	async save<T extends PersistentModel>(
@@ -305,77 +213,30 @@ class IndexedDBAdapter implements Adapter {
 		condition?: ModelPredicate<T>
 	): Promise<[T, OpType.INSERT | OpType.UPDATE][]> {
 		await this.checkPrivate();
-		const modelConstructor = Object.getPrototypeOf(model)
-			.constructor as PersistentModelConstructor<T>;
-		const storeName = this.getStorenameForModel(modelConstructor);
-		const namespaceName = this.namespaceResolver(modelConstructor);
-
-		const connectedModels = traverseModel(
-			modelConstructor.name,
-			model,
-			this.schema.namespaces[namespaceName],
-			this.modelInstanceCreator,
-			this.getModelConstructorByModelName!
-		);
 
-		const set = new Set<string>();
-		const connectionStoreNames = Object.values(connectedModels).map(
-			({ modelName, item, instance }) => {
-				const storeName = getStorename(namespaceName, modelName);
-				set.add(storeName);
-				const keys = getIndexKeys(
-					this.schema.namespaces[namespaceName],
-					modelName
-				);
-				return { storeName, item, instance, keys };
-			}
-		);
+		const { storeName, set, connectionStoreNames, modelKeyValues } =
+			this.saveMetadata(model);
 
 		const tx = this.db.transaction(
 			[storeName, ...Array.from(set.values())],
 			'readwrite'
 		);
-		const store = tx.objectStore(storeName);
-
-		const keyValues = this.getIndexKeyValuesFromModel(model);
 
-		const fromDB = await this._get(store, keyValues);
-
-		if (condition && fromDB) {
-			const predicates = ModelPredicateCreator.getPredicates(condition);
-			const { predicates: predicateObjs, type } = predicates || {};
-
-			const isValid = validatePredicate(
-				fromDB as any,
-				type as any,
-				predicateObjs as any
-			);
-
-			if (!isValid) {
-				const msg = 'Conditional update failed';
-				logger.error(msg, { model: fromDB, condition: predicateObjs });
+		const store = tx.objectStore(storeName);
+		const fromDB = await this._get(store, modelKeyValues);
 
-				throw new Error(msg);
-			}
-		}
+		this.validateSaveCondition(condition, fromDB);
 
 		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
 		for await (const resItem of connectionStoreNames) {
 			const { storeName, item, instance, keys } = resItem;
 			const store = tx.objectStore(storeName);
 
-			const itemKeyValues = keys.map(key => {
-				const value = item[key];
-				return value;
-			});
+			const itemKeyValues: string[] = keys.map(key => item[key]);
 
 			const fromDB = <T>await this._get(store, itemKeyValues);
-			const opType: OpType =
-				fromDB === undefined ? OpType.INSERT : OpType.UPDATE;
-
-			const modelKeyValues = this.getIndexKeyValuesFromModel(model);
+			const opType: OpType = fromDB ? OpType.UPDATE : OpType.INSERT;
 
-			// Even if the parent is an INSERT, the child might not be, so we need to get its key
 			if (
 				keysEqual(itemKeyValues, modelKeyValues) ||
 				opType === OpType.INSERT
@@ -387,60 +248,25 @@ class IndexedDBAdapter implements Adapter {
 				result.push([instance, opType]);
 			}
 		}
-
 		await tx.done;
 
 		return result;
 	}
 
-	private async load<T>(
-		namespaceName: NAMESPACES,
-		srcModelName: string,
-		records: T[]
-	): Promise<T[]> {
-		const namespace = this.schema.namespaces[namespaceName];
-		const relations = namespace.relationships![srcModelName].relationTypes;
-		const connectionStoreNames = relations.map(({ modelName }) => {
-			return getStorename(namespaceName, modelName);
-		});
-		const modelConstructor = this.getModelConstructorByModelName!(
-			namespaceName,
-			srcModelName
-		);
-
-		if (connectionStoreNames.length === 0) {
-			return records.map(record =>
-				this.modelInstanceCreator(modelConstructor, record)
-			);
-		}
-
-		return records.map(record =>
-			this.modelInstanceCreator(modelConstructor, record)
-		);
-	}
-
 	async query<T extends PersistentModel>(
 		modelConstructor: PersistentModelConstructor<T>,
 		predicate?: ModelPredicate<T>,
 		pagination?: PaginationInput<T>
 	): Promise<T[]> {
 		await this.checkPrivate();
-		const storeName = this.getStorenameForModel(modelConstructor);
-		const namespaceName = this.namespaceResolver(
-			modelConstructor
-		) as NAMESPACES;
-
-		const predicates =
-			predicate && ModelPredicateCreator.getPredicates(predicate);
-		const keyPath = getIndexKeys(
-			this.schema.namespaces[namespaceName],
-			modelConstructor.name
-		);
-		const queryByKey =
-			predicates && this.keyValueFromPredicate(predicates, keyPath);
-
-		const hasSort = pagination && pagination.sort;
-		const hasPagination = pagination && pagination.limit;
+		const {
+			storeName,
+			namespaceName,
+			queryByKey,
+			predicates,
+			hasSort,
+			hasPagination,
+		} = this.queryMetadata(modelConstructor, predicate, pagination);
 
 		const records: T[] = (await (async () => {
 			//
@@ -459,24 +285,307 @@ class IndexedDBAdapter implements Adapter {
 				return record ? [record] : [];
 			}
 
-			if (predicates) {
-				const filtered = await this.filterOnPredicate(storeName, predicates);
-				return this.inMemoryPagination(filtered, pagination);
-			}
+			if (predicates) {
+				const filtered = await this.filterOnPredicate(storeName, predicates);
+				return this.inMemoryPagination(filtered, pagination);
+			}
+
+			if (hasSort) {
+				const all = await this.getAll(storeName);
+				return this.inMemoryPagination(all, pagination);
+			}
+
+			if (hasPagination) {
+				return this.enginePagination(storeName, pagination);
+			}
+
+			return this.getAll(storeName);
+		})()) as T[];
+
+		return await this.load(namespaceName, modelConstructor.name, records);
+	}
+
+	async queryOne<T extends PersistentModel>(
+		modelConstructor: PersistentModelConstructor<T>,
+		firstOrLast: QueryOne = QueryOne.FIRST
+	): Promise<T | undefined> {
+		await this.checkPrivate();
+		const storeName = this.getStorenameForModel(modelConstructor);
+
+		const cursor = await this.db
+			.transaction([storeName], 'readonly')
+			.objectStore(storeName)
+			.openCursor(undefined, firstOrLast === QueryOne.FIRST ? 'next' : 'prev');
+
+		const result = cursor ? <T>cursor.value : undefined;
+
+		return result && this.modelInstanceCreator(modelConstructor, result);
+	}
+
+	async batchSave<T extends PersistentModel>(
+		modelConstructor: PersistentModelConstructor<any>,
+		items: ModelInstanceMetadata[]
+	): Promise<[T, OpType][]> {
+		await this.checkPrivate();
+
+		if (items.length === 0) {
+			return [];
+		}
+
+		const modelName = modelConstructor.name;
+		const namespaceName = this.namespaceResolver(modelConstructor);
+		const storeName = this.getStorenameForModel(modelConstructor);
+		const result: [T, OpType][] = [];
+
+		const txn = this.db.transaction(storeName, 'readwrite');
+		const store = txn.store;
+
+		for (const item of items) {
+			const model = this.modelInstanceCreator(modelConstructor, item);
+
+			const connectedModels = traverseModel(
+				modelName,
+				model,
+				this.schema.namespaces[namespaceName],
+				this.modelInstanceCreator,
+				this.getModelConstructorByModelName!
+			);
+
+			const keyValues = this.getIndexKeyValuesFromModel(model);
+			const { _deleted } = item;
+
+			const index = store.index('byPk');
+
+			const key = await index.getKey(this.canonicalKeyPath(keyValues));
+
+			if (!_deleted) {
+				const { instance } = connectedModels.find(({ instance }) => {
+					const instanceKeyValues = this.getIndexKeyValuesFromModel(instance);
+					return keysEqual(instanceKeyValues, keyValues);
+				})!;
+
+				result.push([
+					<T>(<unknown>instance),
+					key ? OpType.UPDATE : OpType.INSERT,
+				]);
+				await store.put(instance, key);
+			} else {
+				result.push([<T>(<unknown>item), OpType.DELETE]);
+
+				if (key) {
+					await store.delete(key);
+				}
+			}
+		}
+
+		await txn.done;
+
+		return result;
+	}
+
+	protected async deleteItem<T extends PersistentModel>(
+		deleteQueue?: {
+			storeName: string;
+			items: T[] | IDBValidKey[];
+		}[]
+	) {
+		const connectionStoreNames = deleteQueue!.map(({ storeName }) => {
+			return storeName;
+		});
+
+		const tx = this.db.transaction([...connectionStoreNames], 'readwrite');
+		for await (const deleteItem of deleteQueue!) {
+			const { storeName, items } = deleteItem;
+			const store = tx.objectStore(storeName);
+
+			for await (const item of items) {
+				if (item) {
+					let key: IDBValidKey | undefined;
+
+					if (typeof item === 'object') {
+						const keyValues = this.getIndexKeyValuesFromModel(item as T);
+						key = await store
+							.index('byPk')
+							.getKey(this.canonicalKeyPath(keyValues));
+					} else {
+						const itemKey = item.toString();
+						key = await store.index('byPk').getKey(itemKey);
+					}
+
+					if (key !== undefined) {
+						await store.delete(key);
+					}
+				}
+			}
+		}
+	}
+
+	/**
+	 * Gets related Has One record for `model`
+	 *
+	 * @param model
+	 * @param srcModel
+	 * @param namespace
+	 * @param rel
+	 * @returns
+	 */
+	protected async getHasOneChild<T extends PersistentModel>(
+		model: T,
+		srcModel: string,
+		namespace: NAMESPACES,
+		rel: RelationType
+	) {
+		const hasOneIndex = 'byPk';
+		const { modelName, targetNames } = rel;
+		const storeName = getStorename(namespace, modelName);
+
+		const values = targetNames!
+			.filter(targetName => model[targetName] ?? false)
+			.map(targetName => model[targetName]);
+
+		if (values.length === 0) return;
+
+		const recordToDelete = <T>(
+			await this.db
+				.transaction(storeName, 'readwrite')
+				.objectStore(storeName)
+				.index(hasOneIndex)
+				.get(this.canonicalKeyPath(values))
+		);
+
+		return recordToDelete;
+	}
+
+	/**
+	 * Backwards compatability for pre-CPK codegen
+	 * TODO - deprecate this in v6; will need to re-gen MIPR for older unit
+	 * tests that hit this path
+	 */
+	protected async getHasOneChildLegacy<T extends PersistentModel>(
+		model: T,
+		srcModel: string,
+		namespace: NAMESPACES,
+		rel: RelationType
+	) {
+		const hasOneIndex = 'byPk';
+		const { modelName, targetName } = rel;
+		const storeName = getStorename(namespace, modelName);
+
+		let index;
+		let values: string[];
+
+		if (targetName && targetName in model) {
+			index = hasOneIndex;
+			const value = model[targetName];
+			if (value === null) {
+				return;
+			}
+			values = [value];
+		} else {
+			// backwards compatability for older versions of codegen that did not emit targetName for HAS_ONE relations
+			index = getIndex(
+				this.schema.namespaces[namespace].relationships![modelName]
+					.relationTypes,
+				srcModel
+			);
+			values = this.getIndexKeyValuesFromModel(model);
+		}
+
+		if (!values || !index) return;
+
+		const recordToDelete = <T>(
+			await this.db
+				.transaction(storeName, 'readwrite')
+				.objectStore(storeName)
+				.index(index)
+				.get(this.canonicalKeyPath(values))
+		);
+
+		return recordToDelete;
+	}
+
+	/**
+	 * Gets related Has Many records by given `storeName`, `index`, and `keyValues`
+	 *
+	 * @param storeName
+	 * @param index
+	 * @param keyValues
+	 * @returns
+	 */
+	protected async getHasManyChildren<T extends PersistentModel>(
+		storeName: string,
+		index: string,
+		keyValues: string[]
+	): Promise<T[]> {
+		const childRecords = await this.db
+			.transaction(storeName, 'readwrite')
+			.objectStore(storeName)
+			.index(index as string)
+			.getAll(this.canonicalKeyPath(keyValues));
+
+		return childRecords;
+	}
+
+	//#region platform-specific helper methods
+
+	private async checkPrivate() {
+		const isPrivate = await isPrivateMode().then(isPrivate => {
+			return isPrivate;
+		});
+		if (isPrivate) {
+			logger.error("IndexedDB not supported in this browser's private mode");
+			return Promise.reject(
+				"IndexedDB not supported in this browser's private mode"
+			);
+		} else {
+			return Promise.resolve();
+		}
+	}
+
+	/**
+	 * Whether the browser's implementation of IndexedDB is coercing single-field
+	 * indexes to a scalar key.
+	 *
+	 * If this returns `true`, we need to treat indexes containing a single field
+	 * as scalars.
+	 *
+	 * See PR description for reference:
+	 * https://github.com/aws-amplify/amplify-js/pull/10527
+	 */
+	private async setSafariCompatabilityMode() {
+		this.safariCompatabilityMode = await isSafariCompatabilityMode();
+
+		if (this.safariCompatabilityMode === true) {
+			logger.debug('IndexedDB Adapter is running in Safari Compatability Mode');
+		}
+	}
 
-			if (hasSort) {
-				const all = await this.getAll(storeName);
-				return this.inMemoryPagination(all, pagination);
-			}
+	private getNamespaceAndModelFromStorename(storeName: string) {
+		const [namespaceName, ...modelNameArr] = storeName.split('_');
+		return {
+			namespaceName,
+			modelName: modelNameArr.join('_'),
+		};
+	}
 
-			if (hasPagination) {
-				return this.enginePagination(storeName, pagination);
-			}
+	private createObjectStoreForModel(
+		db: idb.IDBPDatabase,
+		namespaceName: string,
+		storeName: string,
+		modelName: string
+	): idb.IDBPObjectStore {
+		const store = db.createObjectStore(storeName, {
+			autoIncrement: true,
+		});
 
-			return this.getAll(storeName);
-		})()) as T[];
+		const { indexes } =
+			this.schema.namespaces[namespaceName].relationships![modelName];
 
-		return await this.load(namespaceName, modelConstructor.name, records);
+		indexes.forEach(([idxName, keyPath, options]) => {
+			store.createIndex(idxName, keyPath, options);
+		});
+
+		return store;
 	}
 
 	private async getByKey<T extends PersistentModel>(
@@ -492,38 +601,6 @@ class IndexedDBAdapter implements Adapter {
 		return await this.db.getAll(storeName);
 	}
 
-	private keyValueFromPredicate<T extends PersistentModel>(
-		predicates: PredicatesGroup<T>,
-		keyPath: string[]
-	): string[] | undefined {
-		const { predicates: predicateObjs } = predicates;
-
-		if (predicateObjs.length !== keyPath.length) {
-			return;
-		}
-
-		const keyValues = [] as any[];
-
-		for (const key of keyPath) {
-			const predicateObj = predicateObjs.find(
-				p =>
-					// it's a relevant predicate object only if it's an equality
-					// operation for a key field from the key:
-					isPredicateObj(p) &&
-					p.field === key &&
-					p.operator === 'eq' &&
-					// it's only valid if it's not nullish.
-					// (IDB will throw a fit if it's nullish.)
-					p.operand !== null &&
-					p.operand !== undefined
-			) as PredicateObject<T>;
-
-			predicateObj && keyValues.push(predicateObj.operand);
-		}
-
-		return keyValues.length === keyPath.length ? keyValues : undefined;
-	}
-
 	/**
 	 * Tries to generate an index fetcher for the given predicates. Assumes
 	 * that the given predicate conditions are contained by an AND group and
@@ -789,447 +866,6 @@ class IndexedDBAdapter implements Adapter {
 		return result;
 	}
 
-	async queryOne<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<T>,
-		firstOrLast: QueryOne = QueryOne.FIRST
-	): Promise<T | undefined> {
-		await this.checkPrivate();
-		const storeName = this.getStorenameForModel(modelConstructor);
-
-		const cursor = await this.db
-			.transaction([storeName], 'readonly')
-			.objectStore(storeName)
-			.openCursor(undefined, firstOrLast === QueryOne.FIRST ? 'next' : 'prev');
-
-		const result = cursor ? <T>cursor.value : undefined;
-
-		return result && this.modelInstanceCreator(modelConstructor, result);
-	}
-
-	async delete<T extends PersistentModel>(
-		modelOrModelConstructor: T | PersistentModelConstructor<T>,
-		condition?: ModelPredicate<T>
-	): Promise<[T[], T[]]> {
-		await this.checkPrivate();
-		const deleteQueue: { storeName: string; items: T[] }[] = [];
-
-		if (isModelConstructor(modelOrModelConstructor)) {
-			const modelConstructor =
-				modelOrModelConstructor as PersistentModelConstructor<T>;
-			const nameSpace = this.namespaceResolver(modelConstructor) as NAMESPACES;
-
-			const storeName = this.getStorenameForModel(modelConstructor);
-
-			const models = await this.query(modelConstructor, condition);
-			const relations =
-				this.schema.namespaces![nameSpace].relationships![modelConstructor.name]
-					.relationTypes;
-
-			if (condition !== undefined) {
-				await this.deleteTraverse(
-					relations,
-					models,
-					modelConstructor.name,
-					nameSpace,
-					deleteQueue
-				);
-
-				await this.deleteItem(deleteQueue);
-
-				const deletedModels = deleteQueue.reduce(
-					(acc, { items }) => acc.concat(items),
-					<T[]>[]
-				);
-
-				return [models, deletedModels];
-			} else {
-				await this.deleteTraverse(
-					relations,
-					models,
-					modelConstructor.name,
-					nameSpace,
-					deleteQueue
-				);
-
-				// Delete all
-				await this.db
-					.transaction([storeName], 'readwrite')
-					.objectStore(storeName)
-					.clear();
-
-				const deletedModels = deleteQueue.reduce(
-					(acc, { items }) => acc.concat(items),
-					<T[]>[]
-				);
-
-				return [models, deletedModels];
-			}
-		} else {
-			const model = modelOrModelConstructor as T;
-
-			const modelConstructor = Object.getPrototypeOf(model)
-				.constructor as PersistentModelConstructor<T>;
-			const namespaceName = this.namespaceResolver(
-				modelConstructor
-			) as NAMESPACES;
-
-			const storeName = this.getStorenameForModel(modelConstructor);
-
-			if (condition) {
-				const tx = this.db.transaction([storeName], 'readwrite');
-				const store = tx.objectStore(storeName);
-				const keyValues = this.getIndexKeyValuesFromModel(model);
-
-				const fromDB = await this._get(store, keyValues);
-
-				if (fromDB === undefined) {
-					const msg = 'Model instance not found in storage';
-					logger.warn(msg, { model });
-
-					return [[model], []];
-				}
-
-				const predicates = ModelPredicateCreator.getPredicates(condition);
-				const { predicates: predicateObjs, type } =
-					predicates as PredicatesGroup<T>;
-
-				const isValid = validatePredicate(fromDB as T, type, predicateObjs);
-
-				if (!isValid) {
-					const msg = 'Conditional update failed';
-					logger.error(msg, { model: fromDB, condition: predicateObjs });
-
-					throw new Error(msg);
-				}
-				await tx.done;
-
-				const relations =
-					this.schema.namespaces[namespaceName].relationships![
-						modelConstructor.name
-					].relationTypes;
-
-				await this.deleteTraverse(
-					relations,
-					[model],
-					modelConstructor.name,
-					namespaceName,
-					deleteQueue
-				);
-			} else {
-				const relations =
-					this.schema.namespaces[namespaceName].relationships![
-						modelConstructor.name
-					].relationTypes;
-
-				await this.deleteTraverse(
-					relations,
-					[model],
-					modelConstructor.name,
-					namespaceName,
-					deleteQueue
-				);
-			}
-
-			await this.deleteItem(deleteQueue);
-
-			const deletedModels = deleteQueue.reduce(
-				(acc, { items }) => acc.concat(items),
-				<T[]>[]
-			);
-
-			return [[model], deletedModels];
-		}
-	}
-
-	private async deleteItem<T extends PersistentModel>(
-		deleteQueue?: {
-			storeName: string;
-			items: T[] | IDBValidKey[];
-		}[]
-	) {
-		const connectionStoreNames = deleteQueue!.map(({ storeName }) => {
-			return storeName;
-		});
-
-		const tx = this.db.transaction([...connectionStoreNames], 'readwrite');
-		for await (const deleteItem of deleteQueue!) {
-			const { storeName, items } = deleteItem;
-			const store = tx.objectStore(storeName);
-
-			for await (const item of items) {
-				if (item) {
-					let key: IDBValidKey | undefined;
-
-					if (typeof item === 'object') {
-						const keyValues = this.getIndexKeyValuesFromModel(item as T);
-						key = await store
-							.index('byPk')
-							.getKey(this.canonicalKeyPath(keyValues));
-					} else {
-						const itemKey = item.toString();
-						key = await store.index('byPk').getKey(itemKey);
-					}
-
-					if (key !== undefined) {
-						await store.delete(key);
-					}
-				}
-			}
-		}
-	}
-
-	private async deleteTraverse<T extends PersistentModel>(
-		relations: RelationType[],
-		models: T[],
-		srcModel: string,
-		nameSpace: NAMESPACES,
-		deleteQueue: { storeName: string; items: T[] }[]
-	): Promise<void> {
-		for await (const rel of relations) {
-			const {
-				relationType,
-				modelName,
-				targetName,
-				targetNames,
-				associatedWith,
-			} = rel;
-
-			const storeName = getStorename(nameSpace, modelName);
-
-			switch (relationType) {
-				case 'HAS_ONE':
-					for await (const model of models) {
-						const hasOneIndex = 'byPk';
-
-						if (targetNames?.length) {
-							// CPK codegen
-							const values = targetNames
-								.filter(targetName => model[targetName] ?? false)
-								.map(targetName => model[targetName]);
-
-							if (values.length === 0) break;
-
-							const recordToDelete = <T>(
-								await this.db
-									.transaction(storeName, 'readwrite')
-									.objectStore(storeName)
-									.index(hasOneIndex)
-									.get(this.canonicalKeyPath(values))
-							);
-
-							await this.deleteTraverse(
-								this.schema.namespaces[nameSpace].relationships![modelName]
-									.relationTypes,
-								recordToDelete ? [recordToDelete] : [],
-								modelName,
-								nameSpace,
-								deleteQueue
-							);
-							break;
-						} else {
-							// PRE-CPK codegen
-							let index;
-							let values: string[];
-
-							if (targetName && targetName in model) {
-								index = hasOneIndex;
-								const value = model[targetName];
-								if (value === null) break;
-								values = [value];
-							} else {
-								// backwards compatability for older versions of codegen that did not emit targetName for HAS_ONE relations
-								// TODO: can we deprecate this? it's been ~2 years since codegen started including targetName for HAS_ONE
-								// If we deprecate, we'll need to re-gen the MIPR in __tests__/schema.ts > newSchema
-								// otherwise some unit tests will fail
-								index = getIndex(
-									this.schema.namespaces[nameSpace].relationships![modelName]
-										.relationTypes,
-									srcModel
-								);
-								values = this.getIndexKeyValuesFromModel(model);
-							}
-
-							if (!values || !index) break;
-
-							const recordToDelete = <T>(
-								await this.db
-									.transaction(storeName, 'readwrite')
-									.objectStore(storeName)
-									.index(index)
-									.get(this.canonicalKeyPath(values))
-							);
-
-							// instantiate models before passing to deleteTraverse
-							// necessary for extracting PK values via getIndexKeyValuesFromModel
-							const modelsToDelete = recordToDelete
-								? await this.load(nameSpace, modelName, [recordToDelete])
-								: [];
-
-							await this.deleteTraverse(
-								this.schema.namespaces[nameSpace].relationships![modelName]
-									.relationTypes,
-								modelsToDelete,
-								modelName,
-								nameSpace,
-								deleteQueue
-							);
-						}
-					}
-					break;
-				case 'HAS_MANY':
-					for await (const model of models) {
-						const index =
-							// explicit bi-directional @hasMany and @manyToMany
-							getIndex(
-								this.schema.namespaces[nameSpace].relationships![modelName]
-									.relationTypes,
-								srcModel
-							) ||
-							// uni and/or implicit @hasMany
-							getIndexFromAssociation(
-								this.schema.namespaces[nameSpace].relationships![modelName]
-									.indexes,
-								associatedWith!
-							);
-						const keyValues = this.getIndexKeyValuesFromModel(model);
-
-						const childRecords = await this.db
-							.transaction(storeName, 'readwrite')
-							.objectStore(storeName)
-							.index(index as string)
-							.getAll(this.canonicalKeyPath(keyValues));
-
-						// instantiate models before passing to deleteTraverse
-						// necessary for extracting PK values via getIndexKeyValuesFromModel
-						const childModels = await this.load(
-							nameSpace,
-							modelName,
-							childRecords
-						);
-
-						await this.deleteTraverse(
-							this.schema.namespaces[nameSpace].relationships![modelName]
-								.relationTypes,
-							childModels,
-							modelName,
-							nameSpace,
-							deleteQueue
-						);
-					}
-					break;
-				case 'BELONGS_TO':
-					// Intentionally blank
-					break;
-				default:
-					throw new Error(`Invalid relation type ${relationType}`);
-					break;
-			}
-		}
-
-		deleteQueue.push({
-			storeName: getStorename(nameSpace, srcModel),
-			items: models.map(record =>
-				this.modelInstanceCreator(
-					this.getModelConstructorByModelName!(nameSpace, srcModel),
-					record
-				)
-			),
-		});
-	}
-
-	async clear(): Promise<void> {
-		await this.checkPrivate();
-
-		this.db?.close();
-
-		await idb.deleteDB(this.dbName);
-
-		this.db = undefined!;
-		this.initPromise = undefined!;
-	}
-
-	async batchSave<T extends PersistentModel>(
-		modelConstructor: PersistentModelConstructor<any>,
-		items: ModelInstanceMetadata[]
-	): Promise<[T, OpType][]> {
-		if (items.length === 0) {
-			return [];
-		}
-
-		await this.checkPrivate();
-
-		const result: [T, OpType][] = [];
-
-		const storeName = this.getStorenameForModel(modelConstructor);
-
-		const txn = this.db.transaction(storeName, 'readwrite');
-		const store = txn.store;
-
-		for (const item of items) {
-			const namespaceName = this.namespaceResolver(modelConstructor);
-			const modelName = modelConstructor.name;
-			const model = this.modelInstanceCreator(modelConstructor, item);
-
-			const connectedModels = traverseModel(
-				modelName,
-				model,
-				this.schema.namespaces[namespaceName],
-				this.modelInstanceCreator,
-				this.getModelConstructorByModelName!
-			);
-
-			const keyValues = this.getIndexKeyValuesFromModel(model);
-			const { _deleted } = item;
-
-			const index = store.index('byPk');
-
-			const key = await index.getKey(this.canonicalKeyPath(keyValues));
-
-			if (!_deleted) {
-				const { instance } = connectedModels.find(({ instance }) => {
-					const instanceKeyValues = this.getIndexKeyValuesFromModel(instance);
-					return keysEqual(instanceKeyValues, keyValues);
-				})!;
-
-				result.push([
-					<T>(<unknown>instance),
-					key ? OpType.UPDATE : OpType.INSERT,
-				]);
-				await store.put(instance, key);
-			} else {
-				result.push([<T>(<unknown>item), OpType.DELETE]);
-
-				if (key) {
-					await store.delete(key);
-				}
-			}
-		}
-
-		await txn.done;
-
-		return result;
-	}
-
-	private createObjectStoreForModel(
-		db: idb.IDBPDatabase,
-		namespaceName: string,
-		storeName: string,
-		modelName: string
-	) {
-		const store = db.createObjectStore(storeName, {
-			autoIncrement: true,
-		});
-
-		const { indexes } =
-			this.schema.namespaces[namespaceName].relationships![modelName];
-
-		indexes.forEach(([idxName, keyPath, options]) => {
-			store.createIndex(idxName, keyPath, options);
-		});
-
-		return store;
-	}
-
 	/**
 	 * Checks the given path against the browser's IndexedDB implementation for
 	 * necessary compatibility transformations, applying those transforms if needed.
@@ -1244,6 +880,7 @@ class IndexedDBAdapter implements Adapter {
 		}
 		return keyArr;
 	};
+	//#endregion
 }
 
 export default new IndexedDBAdapter();