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

package/src/storage/adapter/AsyncStorageAdapter.ts

@@ -2,7 +2,10 @@ import { ConsoleLogger as Logger } from '@aws-amplify/core';
 import AsyncStorageDatabase from './AsyncStorageDatabase';
 import { Adapter } from './index';
 import { ModelInstanceCreator } from '../../datastore/datastore';
-import { ModelPredicateCreator } from '../../predicates';
+import {
+	ModelPredicateCreator,
+	ModelSortPredicateCreator,
+} from '../../predicates';
 import {
 	InternalSchema,
 	isPredicateObj,
@@ -20,13 +23,13 @@ import {
 } from '../../types';
 import {
 	DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR,
+	exhaustiveCheck,
 	getIndex,
 	getIndexFromAssociation,
 	isModelConstructor,
 	traverseModel,
 	validatePredicate,
-	inMemoryPagination,
-	NAMESPACES,
+	sortCompareFunction,
 	keysEqual,
 	getStorename,
 	getIndexKeys,
@@ -37,21 +40,17 @@ import {
 const logger = new Logger('DataStore');
 
 export class AsyncStorageAdapter implements Adapter {
-	// Non-null assertions (bang operators) added to most properties to make TS happy.
-	// For now, we can be reasonably sure they're available when they're needed, because
-	// the adapter is not used directly outside the library boundary.
-	// TODO: rejigger for DI?
-	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!: AsyncStorageDatabase;
-	private initPromise!: Promise<void>;
-	private resolve!: (value?: any) => void;
-	private reject!: (value?: any) => void;
+	private db: AsyncStorageDatabase;
+	private initPromise: Promise<void>;
+	private resolve: (value?: any) => void;
+	private reject: (value?: any) => void;
 
 	private getStorenameForModel(
 		modelConstructor: PersistentModelConstructor<any>
@@ -89,7 +88,7 @@ export class AsyncStorageAdapter implements Adapter {
 		namespaceResolver: NamespaceResolver,
 		modelInstanceCreator: ModelInstanceCreator,
 		getModelConstructorByModelName: (
-			namsespaceName: NAMESPACES,
+			namsespaceName: string,
 			modelName: string
 		) => PersistentModelConstructor<any>
 	) {
@@ -132,7 +131,7 @@ export class AsyncStorageAdapter implements Adapter {
 			model,
 			this.schema.namespaces[namespaceName],
 			this.modelInstanceCreator,
-			this.getModelConstructorByModelName as any
+			this.getModelConstructorByModelName
 		);
 
 		const set = new Set<string>();
@@ -153,7 +152,7 @@ export class AsyncStorageAdapter 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);
 
@@ -190,16 +189,17 @@ export class AsyncStorageAdapter implements Adapter {
 				result.push([instance, opType]);
 			}
 		}
+
 		return result;
 	}
 
 	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);
 		});
@@ -214,6 +214,111 @@ export class AsyncStorageAdapter implements Adapter {
 			);
 		}
 
+		for await (const relation of relations) {
+			const { fieldName, modelName, targetName, targetNames, relationType } =
+				relation;
+			const storeName = getStorename(namespaceName, modelName);
+			const modelConstructor = this.getModelConstructorByModelName(
+				namespaceName,
+				modelName
+			);
+
+			switch (relationType) {
+				case 'HAS_ONE':
+					for await (const recordItem of records) {
+						// ASYNC CPK TODO: make this cleaner
+						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])
+								.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+
+							const connectionRecord = await this.db.get(keys, storeName);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+						} else {
+							const getByfield = recordItem[targetName]
+								? targetName
+								: fieldName;
+							if (!recordItem[getByfield]) break;
+
+							const key = recordItem[getByfield];
+
+							const connectionRecord = await this.db.get(key, storeName);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+						}
+					}
+
+					break;
+				case 'BELONGS_TO':
+					for await (const recordItem of records) {
+						// ASYNC CPK TODO: make this cleaner
+						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])
+								.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
+
+							// Retrieve the connected record
+							const connectionRecord = await this.db.get(keys, storeName);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+
+							targetNames?.map(targetName => {
+								delete recordItem[targetName];
+							});
+						} else if (recordItem[targetName as any]) {
+							const key = recordItem[targetName];
+
+							const connectionRecord = await this.db.get(key, storeName);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+							delete recordItem[targetName];
+						}
+					}
+
+					break;
+				case 'HAS_MANY':
+					// TODO: Lazy loading
+					break;
+				default:
+					exhaustiveCheck(relationType);
+					break;
+			}
+		}
+
 		return records.map(record =>
 			this.modelInstanceCreator(modelConstructor, record)
 		);
