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

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -1,13 +1,11 @@
 import { ConsoleLogger as Logger } from '@aws-amplify/core';
 import * as idb from 'idb';
 import { ModelInstanceCreator } from '../../datastore/datastore';
-import {
-	ModelPredicateCreator,
-	ModelSortPredicateCreator,
-} from '../../predicates';
+import { ModelPredicateCreator } from '../../predicates';
 import {
 	InternalSchema,
 	isPredicateObj,
+	isPredicateGroup,
 	ModelInstanceMetadata,
 	ModelPredicate,
 	NamespaceResolver,
@@ -21,14 +19,14 @@ import {
 	RelationType,
 } from '../../types';
 import {
-	exhaustiveCheck,
 	getIndex,
 	getIndexFromAssociation,
 	isModelConstructor,
 	isPrivateMode,
 	traverseModel,
 	validatePredicate,
-	sortCompareFunction,
+	inMemoryPagination,
+	NAMESPACES,
 	keysEqual,
 	getStorename,
 	getIndexKeys,
@@ -41,17 +39,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: string,
+	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 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;
 
@@ -125,7 +123,7 @@ class IndexedDBAdapter implements Adapter {
 		namespaceResolver: NamespaceResolver,
 		modelInstanceCreator: ModelInstanceCreator,
 		getModelConstructorByModelName: (
-			namsespaceName: string,
+			namsespaceName: NAMESPACES,
 			modelName: string
 		) => PersistentModelConstructor<any>,
 		sessionId?: string
@@ -285,7 +283,7 @@ class IndexedDBAdapter implements Adapter {
 			model,
 			this.schema.namespaces[namespaceName],
 			this.modelInstanceCreator,
-			this.getModelConstructorByModelName
+			this.getModelConstructorByModelName!
 		);
 
 		const set = new Set<string>();
@@ -313,9 +311,13 @@ 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, type, predicateObjs);
+			const isValid = validatePredicate(
+				fromDB as any,
+				type as any,
+				predicateObjs as any
+			);
 
 			if (!isValid) {
 				const msg = 'Conditional update failed';
@@ -326,7 +328,6 @@ 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);
@@ -351,7 +352,6 @@ 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: string,
+		namespaceName: NAMESPACES,
 		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,116 +382,6 @@ 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.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)
 		);
@@ -504,7 +394,9 @@ class IndexedDBAdapter implements Adapter {
 	): Promise<T[]> {
 		await this.checkPrivate();
 		const storeName = this.getStorenameForModel(modelConstructor);
-		const namespaceName = this.namespaceResolver(modelConstructor);
+		const namespaceName = this.namespaceResolver(
+			modelConstructor
+		) as NAMESPACES;
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
@@ -518,7 +410,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] : [];
@@ -539,7 +431,7 @@ class IndexedDBAdapter implements Adapter {
 			}
 
 			return this.getAll(storeName);
-		})();
+		})()) as T[];
 
 		return await this.load(namespaceName, modelConstructor.name, records);
 	}
