@aws-amplify/datastore 3.14.5-unstable.4 → 3.14.5

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -1,11 +1,13 @@
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
 import * as idb from 'idb';
 import { ModelInstanceCreator } from '../../datastore/datastore';
-import { ModelPredicateCreator } from '../../predicates';
+import {
+	ModelPredicateCreator,
+	ModelSortPredicateCreator,
+} from '../../predicates';
 import {
 	InternalSchema,
 	isPredicateObj,
-	isPredicateGroup,
 	ModelInstanceMetadata,
 	ModelPredicate,
 	NamespaceResolver,
@@ -19,14 +21,14 @@ import {
 	RelationType,
 } from '../../types';
 import {
+	exhaustiveCheck,
 	getIndex,
 	getIndexFromAssociation,
 	isModelConstructor,
 	isPrivateMode,
 	traverseModel,
 	validatePredicate,
-	inMemoryPagination,
-	NAMESPACES,
+	sortCompareFunction,
 	keysEqual,
 	getStorename,
 	getIndexKeys,
@@ -39,17 +41,17 @@ const logger = new Logger('DataStore');
 
 const DB_NAME = 'amplify-datastore';
 class IndexedDBAdapter implements Adapter {
-	private schema!: InternalSchema;
-	private namespaceResolver!: NamespaceResolver;
-	private modelInstanceCreator!: ModelInstanceCreator;
-	private getModelConstructorByModelName?: (
-		namsespaceName: NAMESPACES,
+	private schema: InternalSchema;
+	private namespaceResolver: NamespaceResolver;
+	private modelInstanceCreator: ModelInstanceCreator;
+	private getModelConstructorByModelName: (
+		namsespaceName: string,
 		modelName: string
 	) => PersistentModelConstructor<any>;
-	private db!: idb.IDBPDatabase;
-	private initPromise!: Promise<void>;
-	private resolve!: (value?: any) => void;
-	private reject!: (value?: any) => void;
+	private db: idb.IDBPDatabase;
+	private initPromise: Promise<void>;
+	private resolve: (value?: any) => void;
+	private reject: (value?: any) => void;
 	private dbName: string = DB_NAME;
 	private safariCompatabilityMode: boolean = false;
 
@@ -123,7 +125,7 @@ class IndexedDBAdapter implements Adapter {
 		namespaceResolver: NamespaceResolver,
 		modelInstanceCreator: ModelInstanceCreator,
 		getModelConstructorByModelName: (
-			namsespaceName: NAMESPACES,
+			namsespaceName: string,
 			modelName: string
 		) => PersistentModelConstructor<any>,
 		sessionId?: string
@@ -283,7 +285,7 @@ class IndexedDBAdapter implements Adapter {
 			model,
 			this.schema.namespaces[namespaceName],
 			this.modelInstanceCreator,
-			this.getModelConstructorByModelName!
+			this.getModelConstructorByModelName
 		);
 
 		const set = new Set<string>();
@@ -311,13 +313,9 @@ class IndexedDBAdapter implements Adapter {
 
 		if (condition && fromDB) {
 			const predicates = ModelPredicateCreator.getPredicates(condition);
-			const { predicates: predicateObjs, type } = predicates || {};
+			const { predicates: predicateObjs, type } = predicates;
 
-			const isValid = validatePredicate(
-				fromDB as any,
-				type as any,
-				predicateObjs as any
-			);
+			const isValid = validatePredicate(fromDB, type, predicateObjs);
 
 			if (!isValid) {
 				const msg = 'Conditional update failed';
@@ -328,6 +326,7 @@ class IndexedDBAdapter implements Adapter {
 		}
 
 		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
+
 		for await (const resItem of connectionStoreNames) {
 			const { storeName, item, instance, keys } = resItem;
 			const store = tx.objectStore(storeName);
@@ -352,6 +351,7 @@ class IndexedDBAdapter implements Adapter {
 					.index('byPk')
 					.getKey(this.canonicalKeyPath(itemKeyValues));
 				await store.put(item, key);
+
 				result.push([instance, opType]);
 			}
 		}
@@ -362,16 +362,16 @@ class IndexedDBAdapter implements Adapter {
 	}
 
 	private async load<T>(
-		namespaceName: NAMESPACES,
+		namespaceName: string,
 		srcModelName: string,
 		records: T[]
 	): Promise<T[]> {
 		const namespace = this.schema.namespaces[namespaceName];
-		const relations = namespace.relationships![srcModelName].relationTypes;
+		const relations = namespace.relationships[srcModelName].relationTypes;
 		const connectionStoreNames = relations.map(({ modelName }) => {
 			return getStorename(namespaceName, modelName);
 		});
-		const modelConstructor = this.getModelConstructorByModelName!(
+		const modelConstructor = this.getModelConstructorByModelName(
 			namespaceName,
 			srcModelName
 		);
@@ -382,6 +382,116 @@ class IndexedDBAdapter implements Adapter {
 			);
 		}
 
+		const tx = this.db.transaction([...connectionStoreNames], 'readonly');
+
+		for await (const relation of relations) {
+			// 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,
+				modelName
+			);
+
+			switch (relation.relationType) {
+				case 'HAS_ONE':
+					for await (const recordItem of records) {
+						// 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;
+							});
+
+							if (!allPresent) {
+								break;
+							}
+
+							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) {
+						// 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
+								.filter(targetName => recordItem[targetName] ?? false)
+								.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
+					break;
+				default:
+					exhaustiveCheck(relation.relationType);
+					break;
+			}
+		}
+
 		return records.map(record =>
 			this.modelInstanceCreator(modelConstructor, record)
 		);
@@ -394,9 +504,7 @@ class IndexedDBAdapter implements Adapter {
 	): Promise<T[]> {
 		await this.checkPrivate();
 		const storeName = this.getStorenameForModel(modelConstructor);
-		const namespaceName = this.namespaceResolver(
-			modelConstructor
-		) as NAMESPACES;
+		const namespaceName = this.namespaceResolver(modelConstructor);
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
@@ -410,7 +518,7 @@ class IndexedDBAdapter implements Adapter {
 		const hasSort = pagination && pagination.sort;
 		const hasPagination = pagination && pagination.limit;
 
-		const records: T[] = (await (async () => {
+		const records: T[] = await (async () => {
 			if (queryByKey) {
 				const record = await this.getByKey(storeName, queryByKey);
 				return record ? [record] : [];
@@ -431,7 +539,7 @@ class IndexedDBAdapter implements Adapter {
 			}
 
 			return this.getAll(storeName);
-		})()) as T[];
+		})();
 
 		return await this.load(namespaceName, modelConstructor.name, records);
 	}
@@ -440,7 +548,8 @@ class IndexedDBAdapter implements Adapter {
 		storeName: string,
 		keyValue: string[]
 	): Promise<T> {
-		return <T>await this._get(storeName, keyValue);
+		const record = <T>await this._get(storeName, keyValue);
+		return record;
 	}
 
 	private async getAll<T extends PersistentModel>(
@@ -459,7 +568,7 @@ class IndexedDBAdapter implements Adapter {
 			return;
 		}
 
-		const keyValues = [] as any[];
+		const keyValues = [];
 
 		for (const key of keyPath) {
 			const predicateObj = predicateObjs.find(
@@ -472,116 +581,17 @@ class IndexedDBAdapter implements Adapter {
 		return keyValues.length === keyPath.length ? keyValues : undefined;
 	}
 
-	private matchingIndex(
-		storeName: string,
-		fieldName: string,
-		transaction: idb.IDBPTransaction<unknown, [string]>
-	) {
-		const store = transaction.objectStore(storeName);
-		for (const name of store.indexNames) {
-			const idx = store.index(name);
-			if (idx.keyPath === fieldName) {
-				return idx;
-			}
-		}
-	}
-
 	private async filterOnPredicate<T extends PersistentModel>(
 		storeName: string,
 		predicates: PredicatesGroup<T>
 	) {
-		let { predicates: predicateObjs, type } = predicates;
-
-		// the predicate objects we care about tend to be nested at least
-		// one level down: `{and: {or: {and: { <the predicates we want> }}}}`
-		// so, we unpack and/or groups until we find a group with more than 1
-		// child OR a child that is not a group (and is therefore a predicate "object").
-		while (predicateObjs.length === 1 && isPredicateGroup(predicateObjs[0])) {
-			type = (predicateObjs[0] as PredicatesGroup<T>).type;
-			predicateObjs = (predicateObjs[0] as PredicatesGroup<T>).predicates;
-		}
+		const { predicates: predicateObjs, type } = predicates;
 
-		// where we'll accumulate candidate results, which will be filtered at the end.
-		let candidateResults: T[];
-
-		// AFAIK, this will always be a homogenous group of predicate objects at this point.
-		// but, if that ever changes, this pulls out just the predicates from the list that
-		// are field-level predicate objects we can potentially smash against an index.
-		const fieldPredicates = predicateObjs.filter(p =>
-			isPredicateObj(p)
-		) as PredicateObject<T>[];
-
-		// several sub-queries could occur here. explicitly start a txn here to avoid
-		// opening/closing multiple txns.
-		const txn = this.db.transaction(storeName);
-
-		// our potential indexes or lacks thereof.
-		const predicateIndexes = fieldPredicates.map(p => {
-			return {
-				predicate: p,
-				index: this.matchingIndex(storeName, String(p.field), txn),
-			};
-		});
-
-		// Explicitly wait for txns from index queries to complete before proceding.
-		// This helps ensure IndexedDB is in a stable, ready state. Else, subseqeuent
-		// qeuries can sometimes appear to deadlock (at least in FakeIndexedDB).
-		await txn.done;
-
-		// semi-naive implementation:
-		if (type === 'and') {
-			// each condition must be satsified, we can form a base set with any
-			// ONE of those conditions and then filter.
-			const actualPredicateIndexes = predicateIndexes.filter(
-				i => i.index && i.predicate.operator === 'eq'
-			);
-
-			if (actualPredicateIndexes.length > 0) {
-				const predicateIndex = actualPredicateIndexes[0];
-				candidateResults = <T[]>(
-					await predicateIndex.index!.getAll(predicateIndex.predicate.operand)
-				);
-			} else {
-				// no usable indexes
-				candidateResults = <T[]>await this.getAll(storeName);
-			}
-		} else if (type === 'or') {
-			// NOTE: each condition implies a potentially distinct set. we only benefit
-			// from using indexes here if EVERY condition uses an index. if any one
-			// index requires a table scan, we gain nothing from the indexes.
-			// NOTE: results must be DISTINCT-ified if we leverage indexes.
-			if (
-				predicateIndexes.length > 0 &&
-				predicateIndexes.every(i => i.index && i.predicate.operator === 'eq')
-			) {
-				const distinctResults = new Map<string, T>();
-				for (const predicateIndex of predicateIndexes) {
-					const resultGroup = <T[]>(
-						await predicateIndex.index!.getAll(predicateIndex.predicate.operand)
-					);
-					for (const item of resultGroup) {
-						// TODO: custom PK
-						distinctResults.set(item.id, item);
-					}
-				}
-
-				// we could conceivably check for special conditions and return early here.
-				// but, this is simpler and has not yet had a measurable performance impact.
-				candidateResults = Array.from(distinctResults.values());
-			} else {
-				// either no usable indexes or not all conditions can use one.
-				candidateResults = <T[]>await this.getAll(storeName);
-			}
-		} else {
-			// nothing intelligent we can do with `not` groups unless or until we start
-			// smashing comparison operators against indexes -- at which point we could
-			// perform some reversal here.
-			candidateResults = <T[]>await this.getAll(storeName);
-		}
+		const all = <T[]>await this.getAll(storeName);
 
 		const filtered = predicateObjs
-			? candidateResults.filter(m => validatePredicate(m, type, predicateObjs))
-			: candidateResults;
+			? all.filter(m => validatePredicate(m, type, predicateObjs))
+			: all;
 
 		return filtered;
 	}
@@ -590,7 +600,26 @@ class IndexedDBAdapter implements Adapter {
 		records: T[],
 		pagination?: PaginationInput<T>
 	): T[] {
-		return inMemoryPagination(records, pagination);
+		if (pagination && records.length > 1) {
+			if (pagination.sort) {
+				const sortPredicates = ModelSortPredicateCreator.getPredicates(
+					pagination.sort
+				);
+
+				if (sortPredicates.length) {
+					const compareFn = sortCompareFunction(sortPredicates);
+					records.sort(compareFn);
+				}
+			}
+
+			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;
 	}
 
 	private async enginePagination<T extends PersistentModel>(
@@ -658,15 +687,14 @@ class IndexedDBAdapter implements Adapter {
 		const deleteQueue: { storeName: string; items: T[] }[] = [];
 
 		if (isModelConstructor(modelOrModelConstructor)) {
-			const modelConstructor =
-				modelOrModelConstructor as PersistentModelConstructor<T>;
-			const nameSpace = this.namespaceResolver(modelConstructor) as NAMESPACES;
+			const modelConstructor = modelOrModelConstructor;
+			const nameSpace = this.namespaceResolver(modelConstructor);
 
 			const storeName = this.getStorenameForModel(modelConstructor);
 
 			const models = await this.query(modelConstructor, condition);
 			const relations =
-				this.schema.namespaces![nameSpace].relationships![modelConstructor.name]
+				this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
 					.relationTypes;
 
 			if (condition !== undefined) {
@@ -709,13 +737,11 @@ class IndexedDBAdapter implements Adapter {
 				return [models, deletedModels];
 			}
 		} else {
-			const model = modelOrModelConstructor as T;
+			const model = modelOrModelConstructor;
 
 			const modelConstructor = Object.getPrototypeOf(model)
 				.constructor as PersistentModelConstructor<T>;
-			const namespaceName = this.namespaceResolver(
-				modelConstructor
-			) as NAMESPACES;
+			const namespaceName = this.namespaceResolver(modelConstructor);
 
 			const storeName = this.getStorenameForModel(modelConstructor);
 
@@ -734,10 +760,9 @@ class IndexedDBAdapter implements Adapter {
 				}
 
 				const predicates = ModelPredicateCreator.getPredicates(condition);
-				const { predicates: predicateObjs, type } =
-					predicates as PredicatesGroup<T>;
+				const { predicates: predicateObjs, type } = predicates;
 
-				const isValid = validatePredicate(fromDB as T, type, predicateObjs);
+				const isValid = validatePredicate(fromDB, type, predicateObjs);
 
 				if (!isValid) {
 					const msg = 'Conditional update failed';
@@ -748,7 +773,7 @@ class IndexedDBAdapter implements Adapter {
 				await tx.done;
 
 				const relations =
-					this.schema.namespaces[namespaceName].relationships![
+					this.schema.namespaces[namespaceName].relationships[
 						modelConstructor.name
 					].relationTypes;
 
@@ -761,7 +786,7 @@ class IndexedDBAdapter implements Adapter {
 				);
 			} else {
 				const relations =
-					this.schema.namespaces[namespaceName].relationships![
+					this.schema.namespaces[namespaceName].relationships[
 						modelConstructor.name
 					].relationTypes;
 
@@ -791,18 +816,18 @@ class IndexedDBAdapter implements Adapter {
 			items: T[] | IDBValidKey[];
 		}[]
 	) {
-		const connectionStoreNames = deleteQueue!.map(({ storeName }) => {
+		const connectionStoreNames = deleteQueue.map(({ storeName }) => {
 			return storeName;
 		});
 
 		const tx = this.db.transaction([...connectionStoreNames], 'readwrite');
-		for await (const deleteItem of deleteQueue!) {
+		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;
+					let key: IDBValidKey;
 
 					if (typeof item === 'object') {
 						const keyValues = this.getIndexKeyValuesFromModel(item as T);
@@ -826,7 +851,7 @@ class IndexedDBAdapter implements Adapter {
 		relations: RelationType[],
 		models: T[],
 		srcModel: string,
-		nameSpace: NAMESPACES,
+		nameSpace: string,
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
 		for await (const rel of relations) {
@@ -862,7 +887,7 @@ class IndexedDBAdapter implements Adapter {
 							);
 
 							await this.deleteTraverse(
-								this.schema.namespaces[nameSpace].relationships![modelName]
+								this.schema.namespaces[nameSpace].relationships[modelName]
 									.relationTypes,
 								recordToDelete ? [recordToDelete] : [],
 								modelName,
@@ -885,7 +910,7 @@ class IndexedDBAdapter implements Adapter {
 								// 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]
+									this.schema.namespaces[nameSpace].relationships[modelName]
 										.relationTypes,
 									srcModel
 								);
@@ -903,7 +928,7 @@ class IndexedDBAdapter implements Adapter {
 							);
 
 							await this.deleteTraverse(
-								this.schema.namespaces[nameSpace].relationships![modelName]
+								this.schema.namespaces[nameSpace].relationships[modelName]
 									.relationTypes,
 								recordToDelete ? [recordToDelete] : [],
 								modelName,
@@ -918,15 +943,15 @@ class IndexedDBAdapter implements Adapter {
 						const index =
 							// explicit bi-directional @hasMany and @manyToMany
 							getIndex(
-								this.schema.namespaces[nameSpace].relationships![modelName]
+								this.schema.namespaces[nameSpace].relationships[modelName]
 									.relationTypes,
 								srcModel
 							) ||
 							// uni and/or implicit @hasMany
 							getIndexFromAssociation(
-								this.schema.namespaces[nameSpace].relationships![modelName]
+								this.schema.namespaces[nameSpace].relationships[modelName]
 									.indexes,
-								associatedWith!
+								associatedWith
 							);
 						const keyValues = this.getIndexKeyValuesFromModel(model);
 
@@ -937,7 +962,7 @@ class IndexedDBAdapter implements Adapter {
 							.getAll(this.canonicalKeyPath(keyValues));
 
 						await this.deleteTraverse(
-							this.schema.namespaces[nameSpace].relationships![modelName]
+							this.schema.namespaces[nameSpace].relationships[modelName]
 								.relationTypes,
 							childrenArray,
 							modelName,
@@ -950,7 +975,7 @@ class IndexedDBAdapter implements Adapter {
 					// Intentionally blank
 					break;
 				default:
-					throw new Error(`Invalid relation type ${relationType}`);
+					exhaustiveCheck(relationType);
 					break;
 			}
 		}
@@ -959,7 +984,7 @@ class IndexedDBAdapter implements Adapter {
 			storeName: getStorename(nameSpace, srcModel),
 			items: models.map(record =>
 				this.modelInstanceCreator(
-					this.getModelConstructorByModelName!(nameSpace, srcModel),
+					this.getModelConstructorByModelName(nameSpace, srcModel),
 					record
 				)
 			),
@@ -973,8 +998,8 @@ class IndexedDBAdapter implements Adapter {
 
 		await idb.deleteDB(this.dbName);
 
-		this.db = undefined!;
-		this.initPromise = undefined!;
+		this.db = undefined;
+		this.initPromise = undefined;
 	}
 
 	async batchSave<T extends PersistentModel>(
@@ -1004,7 +1029,7 @@ class IndexedDBAdapter implements Adapter {
 				model,
 				this.schema.namespaces[namespaceName],
 				this.modelInstanceCreator,
-				this.getModelConstructorByModelName!
+				this.getModelConstructorByModelName
 			);
 
 			const keyValues = this.getIndexKeyValuesFromModel(model);
@@ -1018,7 +1043,7 @@ class IndexedDBAdapter implements Adapter {
 				const { instance } = connectedModels.find(({ instance }) => {
 					const instanceKeyValues = this.getIndexKeyValuesFromModel(instance);
 					return keysEqual(instanceKeyValues, keyValues);
-				})!;
+				});
 
 				result.push([
 					<T>(<unknown>instance),
@@ -1050,7 +1075,7 @@ class IndexedDBAdapter implements Adapter {
 		});
 
 		const { indexes } =
-			this.schema.namespaces[namespaceName].relationships![modelName];
+			this.schema.namespaces[namespaceName].relationships[modelName];
 
 		indexes.forEach(([idxName, keyPath, options]) => {
 			store.createIndex(idxName, keyPath, options);

package/src/storage/adapter/getDefaultAdapter/index.ts

@@ -7,10 +7,10 @@ const getDefaultAdapter: () => Adapter = () => {
 	const { isBrowser } = browserOrNode();
 
 	if ((isBrowser && window.indexedDB) || (isWebWorker() && self.indexedDB)) {
-		return IndexedDBAdapter as Adapter;
+		return IndexedDBAdapter;
 	}
 
-	return AsyncStorageAdapter as Adapter;
+	return AsyncStorageAdapter;
 };
 
 export default getDefaultAdapter;