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

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -29,13 +29,17 @@ import {
 	traverseModel,
 	validatePredicate,
 	sortCompareFunction,
+	keysEqual,
+	getStorename,
+	getIndexKeys,
+	extractPrimaryKeyValues,
+	isSafariCompatabilityMode,
 } from '../../util';
 import { Adapter } from './index';
 
 const logger = new Logger('DataStore');
 
 const DB_NAME = 'amplify-datastore';
-
 class IndexedDBAdapter implements Adapter {
 	private schema: InternalSchema;
 	private namespaceResolver: NamespaceResolver;
@@ -49,6 +53,32 @@ class IndexedDBAdapter implements Adapter {
 	private resolve: (value?: any) => void;
 	private reject: (value?: any) => void;
 	private dbName: string = DB_NAME;
+	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);
+	}
 
 	private async checkPrivate() {
 		const isPrivate = await isPrivateMode().then(isPrivate => {
@@ -64,19 +94,30 @@ class IndexedDBAdapter implements Adapter {
 		}
 	}
 
-	private getStorenameForModel(
-		modelConstructor: PersistentModelConstructor<any>
-	) {
-		const namespace = this.namespaceResolver(modelConstructor);
-		const { name: modelName } = modelConstructor;
-
-		return this.getStorename(namespace, modelName);
+	/**
+	 * 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');
+		}
 	}
 
-	private getStorename(namespace: string, modelName: string) {
-		const storeName = `${namespace}_${modelName}`;
-
-		return storeName;
+	private getNamespaceAndModelFromStorename(storeName: string) {
+		const [namespaceName, ...modelNameArr] = storeName.split('_');
+		return {
+			namespaceName,
+			modelName: modelNameArr.join('_'),
+		};
 	}
 
 	async setUp(
@@ -90,6 +131,8 @@ class IndexedDBAdapter implements Adapter {
 		sessionId?: string
 	) {
 		await this.checkPrivate();
+		await this.setSafariCompatabilityMode();
+
 		if (!this.initPromise) {
 			this.initPromise = new Promise((res, rej) => {
 				this.resolve = res;
@@ -108,7 +151,7 @@ class IndexedDBAdapter implements Adapter {
 
 		try {
 			if (!this.db) {
-				const VERSION = 2;
+				const VERSION = 3;
 				this.db = await idb.openDB(this.dbName, VERSION, {
 					upgrade: async (db, oldVersion, newVersion, txn) => {
 						if (oldVersion === 0) {
@@ -116,7 +159,7 @@ class IndexedDBAdapter implements Adapter {
 								const namespace = theSchema.namespaces[namespaceName];
 
 								Object.keys(namespace.models).forEach(modelName => {
-									const storeName = this.getStorename(namespaceName, modelName);
+									const storeName = getStorename(namespaceName, modelName);
 									this.createObjectStoreForModel(
 										db,
 										namespaceName,
@@ -129,7 +172,7 @@ class IndexedDBAdapter implements Adapter {
 							return;
 						}
 
-						if (oldVersion === 1 && newVersion === 2) {
+						if ((oldVersion === 1 || oldVersion === 2) && newVersion === 3) {
 							try {
 								for (const storeName of txn.objectStoreNames) {
 									const origStore = txn.objectStore(storeName);
@@ -138,13 +181,15 @@ class IndexedDBAdapter implements Adapter {
 									const tmpName = `tmp_${storeName}`;
 									origStore.name = tmpName;
 
-									// create new store with original name
-									const newStore = db.createObjectStore(storeName, {
-										keyPath: undefined,
-										autoIncrement: true,
-									});
+									const { namespaceName, modelName } =
+										this.getNamespaceAndModelFromStorename(storeName);
 
-									newStore.createIndex('byId', 'id', { unique: true });
+									const newStore = this.createObjectStoreForModel(
+										db,
+										namespaceName,
+										storeName,
+										modelName
+									);
 
 									let cursor = await origStore.openCursor();
 									let count = 0;
@@ -175,7 +220,7 @@ class IndexedDBAdapter implements Adapter {
 										.map(modelName => {
 											return [
 												modelName,
-												this.getStorename(namespaceName, modelName),
+												getStorename(namespaceName, modelName),
 											];
 										})
 										.filter(([, storeName]) => !objectStoreNames.has(storeName))
@@ -208,19 +253,19 @@ class IndexedDBAdapter implements Adapter {
 
 	private async _get<T>(
 		storeOrStoreName: idb.IDBPObjectStore | string,
-		id: string
+		keyArr: string[]
 	): Promise<T> {
 		let index: idb.IDBPIndex;
 
 		if (typeof storeOrStoreName === 'string') {
 			const storeName = storeOrStoreName;
-			index = this.db.transaction(storeName, 'readonly').store.index('byId');
+			index = this.db.transaction(storeName, 'readonly').store.index('byPk');
 		} else {
 			const store = storeOrStoreName;
-			index = store.index('byId');
+			index = store.index('byPk');
 		}
 
-		const result = await index.get(id);
+		const result = await index.get(this.canonicalKeyPath(keyArr));
 
 		return result;
 	}
@@ -233,21 +278,26 @@ class IndexedDBAdapter implements Adapter {
 		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[this.namespaceResolver(modelConstructor)],
+			this.schema.namespaces[namespaceName],
 			this.modelInstanceCreator,
 			this.getModelConstructorByModelName
 		);
-		const namespaceName = this.namespaceResolver(modelConstructor);
 
 		const set = new Set<string>();
 		const connectionStoreNames = Object.values(connectedModels).map(
 			({ modelName, item, instance }) => {
-				const storeName = this.getStorename(namespaceName, modelName);
+				const storeName = getStorename(namespaceName, modelName);
 				set.add(storeName);
-				return { storeName, item, instance };
+				const keys = getIndexKeys(
+					this.schema.namespaces[namespaceName],
+					modelName
+				);
+				return { storeName, item, instance, keys };
 			}
 		);
 
@@ -257,7 +307,9 @@ class IndexedDBAdapter implements Adapter {
 		);
 		const store = tx.objectStore(storeName);
 
-		const fromDB = await this._get(store, model.id);
+		const keyValues = this.getIndexKeyValuesFromModel(model);
+
+		const fromDB = await this._get(store, keyValues);
 
 		if (condition && fromDB) {
 			const predicates = ModelPredicateCreator.getPredicates(condition);
@@ -276,17 +328,28 @@ class IndexedDBAdapter implements Adapter {
 		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
 
 		for await (const resItem of connectionStoreNames) {
-			const { storeName, item, instance } = resItem;
+			const { storeName, item, instance, keys } = resItem;
 			const store = tx.objectStore(storeName);
-			const { id } = item;
 
-			const fromDB = <T>await this._get(store, id);
+			const itemKeyValues = keys.map(key => {
+				const value = item[key];
+				return value;
+			});
+
+			const fromDB = <T>await this._get(store, itemKeyValues);
 			const opType: OpType =
 				fromDB === undefined ? OpType.INSERT : OpType.UPDATE;
 
+			const modelKeyValues = this.getIndexKeyValuesFromModel(model);
+
 			// Even if the parent is an INSERT, the child might not be, so we need to get its key
-			if (id === model.id || opType === OpType.INSERT) {
-				const key = await store.index('byId').getKey(item.id);
+			if (
+				keysEqual(itemKeyValues, modelKeyValues) ||
+				opType === OpType.INSERT
+			) {
+				const key = await store
+					.index('byPk')
+					.getKey(this.canonicalKeyPath(itemKeyValues));
 				await store.put(item, key);
 
 				result.push([instance, opType]);
@@ -306,7 +369,7 @@ class IndexedDBAdapter implements Adapter {
 		const namespace = this.schema.namespaces[namespaceName];
 		const relations = namespace.relationships[srcModelName].relationTypes;
 		const connectionStoreNames = relations.map(({ modelName }) => {
-			return this.getStorename(namespaceName, modelName);
+			return getStorename(namespaceName, modelName);
 		});
 		const modelConstructor = this.getModelConstructorByModelName(
 			namespaceName,
@@ -322,8 +385,9 @@ class IndexedDBAdapter implements Adapter {
 		const tx = this.db.transaction([...connectionStoreNames], 'readonly');
 
 		for await (const relation of relations) {
-			const { fieldName, modelName, targetName } = relation;
-			const storeName = this.getStorename(namespaceName, modelName);
+			// target name, metadata, set by init
+			const { fieldName, modelName, targetName, targetNames } = relation;
+			const storeName = getStorename(namespaceName, modelName);
 			const store = tx.objectStore(storeName);
 			const modelConstructor = this.getModelConstructorByModelName(
 				namespaceName,
@@ -333,35 +397,91 @@ class IndexedDBAdapter implements Adapter {
 			switch (relation.relationType) {
 				case 'HAS_ONE':
 					for await (const recordItem of records) {
-						const getByfield = recordItem[targetName] ? targetName : fieldName;
-						if (!recordItem[getByfield]) break;
+						// POST CPK codegen changes:
+						if (targetNames?.length) {
+							let getByFields = [];
+							let allPresent;
+							// iterate through all targetnames to make sure they are all present in the recordItem
+							allPresent = targetNames.every(targetName => {
+								return recordItem[targetName] != null;
+							});
 
-						const connectionRecord = await this._get(
-							store,
-							recordItem[getByfield]
-						);
+							if (!allPresent) {
+								break;
+							}
 
-						recordItem[fieldName] =
-							connectionRecord &&
-							this.modelInstanceCreator(modelConstructor, connectionRecord);
-					}
+							getByFields = targetNames as any;
 
+							// keys are the key values
+							const keys = getByFields.map(
+								getByField => recordItem[getByField]
+							);
+
+							const connectionRecord = await this._get(store, keys);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+						} else {
+							// If single target name, using old codegen
+							const getByfield = recordItem[targetName]
+								? targetName
+								: fieldName;
+
+							// We break here, because the recordItem does not have 'team', the `getByField`
+							// extract the keys on the related model.
+							if (!recordItem[getByfield]) break;
+
+							const key = [recordItem[getByfield]];
+
+							const connectionRecord = await this._get(store, key);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+						}
+					}
 					break;
 				case 'BELONGS_TO':
 					for await (const recordItem of records) {
-						if (recordItem[targetName]) {
-							const connectionRecord = await this._get(
-								store,
-								recordItem[targetName]
+						// POST CPK codegen changes:
+						if (targetNames?.length) {
+							let allPresent;
+							// iterate through all targetnames to make sure they are all present in the recordItem
+							allPresent = targetNames.every(targetName => {
+								return recordItem[targetName] != null;
+							});
+
+							// If not present, there is not yet a connected record
+							if (!allPresent) {
+								break;
+							}
+
+							const keys = targetNames.map(
+								targetName => recordItem[targetName]
 							);
 
+							// Retrieve the connected record
+							const connectionRecord = await this._get(store, keys);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+
+							targetNames?.map(targetName => {
+								delete recordItem[targetName];
+							});
+						} else if (recordItem[targetName]) {
+							const key = [recordItem[targetName]];
+
+							const connectionRecord = await this._get(store, key);
+
 							recordItem[fieldName] =
 								connectionRecord &&
 								this.modelInstanceCreator(modelConstructor, connectionRecord);
 							delete recordItem[targetName];
 						}
 					}
-
 					break;
 				case 'HAS_MANY':
 					// TODO: Lazy loading
@@ -388,13 +508,19 @@ class IndexedDBAdapter implements Adapter {
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
-		const queryById = predicates && this.idFromPredicate(predicates);
+		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 records: T[] = await (async () => {
-			if (queryById) {
-				const record = await this.getById(storeName, queryById);
+			if (queryByKey) {
+				const record = await this.getByKey(storeName, queryByKey);
 				return record ? [record] : [];
 			}
 
@@ -418,11 +544,11 @@ class IndexedDBAdapter implements Adapter {
 		return await this.load(namespaceName, modelConstructor.name, records);
 	}
 
-	private async getById<T extends PersistentModel>(
+	private async getByKey<T extends PersistentModel>(
 		storeName: string,
-		id: string
+		keyValue: string[]
 	): Promise<T> {
-		const record = <T>await this._get(storeName, id);
+		const record = <T>await this._get(storeName, keyValue);
 		return record;
 	}
 
@@ -432,17 +558,27 @@ class IndexedDBAdapter implements Adapter {
 		return await this.db.getAll(storeName);
 	}
 
-	private idFromPredicate<T extends PersistentModel>(
-		predicates: PredicatesGroup<T>
-	) {
+	private keyValueFromPredicate<T extends PersistentModel>(
+		predicates: PredicatesGroup<T>,
+		keyPath: string[]
+	): string[] | undefined {
 		const { predicates: predicateObjs } = predicates;
-		const idPredicate =
-			predicateObjs.length === 1 &&
-			(predicateObjs.find(
-				p => isPredicateObj(p) && p.field === 'id' && p.operator === 'eq'
-			) as PredicateObject<T>);
 
-		return idPredicate && idPredicate.operand;
+		if (predicateObjs.length !== keyPath.length) {
+			return;
+		}
+
+		const keyValues = [];
+
+		for (const key of keyPath) {
+			const predicateObj = predicateObjs.find(
+				p => isPredicateObj(p) && p.field === key && p.operator === 'eq'
+			) as PredicateObject<T>;
+
+			predicateObj && keyValues.push(predicateObj.operand);
+		}
+
+		return keyValues.length === keyPath.length ? keyValues : undefined;
 	}
 
 	private async filterOnPredicate<T extends PersistentModel>(
@@ -605,15 +741,16 @@ class IndexedDBAdapter implements Adapter {
 
 			const modelConstructor = Object.getPrototypeOf(model)
 				.constructor as PersistentModelConstructor<T>;
-			const nameSpace = this.namespaceResolver(modelConstructor);
+			const namespaceName = this.namespaceResolver(modelConstructor);
 
 			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, model.id);
+				const fromDB = await this._get(store, keyValues);
 
 				if (fromDB === undefined) {
 					const msg = 'Model instance not found in storage';
@@ -636,26 +773,28 @@ class IndexedDBAdapter implements Adapter {
 				await tx.done;
 
 				const relations =
-					this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
-						.relationTypes;
+					this.schema.namespaces[namespaceName].relationships[
+						modelConstructor.name
+					].relationTypes;
 
 				await this.deleteTraverse(
 					relations,
 					[model],
 					modelConstructor.name,
-					nameSpace,
+					namespaceName,
 					deleteQueue
 				);
 			} else {
 				const relations =
-					this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
-						.relationTypes;
+					this.schema.namespaces[namespaceName].relationships[
+						modelConstructor.name
+					].relationTypes;
 
 				await this.deleteTraverse(
 					relations,
 					[model],
 					modelConstructor.name,
-					nameSpace,
+					namespaceName,
 					deleteQueue
 				);
 			}
@@ -672,7 +811,10 @@ class IndexedDBAdapter implements Adapter {
 	}
 
 	private async deleteItem<T extends PersistentModel>(
-		deleteQueue?: { storeName: string; items: T[] | IDBValidKey[] }[]
+		deleteQueue?: {
+			storeName: string;
+			items: T[] | IDBValidKey[];
+		}[]
 	) {
 		const connectionStoreNames = deleteQueue.map(({ storeName }) => {
 			return storeName;
@@ -688,9 +830,13 @@ class IndexedDBAdapter implements Adapter {
 					let key: IDBValidKey;
 
 					if (typeof item === 'object') {
-						key = await store.index('byId').getKey(item['id']);
+						const keyValues = this.getIndexKeyValuesFromModel(item as T);
+						key = await store
+							.index('byPk')
+							.getKey(this.canonicalKeyPath(keyValues));
 					} else {
-						key = await store.index('byId').getKey(item.toString());
+						const itemKey = item.toString();
+						key = await store.index('byPk').getKey(itemKey);
 					}
 
 					if (key !== undefined) {
@@ -709,57 +855,109 @@ class IndexedDBAdapter implements Adapter {
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
 		for await (const rel of relations) {
-			const { relationType, fieldName, modelName, targetName } = rel;
-			const storeName = this.getStorename(nameSpace, modelName);
-
-			const index: string =
-				getIndex(
-					this.schema.namespaces[nameSpace].relationships[modelName]
-						.relationTypes,
-					srcModel
-				) ||
-				// if we were unable to find an index via relationTypes
-				// i.e. for keyName connections, attempt to find one by the
-				// associatedWith property
-				getIndexFromAssociation(
-					this.schema.namespaces[nameSpace].relationships[modelName].indexes,
-					rel.associatedWith
-				);
+			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 = index || 'byId';
-
-						const hasOneCustomField = targetName in model;
-						const value = hasOneCustomField ? model[targetName] : model.id;
-						if (!value) break;
-
-						const recordToDelete = <T>(
-							await this.db
-								.transaction(storeName, 'readwrite')
-								.objectStore(storeName)
-								.index(hasOneIndex)
-								.get(value)
-						);
+						const hasOneIndex = 'byPk';
 
-						await this.deleteTraverse(
-							this.schema.namespaces[nameSpace].relationships[modelName]
-								.relationTypes,
-							recordToDelete ? [recordToDelete] : [],
-							modelName,
-							nameSpace,
-							deleteQueue
-						);
+						if (targetNames?.length) {
+							// CPK codegen
+							const values = targetNames.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];
+								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))
+							);
+
+							await this.deleteTraverse(
+								this.schema.namespaces[nameSpace].relationships[modelName]
+									.relationTypes,
+								recordToDelete ? [recordToDelete] : [],
+								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 childrenArray = await this.db
 							.transaction(storeName, 'readwrite')
 							.objectStore(storeName)
-							.index(index)
-							.getAll(model['id']);
+							.index(index as string)
+							.getAll(this.canonicalKeyPath(keyValues));
 
 						await this.deleteTraverse(
 							this.schema.namespaces[nameSpace].relationships[modelName]
@@ -781,7 +979,7 @@ class IndexedDBAdapter implements Adapter {
 		}
 
 		deleteQueue.push({
-			storeName: this.getStorename(nameSpace, srcModel),
+			storeName: getStorename(nameSpace, srcModel),
 			items: models.map(record =>
 				this.modelInstanceCreator(
 					this.getModelConstructorByModelName(nameSpace, srcModel),
@@ -820,22 +1018,30 @@ class IndexedDBAdapter implements Adapter {
 		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(
-				modelConstructor.name,
-				this.modelInstanceCreator(modelConstructor, item),
-				this.schema.namespaces[this.namespaceResolver(modelConstructor)],
+				modelName,
+				model,
+				this.schema.namespaces[namespaceName],
 				this.modelInstanceCreator,
 				this.getModelConstructorByModelName
 			);
 
-			const { id, _deleted } = item;
-			const index = store.index('byId');
-			const key = await index.getKey(id);
+			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 }) => instance.id === id
-				);
+				const { instance } = connectedModels.find(({ instance }) => {
+					const instanceKeyValues = this.getIndexKeyValuesFromModel(instance);
+					return keysEqual(instanceKeyValues, keyValues);
+				});
 
 				result.push([
 					<T>(<unknown>instance),
@@ -856,7 +1062,7 @@ class IndexedDBAdapter implements Adapter {
 		return result;
 	}
 
-	private async createObjectStoreForModel(
+	private createObjectStoreForModel(
 		db: idb.IDBPDatabase,
 		namespaceName: string,
 		storeName: string,
@@ -866,12 +1072,30 @@ class IndexedDBAdapter implements Adapter {
 			autoIncrement: true,
 		});
 
-		const indexes =
-			this.schema.namespaces[namespaceName].relationships[modelName].indexes;
-		indexes.forEach(index => store.createIndex(index, index));
+		const { indexes } =
+			this.schema.namespaces[namespaceName].relationships[modelName];
 
-		store.createIndex('byId', 'id', { unique: true });
+		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.
+	 *
+	 * @param `keyArr` strings to compatibilize for browser-indexeddb index operations
+	 * @returns An array or string, depending on and given key,
+	 * that is ensured to be compatible with the IndexedDB implementation's nuances.
+	 */
+	private canonicalKeyPath = (keyArr: string[]) => {
+		if (this.safariCompatabilityMode) {
+			return keyArr.length > 1 ? keyArr : keyArr[0];
+		}
+		return keyArr;
+	};
 }
 
 export default new IndexedDBAdapter();