@aws-amplify/datastore 3.7.3-webpack5.5 → 3.7.4-custom-pk.80

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -29,13 +29,13 @@ import {
 	traverseModel,
 	validatePredicate,
 	sortCompareFunction,
+	extractTargetNamesFromSrc,
 } 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;
@@ -79,6 +79,45 @@ class IndexedDBAdapter implements Adapter {
 		return storeName;
 	}
 
+	private getNamespaceAndModelFromStorename(storeName: string) {
+		const [namespaceName, ...modelNameArr] = storeName.split('_');
+		return {
+			namespaceName,
+			modelName: modelNameArr.join('_'),
+		};
+	}
+
+	private getIndexKeyPath(namespaceName: string, modelName: string): string[] {
+		const namespace = this.schema.namespaces[namespaceName];
+
+		const keyPath = namespace?.keys[modelName]?.primaryKey;
+
+		if (keyPath) {
+			return keyPath;
+		}
+
+		return ['id'];
+	}
+
+	private getIndexKeyValues<T extends PersistentModel>(model: T): string[] {
+		const modelConstructor = Object.getPrototypeOf(model)
+			.constructor as PersistentModelConstructor<T>;
+		const namespaceName = this.namespaceResolver(modelConstructor);
+
+		const keys = this.getIndexKeyPath(namespaceName, modelConstructor.name);
+
+		const keyValues = keys.map(field => model[field]);
+		return keyValues;
+	}
+
+	private keysEqual(keysA, keysB): boolean {
+		if (keysA.length !== keysB.length) {
+			return false;
+		}
+
+		return keysA.every((key, idx) => key === keysB[idx]);
+	}
+
 	async setUp(
 		theSchema: InternalSchema,
 		namespaceResolver: NamespaceResolver,
@@ -90,6 +129,7 @@ class IndexedDBAdapter implements Adapter {
 		sessionId?: string
 	) {
 		await this.checkPrivate();
+
 		if (!this.initPromise) {
 			this.initPromise = new Promise((res, rej) => {
 				this.resolve = res;
@@ -108,7 +148,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) {
@@ -117,24 +157,19 @@ class IndexedDBAdapter implements Adapter {
 
 								Object.keys(namespace.models).forEach(modelName => {
 									const storeName = this.getStorename(namespaceName, modelName);
-									const store = db.createObjectStore(storeName, {
-										autoIncrement: true,
-									});
-
-									const indexes =
-										this.schema.namespaces[namespaceName].relationships[
-											modelName
-										].indexes;
-									indexes.forEach(index => store.createIndex(index, index));
-
-									store.createIndex('byId', 'id', { unique: true });
+									this.createObjectStoreForModel(
+										db,
+										namespaceName,
+										storeName,
+										modelName
+									);
 								});
 							});
 
 							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);
@@ -149,7 +184,26 @@ class IndexedDBAdapter implements Adapter {
 										autoIncrement: true,
 									});
 
-									newStore.createIndex('byId', 'id', { unique: true });
+									const origIndexNames = Object.values(origStore.indexNames);
+									for (const idxName of origIndexNames) {
+										if (idxName === 'byId') {
+											// don't migrate this index. It'll be replaced with byPk
+											continue;
+										}
+										const idx = origStore.index(idxName);
+										const { keyPath, unique } = idx;
+
+										newStore.createIndex(idxName, keyPath, { unique });
+									}
+
+									const { namespaceName, modelName } =
+										this.getNamespaceAndModelFromStorename(storeName);
+
+									const keyPath = this.getIndexKeyPath(
+										namespaceName,
+										modelName
+									);
+									newStore.createIndex('byPk', keyPath, { unique: true });
 
 									let cursor = await origStore.openCursor();
 									let count = 0;
@@ -168,6 +222,31 @@ class IndexedDBAdapter implements Adapter {
 
 									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,
+												this.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();
@@ -188,19 +267,19 @@ class IndexedDBAdapter implements Adapter {
 
 	private async _get<T>(
 		storeOrStoreName: idb.IDBPObjectStore | string,
-		id: string
+		keyArr: any[]
 	): 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(keyArr);
 
 		return result;
 	}
@@ -213,30 +292,35 @@ 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);
 				set.add(storeName);
-				return { storeName, item, instance };
+				const keys = this.getIndexKeyPath(namespaceName, modelName);
+				return { storeName, item, instance, keys };
 			}
 		);
+
 		const tx = this.db.transaction(
 			[storeName, ...Array.from(set.values())],
 			'readwrite'
 		);
 		const store = tx.objectStore(storeName);
 