@@ -548,8 +440,7 @@ class IndexedDBAdapter implements Adapter {
 		storeName: string,
 		keyValue: string[]
 	): Promise<T> {
-		const record = <T>await this._get(storeName, keyValue);
-		return record;
+		return <T>await this._get(storeName, keyValue);
 	}
 
 	private async getAll<T extends PersistentModel>(
@@ -568,7 +459,7 @@ class IndexedDBAdapter implements Adapter {
 			return;
 		}
 
-		const keyValues = [];
+		const keyValues = [] as any[];
 
 		for (const key of keyPath) {
 			const predicateObj = predicateObjs.find(
@@ -581,17 +472,116 @@ 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>
 	) {
-		const { predicates: predicateObjs, type } = predicates;
+		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 all = <T[]>await this.getAll(storeName);
+		// 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 filtered = predicateObjs
-			? all.filter(m => validatePredicate(m, type, predicateObjs))
-			: all;
+			? candidateResults.filter(m => validatePredicate(m, type, predicateObjs))
+			: candidateResults;
 
 		return filtered;
 	}
@@ -600,26 +590,7 @@ class IndexedDBAdapter implements Adapter {
 		records: T[],
 		pagination?: PaginationInput<T>
 	): T[] {
-		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;
+		return inMemoryPagination(records, pagination);
 	}
 
 	private async enginePagination<T extends PersistentModel>(
@@ -687,14 +658,15 @@ class IndexedDBAdapter implements Adapter {
 		const deleteQueue: { storeName: string; items: T[] }[] = [];
 
 		if (isModelConstructor(modelOrModelConstructor)) {
-			const modelConstructor = modelOrModelConstructor;
-			const nameSpace = this.namespaceResolver(modelConstructor);
+			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]
+				this.schema.namespaces![nameSpace].relationships![modelConstructor.name]
 					.relationTypes;
 
 			if (condition !== undefined) {
@@ -737,11 +709,13 @@ class IndexedDBAdapter implements Adapter {
 				return [models, deletedModels];
 			}
 		} else {
-			const model = modelOrModelConstructor;
+			const model = modelOrModelConstructor as T;
 
 			const modelConstructor = Object.getPrototypeOf(model)
 				.constructor as PersistentModelConstructor<T>;
-			const namespaceName = this.namespaceResolver(modelConstructor);
+			const namespaceName = this.namespaceResolver(
+				modelConstructor
+			) as NAMESPACES;
 
 			const storeName = this.getStorenameForModel(modelConstructor);
 
@@ -760,9 +734,10 @@ class IndexedDBAdapter implements Adapter {
 				}
 
 				const predicates = ModelPredicateCreator.getPredicates(condition);
-				const { predicates: predicateObjs, type } = predicates;
+				const { predicates: predicateObjs, type } =
+					predicates as PredicatesGroup<T>;
 
-				const isValid = validatePredicate(fromDB, type, predicateObjs);
+				const isValid = validatePredicate(fromDB as T, type, predicateObjs);
 
 				if (!isValid) {
 					const msg = 'Conditional update failed';
@@ -773,7 +748,7 @@ class IndexedDBAdapter implements Adapter {
 				await tx.done;
 
 				const relations =
-					this.schema.namespaces[namespaceName].relationships[
+					this.schema.namespaces[namespaceName].relationships![
 						modelConstructor.name
 					].relationTypes;
 
@@ -786,7 +761,7 @@ class IndexedDBAdapter implements Adapter {
 				);
 			} else {
 				const relations =
-					this.schema.namespaces[namespaceName].relationships[
+					this.schema.namespaces[namespaceName].relationships![
 						modelConstructor.name
 					].relationTypes;
 
@@ -816,18 +791,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;
+					let key: IDBValidKey | undefined;
 
 					if (typeof item === 'object') {
 						const keyValues = this.getIndexKeyValuesFromModel(item as T);
@@ -851,7 +826,7 @@ class IndexedDBAdapter implements Adapter {
 		relations: RelationType[],
 		models: T[],
 		srcModel: string,
-		nameSpace: string,
+		nameSpace: NAMESPACES,
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
 		for await (const rel of relations) {
@@ -885,7 +860,7 @@ class IndexedDBAdapter implements Adapter {
 							);
 
 							await this.deleteTraverse(
-								this.schema.namespaces[nameSpace].relationships[modelName]
+								this.schema.namespaces[nameSpace].relationships![modelName]
 									.relationTypes,
 								recordToDelete ? [recordToDelete] : [],
 								modelName,
@@ -908,7 +883,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
 								);
@@ -926,7 +901,7 @@ class IndexedDBAdapter implements Adapter {
 							);
 
 							await this.deleteTraverse(
-								this.schema.namespaces[nameSpace].relationships[modelName]
+								this.schema.namespaces[nameSpace].relationships![modelName]
 									.relationTypes,
 								recordToDelete ? [recordToDelete] : [],
 								modelName,
@@ -941,15 +916,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);
 
@@ -960,7 +935,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,
@@ -973,7 +948,7 @@ class IndexedDBAdapter implements Adapter {
 					// Intentionally blank
 					break;
 				default:
-					exhaustiveCheck(relationType);
+					throw new Error(`Invalid relation type ${relationType}`);
 					break;
 			}
 		}
@@ -982,7 +957,7 @@ class IndexedDBAdapter implements Adapter {
 			storeName: getStorename(nameSpace, srcModel),
 			items: models.map(record =>
 				this.modelInstanceCreator(
-					this.getModelConstructorByModelName(nameSpace, srcModel),
+					this.getModelConstructorByModelName!(nameSpace, srcModel),
 					record
 				)
 			),
@@ -996,8 +971,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>(
@@ -1027,7 +1002,7 @@ class IndexedDBAdapter implements Adapter {
 				model,
 				this.schema.namespaces[namespaceName],
 				this.modelInstanceCreator,
-				this.getModelConstructorByModelName
+				this.getModelConstructorByModelName!
 			);
 
 			const keyValues = this.getIndexKeyValuesFromModel(model);
@@ -1041,7 +1016,7 @@ class IndexedDBAdapter implements Adapter {
 				const { instance } = connectedModels.find(({ instance }) => {
 					const instanceKeyValues = this.getIndexKeyValuesFromModel(instance);
 					return keysEqual(instanceKeyValues, keyValues);
-				});
+				})!;
 
 				result.push([
 					<T>(<unknown>instance),
@@ -1073,7 +1048,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;
+		return IndexedDBAdapter as Adapter;
 	}
 
-	return AsyncStorageAdapter;
+	return AsyncStorageAdapter as Adapter;
 };
 
 export default getDefaultAdapter;