@@ -225,9 +330,7 @@ export class AsyncStorageAdapter implements Adapter {
 		pagination?: PaginationInput<T>
 	): Promise<T[]> {
 		const storeName = this.getStorenameForModel(modelConstructor);
-		const namespaceName = this.namespaceResolver(
-			modelConstructor
-		) as NAMESPACES;
+		const namespaceName = this.namespaceResolver(modelConstructor);
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
@@ -241,7 +344,7 @@ export class AsyncStorageAdapter 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] : [];
@@ -258,7 +361,7 @@ export class AsyncStorageAdapter implements Adapter {
 			}
 
 			return this.getAll(storeName);
-		})()) as T[];
+		})();
 
 		return await this.load(namespaceName, modelConstructor.name, records);
 	}
@@ -287,7 +390,7 @@ export class AsyncStorageAdapter implements Adapter {
 			return;
 		}
 
-		const keyValues = [] as any[];
+		const keyValues = [];
 
 		for (const key of keys) {
 			const predicateObj = predicateObjs.find(
@@ -321,7 +424,26 @@ export class AsyncStorageAdapter 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;
 	}
 
 	async queryOne<T extends PersistentModel>(
@@ -341,15 +463,14 @@ export class AsyncStorageAdapter 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);
 
 			// models to be deleted.
-			const models = await this.query(modelConstructor, condition!);
+			const models = await this.query(modelConstructor, condition);
 			// TODO: refactor this to use a function like getRelations()
 			const relations =
-				this.schema.namespaces[nameSpace].relationships![modelConstructor.name]
+				this.schema.namespaces[nameSpace].relationships[modelConstructor.name]
 					.relationTypes;
 
 			if (condition !== undefined) {
@@ -388,11 +509,11 @@ export class AsyncStorageAdapter implements Adapter {
 				return [models, deletedModels];
 			}
 		} else {
-			const model = modelOrModelConstructor as T;
+			const model = modelOrModelConstructor;
 
 			const modelConstructor = Object.getPrototypeOf(model)
 				.constructor as PersistentModelConstructor<T>;
-			const nameSpace = this.namespaceResolver(modelConstructor) as NAMESPACES;
+			const namespaceName = this.namespaceResolver(modelConstructor);
 
 			const storeName = this.getStorenameForModel(modelConstructor);
 
@@ -409,7 +530,7 @@ export class AsyncStorageAdapter implements Adapter {
 				}
 
 				const predicates = ModelPredicateCreator.getPredicates(condition);
-				const { predicates: predicateObjs, type } = predicates!;
+				const { predicates: predicateObjs, type } = predicates;
 
 				const isValid = validatePredicate(fromDB, type, predicateObjs);
 				if (!isValid) {
@@ -420,19 +541,20 @@ export class AsyncStorageAdapter implements Adapter {
 				}
 
 				const relations =
-					this.schema.namespaces[nameSpace].relationships![
+					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![
+					this.schema.namespaces[namespaceName].relationships[
 						modelConstructor.name
 					].relationTypes;
 
@@ -440,7 +562,7 @@ export class AsyncStorageAdapter implements Adapter {
 					relations,
 					[model],
 					modelConstructor.name,
-					nameSpace,
+					namespaceName,
 					deleteQueue
 				);
 			}
@@ -459,7 +581,7 @@ export class AsyncStorageAdapter implements Adapter {
 	private async deleteItem<T extends PersistentModel>(
 		deleteQueue?: { storeName: string; items: T[] | IDBValidKey[] }[]
 	) {
-		for await (const deleteItem of deleteQueue!) {
+		for await (const deleteItem of deleteQueue) {
 			const { storeName, items } = deleteItem;
 
 			for await (const item of items) {
@@ -472,7 +594,6 @@ export class AsyncStorageAdapter implements Adapter {
 			}
 		}
 	}
-
 	/**
 	 * Populates the delete Queue with all the items to delete
 	 * @param relations
@@ -485,7 +606,7 @@ export class AsyncStorageAdapter 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) {
@@ -500,7 +621,7 @@ export class AsyncStorageAdapter implements Adapter {
 
 			const index: string | undefined =
 				getIndex(
-					this.schema.namespaces[nameSpace].relationships![modelName]
+					this.schema.namespaces[nameSpace].relationships[modelName]
 						.relationTypes,
 					srcModel
 				) ||
@@ -508,8 +629,8 @@ export class AsyncStorageAdapter implements Adapter {
 				// i.e. for keyName connections, attempt to find one by the
 				// associatedWith property
 				getIndexFromAssociation(
-					this.schema.namespaces[nameSpace].relationships![modelName].indexes,
-					rel.associatedWith!
+					this.schema.namespaces[nameSpace].relationships[modelName].indexes,
+					rel.associatedWith
 				);
 
 			switch (relationType) {
@@ -581,7 +702,7 @@ export class AsyncStorageAdapter implements Adapter {
 							}
 
 							await this.deleteTraverse<T>(
-								this.schema.namespaces[nameSpace].relationships![modelName]
+								this.schema.namespaces[nameSpace].relationships[modelName]
 									.relationTypes,
 								recordToDelete,
 								modelName,
@@ -590,10 +711,10 @@ export class AsyncStorageAdapter implements Adapter {
 							);
 						} else {
 							const hasOneIndex = index || associatedWith;
-							const hasOneCustomField = targetName! in model;
+							const hasOneCustomField = targetName in model;
 							const keyValuesPath: string = this.getIndexKeyValuesPath(model);
 							const value = hasOneCustomField
-								? model[targetName!]
+								? model[targetName]
 								: keyValuesPath;
 
 							if (!value) break;
@@ -605,7 +726,7 @@ export class AsyncStorageAdapter implements Adapter {
 							) as T[];
 
 							await this.deleteTraverse<T>(
-								this.schema.namespaces[nameSpace].relationships![modelName]
+								this.schema.namespaces[nameSpace].relationships[modelName]
 									.relationTypes,
 								recordToDelete,
 								modelName,
@@ -622,14 +743,14 @@ export class AsyncStorageAdapter implements Adapter {
 
 						const allRecords = await this.db.getAll(storeName);
 
-						const indices = index!.split(IDENTIFIER_KEY_SEPARATOR);
+						const indices = index.split(IDENTIFIER_KEY_SEPARATOR);
 
 						const childrenArray = allRecords.filter(childItem =>
 							indices.every(index => keyValues.includes(childItem[index]))
 						) as T[];
 
 						await this.deleteTraverse<T>(
-							this.schema.namespaces[nameSpace].relationships![modelName]
+							this.schema.namespaces[nameSpace].relationships[modelName]
 								.relationTypes,
 							childrenArray,
 							modelName,
@@ -642,7 +763,8 @@ export class AsyncStorageAdapter implements Adapter {
 					// Intentionally blank
 					break;
 				default:
-					throw new Error(`Invalid relationType ${relationType}`);
+					exhaustiveCheck(relationType);
+					break;
 			}
 		}
 
@@ -660,8 +782,8 @@ export class AsyncStorageAdapter implements Adapter {
 	async clear(): Promise<void> {
 		await this.db.clear();
 
-		this.db = undefined!;
-		this.initPromise = undefined!;
+		this.db = undefined;
+		this.initPromise = undefined;
 	}
 
 	async batchSave<T extends PersistentModel>(
@@ -690,7 +812,7 @@ export class AsyncStorageAdapter implements Adapter {
 			const { instance } = connectedModels.find(({ instance }) => {
 				const instanceKeyValuesPath = this.getIndexKeyValuesPath(instance);
 				return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
-			})!;
+			});
 
 			batch.push(instance);
 		}

package/src/storage/adapter/AsyncStorageDatabase.ts

@@ -50,7 +50,7 @@ class AsyncStorageDatabase {
 			monotonicFactoriesMap.set(storeName, monotonicUlidFactory());
 		}
 
-		return monotonicFactoriesMap.get(storeName)!;
+		return monotonicFactoriesMap.get(storeName);
 	}
 
 	async init(): Promise<void> {
@@ -58,7 +58,7 @@ class AsyncStorageDatabase {
 
 		const allKeys: string[] = await this.storage.getAllKeys();
 
-		const keysForCollectionEntries: string[] = [];
+		const keysForCollectionEntries = [];
 
 		for (const key of allKeys) {
 			const [dbName, storeName, recordType, ulidOrId, id] = key.split('::');
@@ -79,7 +79,7 @@ class AsyncStorageDatabase {
 
 						const item = await this.storage.getItem(oldKey);
 
-						await this.storage.setItem(newKey, item!);
+						await this.storage.setItem(newKey, item);
 						await this.storage.removeItem(oldKey);
 
 						ulid = newUlid;
@@ -87,7 +87,7 @@ class AsyncStorageDatabase {
 						ulid = ulidOrId;
 					}
 
-					this.getCollectionIndex(storeName)!.set(id, ulid);
+					this.getCollectionIndex(storeName).set(id, ulid);
 				} else if (recordType === COLLECTION) {
 					keysForCollectionEntries.push(key);
 				}
@@ -108,14 +108,14 @@ class AsyncStorageDatabase {
 		const idxName = indexNameFromKeys(keys);
 
 		const ulid =
-			this.getCollectionIndex(storeName)?.get(idxName) ||
+			this.getCollectionIndex(storeName).get(idxName) ||
 			this.getMonotonicFactory(storeName)();
 
 		// Retrieve db key for item
 		const itemKey = this.getKeyForItem(storeName, keyValuesPath, ulid);
 
 		// Set key in collection index
-		this.getCollectionIndex(storeName)?.set(keyValuesPath, ulid);
+		this.getCollectionIndex(storeName).set(keyValuesPath, ulid);
 
 		// Save item in db
 		await this.storage.setItem(itemKey, JSON.stringify(item));
@@ -131,12 +131,11 @@ class AsyncStorageDatabase {
 		}
 
 		const result: [T, OpType][] = [];
-
-		const collection = this.getCollectionIndex(storeName)!;
+		const collection = this.getCollectionIndex(storeName);
 
 		const keysToDelete = new Set<string>();
 		const keysToSave = new Set<string>();
-		const allItemsKeys: string[] = [];
+		const allItemsKeys = [];
 		const itemsMap: Record<string, { ulid: string; model: T }> = {};
 
 		/* Populate allItemKeys, keysToDelete, and keysToSave */
@@ -253,7 +252,7 @@ class AsyncStorageDatabase {
 		keyValuePath: string,
 		storeName: string
 	): Promise<T> {
-		const ulid = this.getCollectionIndex(storeName)!.get(keyValuePath)!;
+		const ulid = this.getCollectionIndex(storeName).get(keyValuePath);
 		const itemKey = this.getKeyForItem(storeName, keyValuePath, ulid);
 		const recordAsString = await this.storage.getItem(itemKey);
 		const record = recordAsString && JSON.parse(recordAsString);
@@ -261,19 +260,19 @@ class AsyncStorageDatabase {
 	}
 
 	async getOne(firstOrLast: QueryOne, storeName: string) {
-		const collection = this.getCollectionIndex(storeName)!;
+		const collection = this.getCollectionIndex(storeName);
 
 		const [itemId, ulid] =
 			firstOrLast === QueryOne.FIRST
 				? (() => {
 						let id: string, ulid: string;
 						for ([id, ulid] of collection) break; // Get first element of the set
-						return [id!, ulid!];
+						return [id, ulid];
 				  })()
 				: (() => {
 						let id: string, ulid: string;
 						for ([id, ulid] of collection); // Get last element of the set
-						return [id!, ulid!];
+						return [id, ulid];
 				  })();
 		const itemKey = this.getKeyForItem(storeName, itemId, ulid);
 
@@ -292,7 +291,7 @@ class AsyncStorageDatabase {
 		storeName: string,
 		pagination?: PaginationInput<T>
 	): Promise<T[]> {
-		const collection = this.getCollectionIndex(storeName)!;
+		const collection = this.getCollectionIndex(storeName);
 
 		const { page = 0, limit = 0 } = pagination || {};
 		const start = Math.max(0, page * limit) || 0;
@@ -323,9 +322,9 @@ class AsyncStorageDatabase {
 	}
 
 	async delete(key: string, storeName: string) {
-		const ulid = this.getCollectionIndex(storeName)!.get(key)!;
+		const ulid = this.getCollectionIndex(storeName).get(key);
 		const itemKey = this.getKeyForItem(storeName, key, ulid);
-		this.getCollectionIndex(storeName)!.delete(key);
+		this.getCollectionIndex(storeName).delete(key);
 		await this.storage.removeItem(itemKey);
 	}
 

package/src/storage/adapter/InMemoryStore.ts

@@ -6,14 +6,11 @@ export class InMemoryStore {
 	};
 
 	multiGet = async (keys: string[]) => {
-		return keys.reduce(
-			(res, k) => (res.push([k, this.db.get(k)!]), res),
-			[] as [string, string][]
-		);
+		return keys.reduce((res, k) => (res.push([k, this.db.get(k)]), res), []);
 	};
 
 	multiRemove = async (keys: string[], callback?) => {
-		keys.forEach((k) => this.db.delete(k));
+		keys.forEach(k => this.db.delete(k));
 
 		typeof callback === 'function' && callback();
 	};