-		const fromDB = await this._get(store, model.id);
+		const keyValues = this.getIndexKeyValues(model);
+
+		const fromDB = await this._get(store, keyValues);
 
 		if (condition && fromDB) {
 			const predicates = ModelPredicateCreator.getPredicates(condition);
@@ -255,17 +339,24 @@ 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.getIndexKeyValues(model);
+			const keysEqual = this.keysEqual(itemKeyValues, modelKeyValues);
+
 			// 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 || opType === OpType.INSERT) {
+				const key = await store.index('byPk').getKey(itemKeyValues);
 				await store.put(item, key);
 
 				result.push([instance, opType]);
@@ -301,7 +392,8 @@ class IndexedDBAdapter implements Adapter {
 		const tx = this.db.transaction([...connectionStoreNames], 'readonly');
 
 		for await (const relation of relations) {
-			const { fieldName, modelName, targetName } = relation;
+			// target name, metadata, set by init
+			const { fieldName, modelName, targetName, targetNames } = relation;
 			const storeName = this.getStorename(namespaceName, modelName);
 			const store = tx.objectStore(storeName);
 			const modelConstructor = this.getModelConstructorByModelName(
@@ -312,35 +404,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
@@ -367,13 +515,16 @@ class IndexedDBAdapter implements Adapter {
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
-		const queryById = predicates && this.idFromPredicate(predicates);
+		const keyPath = this.getIndexKeyPath(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] : [];
 			}
 
@@ -397,31 +548,41 @@ 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;
 	}
 
 	private async getAll<T extends PersistentModel>(
-		storeName: string
+		storeName: any
 	): Promise<T[]> {
 		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>(
@@ -584,15 +745,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.getIndexKeyValues(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';
@@ -615,26 +777,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
 				);
 			}
@@ -651,7 +815,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;
@@ -667,9 +834,11 @@ class IndexedDBAdapter implements Adapter {
 					let key: IDBValidKey;
 
 					if (typeof item === 'object') {
-						key = await store.index('byId').getKey(item['id']);
+						const keyValues = this.getIndexKeyValues(item as T);
+						key = await store.index('byPk').getKey(keyValues);
 					} else {
-						key = await store.index('byId').getKey(item.toString());
+						const itemKey = [item.toString()];
+						key = await store.index('byPk').getKey([itemKey]);
 					}
 
 					if (key !== undefined) {
@@ -688,10 +857,12 @@ class IndexedDBAdapter implements Adapter {
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
 		for await (const rel of relations) {
-			const { relationType, fieldName, modelName, targetName } = rel;
+			const { relationType, fieldName, modelName, targetName, targetNames } =
+				rel;
+
 			const storeName = this.getStorename(nameSpace, modelName);
 
-			const index: string =
+			const index: string | string[] | undefined =
 				getIndex(
 					this.schema.namespaces[nameSpace].relationships[modelName]
 						.relationTypes,
@@ -705,40 +876,88 @@ class IndexedDBAdapter implements Adapter {
 					rel.associatedWith
 				);
 
+			// TODO: refactor
 			switch (relationType) {
 				case 'HAS_ONE':
 					for await (const model of models) {
-						const hasOneIndex = index || 'byId';
+						const hasOneIndex = index || 'byPk';
+
+						// CPK
+						if (targetNames && targetNames.length > 0) {
+							// iterate over targetNames array and see if each item is present in model object
+							// targetNames here being the keys for the CHILD model
+							const hasConnectedModelFields = targetNames.every(targetName =>
+								model.hasOwnProperty(targetName)
+							);
+
+							// PK / Composite key for the PARENT model
+							const keyValues = this.getIndexKeyValues(model);
+
+							let values = [];
+
+							if (hasConnectedModelFields) {
+								// Values will be that of the child model
+								values = targetNames.map(
+									targetName => model[targetName]
+								) as any;
+							} else {
+								// values will be that of the parent model
+								values = keyValues as any;
+							}
 
-						const hasOneCustomField = targetName in model;
-						const value = hasOneCustomField ? model[targetName] : model.id;
-						if (!value) break;
+							if (values.length === 0) break;
 
-						const recordToDelete = <T>(
-							await this.db
+							const recordToDelete = <T>await this.db
 								.transaction(storeName, 'readwrite')
 								.objectStore(storeName)
-								.index(hasOneIndex)
-								.get(value)
-						);
+								.index(hasOneIndex as string)
+								.get(values);
+
+							await this.deleteTraverse(
+								this.schema.namespaces[nameSpace].relationships[modelName]
+									.relationTypes,
+								recordToDelete ? [recordToDelete] : [],
+								modelName,
+								nameSpace,
+								deleteQueue
+							);
+							break;
+						} else {
+							// Backwards compatibility (TODO: combine with above)
+							const hasOneIndex = index || 'byPk';
 
-						await this.deleteTraverse(
-							this.schema.namespaces[nameSpace].relationships[modelName]
-								.relationTypes,
-							recordToDelete ? [recordToDelete] : [],
-							modelName,
-							nameSpace,
-							deleteQueue
-						);
+							const hasOneCustomField = targetName in model;
+							const keyValues = this.getIndexKeyValues(model);
+							const value = hasOneCustomField ? [model[targetName]] : keyValues;
+
+							if (!value) break;
+
+							const recordToDelete = <T>await this.db
+								.transaction(storeName, 'readwrite')
+								.objectStore(storeName)
+								.index(hasOneIndex as string)
+								.get(value);
+
+							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 keyValues = this.getIndexKeyValues(model);
+
 						const childrenArray = await this.db
 							.transaction(storeName, 'readwrite')
 							.objectStore(storeName)
-							.index(index)
-							.getAll(model['id']);
+							.index(index as string)
+							.getAll(keyValues);
 
 						await this.deleteTraverse(
 							this.schema.namespaces[nameSpace].relationships[modelName]
@@ -799,22 +1018,29 @@ 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.getIndexKeyValues(model);
+			const { _deleted } = item;
+
+			const index = store.index('byPk');
+			const key = await index.getKey(keyValues);
 
 			if (!_deleted) {
-				const { instance } = connectedModels.find(
-					({ instance }) => instance.id === id
-				);
+				const { instance } = connectedModels.find(({ instance }) => {
+					const instanceKeyValues = this.getIndexKeyValues(instance);
+					return this.keysEqual(instanceKeyValues, keyValues);
+				});
 
 				result.push([
 					<T>(<unknown>instance),
@@ -834,6 +1060,24 @@ class IndexedDBAdapter implements Adapter {
 
 		return result;
 	}
+
+	private async 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);
+		});
+	}
 }
 
 export default new IndexedDBAdapter();