@aws-amplify/datastore 3.12.12 → 3.12.13-ds-allow-applicable-data.6

package/src/predicates/index.ts

@@ -8,7 +8,11 @@ import {
 	ProducerModelPredicate,
 	SchemaModel,
 } from '../types';
-import { exhaustiveCheck } from '../util';
+import {
+	exhaustiveCheck,
+	extractPrimaryKeyFieldNames,
+	extractPrimaryKeyValues,
+} from '../util';
 
 export { ModelSortPredicateCreator } from './sort';
 
@@ -85,7 +89,7 @@ export class ModelPredicateCreator {
 
 								// Push the group to the top-level recorder
 								ModelPredicateCreator.predicateGroupsMap
-									.get(receiver)
+									.get(receiver)!
 									.predicates.push(group);
 
 								return receiver;
@@ -109,7 +113,7 @@ export class ModelPredicateCreator {
 						operand: any
 					) => {
 						ModelPredicateCreator.predicateGroupsMap
-							.get(receiver)
+							.get(receiver)!
 							.predicates.push({ field, operator, operand });
 						return receiver;
 					};
@@ -147,7 +151,7 @@ export class ModelPredicateCreator {
 	// transforms cb-style predicate into Proxy
 	static createFromExisting<T extends PersistentModel>(
 		modelDefinition: SchemaModel,
-		existing: ProducerModelPredicate<T>
+		existing?: ProducerModelPredicate<T>
 	) {
 		if (!existing || !modelDefinition) {
 			return undefined;
@@ -158,13 +162,31 @@ export class ModelPredicateCreator {
 		);
 	}
 
-	static createForId<T extends PersistentModel>(
+	static createForSingleField<T extends PersistentModel>(
 		modelDefinition: SchemaModel,
-		id: string
+		fieldName: string,
+		value: string
 	) {
-		return ModelPredicateCreator.createPredicateBuilder<T>(modelDefinition).id(
-			'eq',
-			<any>id
-		);
+		return ModelPredicateCreator.createPredicateBuilder<T>(modelDefinition)[
+			fieldName
+		](<any>'eq', <any>value);
+	}
+
+	static createForPk<T extends PersistentModel>(
+		modelDefinition: SchemaModel,
+		model: T
+	) {
+		const keyFields = extractPrimaryKeyFieldNames(modelDefinition);
+		const keyValues = extractPrimaryKeyValues(model, keyFields);
+
+		let modelPredicate =
+			ModelPredicateCreator.createPredicateBuilder<T>(modelDefinition);
+
+		keyFields.forEach((field, idx) => {
+			const operand = keyValues[idx];
+			modelPredicate = modelPredicate[field](<any>'eq', <any>operand);
+		});
+
+		return modelPredicate;
 	}
 }

package/src/storage/adapter/AsyncStorageAdapter.ts

@@ -22,6 +22,7 @@ import {
 	RelationType,
 } from '../../types';
 import {
+	DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR,
 	exhaustiveCheck,
 	getIndex,
 	getIndexFromAssociation,
@@ -29,6 +30,11 @@ import {
 	traverseModel,
 	validatePredicate,
 	sortCompareFunction,
+	keysEqual,
+	getStorename,
+	getIndexKeys,
+	extractPrimaryKeyValues,
+	IDENTIFIER_KEY_SEPARATOR,
 } from '../../util';
 
 const logger = new Logger('DataStore');
@@ -52,13 +58,29 @@ export class AsyncStorageAdapter implements Adapter {
 		const namespace = this.namespaceResolver(modelConstructor);
 		const { name: modelName } = modelConstructor;
 
-		return this.getStorename(namespace, modelName);
+		return getStorename(namespace, modelName);
 	}
 
-	private getStorename(namespace: string, modelName: string) {
-		const storeName = `${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);
+	}
 
-		return storeName;
+	// Retrieves concatenated primary key values from a model
+	private getIndexKeyValuesPath<T extends PersistentModel>(model: T): string {
+		return this.getIndexKeyValuesFromModel(model).join(
+			DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR
+		);
 	}
 
 	async setUp(
@@ -101,23 +123,32 @@ export class AsyncStorageAdapter 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 };
 			}
 		);
-		const fromDB = await this.db.get(model.id, storeName);
+		const keyValuesPath = this.getIndexKeyValuesPath(model);
+
+		const fromDB = await this.db.get(keyValuesPath, storeName);
 
 		if (condition && fromDB) {
 			const predicates = ModelPredicateCreator.getPredicates(condition);
@@ -136,14 +167,24 @@ export class AsyncStorageAdapter implements Adapter {
 		const result: [T, OpType.INSERT | OpType.UPDATE][] = [];
 
 		for await (const resItem of connectionStoreNames) {
-			const { storeName, item, instance } = resItem;
-			const { id } = item;
+			const { storeName, item, instance, keys } = resItem;
+
+			/* Find the key values in the item, and concatenate them */
+			const itemKeyValues: string[] = keys.map(key => item[key]);
+			const itemKeyValuesPath: string = itemKeyValues.join(
+				DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR
+			);
 
-			const fromDB = <T>await this.db.get(id, storeName);
+			const fromDB = <T>await this.db.get(itemKeyValuesPath, storeName);
 			const opType: OpType = fromDB ? OpType.UPDATE : OpType.INSERT;
+			const modelKeyValues = this.getIndexKeyValuesFromModel(model);
 
-			if (id === model.id || opType === OpType.INSERT) {
-				await this.db.save(item, storeName);
+			// If item key values and model key values are equal, save to db
+			if (
+				keysEqual(itemKeyValues, modelKeyValues) ||
+				opType === OpType.INSERT
+			) {
+				await this.db.save(item, storeName, keys, itemKeyValuesPath);
 
 				result.push([instance, opType]);
 			}
@@ -160,7 +201,7 @@ export class AsyncStorageAdapter 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,
@@ -174,8 +215,9 @@ export class AsyncStorageAdapter implements Adapter {
 		}
 
 		for await (const relation of relations) {
-			const { fieldName, modelName, targetName, relationType } = relation;
-			const storeName = this.getStorename(namespaceName, modelName);
+			const { fieldName, modelName, targetName, targetNames, relationType } =
+				relation;
+			const storeName = getStorename(namespaceName, modelName);
 			const modelConstructor = this.getModelConstructorByModelName(
 				namespaceName,
 				modelName
@@ -184,27 +226,81 @@ export class AsyncStorageAdapter implements Adapter {
 			switch (relationType) {
 				case 'HAS_ONE':
 					for await (const recordItem of records) {
-						const getByfield = recordItem[targetName] ? targetName : fieldName;
-						if (!recordItem[getByfield]) break;
+						// 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;
+							});
 
-						const connectionRecord = await this.db.get(
-							recordItem[getByfield],
-							storeName
-						);
+							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);
+							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) {
-						if (recordItem[targetName]) {
-							const connectionRecord = await this.db.get(
-								recordItem[targetName],
-								storeName
-							);
+						// 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 &&
@@ -238,13 +334,19 @@ export class AsyncStorageAdapter implements Adapter {
 
 		const predicates =
 			predicate && ModelPredicateCreator.getPredicates(predicate);
-		const queryById = predicates && this.idFromPredicate(predicates);
+		const keys = getIndexKeys(
+			this.schema.namespaces[namespaceName],
+			modelConstructor.name
+		);
+		const queryByKey =
+			predicates && this.keyValueFromPredicate(predicates, keys);
+
 		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] : [];
 			}
 
@@ -264,11 +366,11 @@ export class AsyncStorageAdapter 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
+		keyValuePath: string
 	): Promise<T> {
-		const record = <T>await this.db.get(id, storeName);
+		const record = <T>await this.db.get(keyValuePath, storeName);
 		return record;
 	}
 
@@ -278,17 +380,29 @@ export class AsyncStorageAdapter implements Adapter {
 		return await this.db.getAll(storeName);
 	}
 
-	private idFromPredicate<T extends PersistentModel>(
-		predicates: PredicatesGroup<T>
-	) {
+	private keyValueFromPredicate<T extends PersistentModel>(
+		predicates: PredicatesGroup<T>,
+		keys: 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 !== keys.length) {
+			return;
+		}
+
+		const keyValues = [];
+
+		for (const key of keys) {
+			const predicateObj = predicateObjs.find(
+				p => isPredicateObj(p) && p.field === key && p.operator === 'eq'
+			) as PredicateObject<T>;
+
+			predicateObj && keyValues.push(predicateObj.operand);
+		}
+
+		return keyValues.length === keys.length
+			? keyValues.join(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR)
+			: undefined;
 	}
 
 	private async filterOnPredicate<T extends PersistentModel>(
@@ -328,6 +442,7 @@ export class AsyncStorageAdapter implements Adapter {
 
 			return records.slice(start, end);
 		}
+
 		return records;
 	}
 
@@ -337,6 +452,7 @@ export class AsyncStorageAdapter implements Adapter {
 	): Promise<T | undefined> {
 		const storeName = this.getStorenameForModel(modelConstructor);
 		const result = <T>await this.db.getOne(firstOrLast, storeName);
+
 		return result && this.modelInstanceCreator(modelConstructor, result);
 	}
 
@@ -372,6 +488,7 @@ export class AsyncStorageAdapter implements Adapter {
 					(acc, { items }) => acc.concat(items),
 					<T[]>[]
 				);
+
 				return [models, deletedModels];
 			} else {
 				await this.deleteTraverse(
@@ -396,12 +513,14 @@ export class AsyncStorageAdapter 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 fromDB = await this.db.get(model.id, storeName);
+				const keyValuePath = this.getIndexKeyValuesPath(model);
+
+				const fromDB = await this.db.get(keyValuePath, storeName);
 
 				if (fromDB === undefined) {
 					const msg = 'Model instance not found in storage';
@@ -422,25 +541,28 @@ export class AsyncStorageAdapter implements Adapter {
 				}
 
 				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
 				);
 			}
@@ -465,8 +587,8 @@ export class AsyncStorageAdapter implements Adapter {
 			for await (const item of items) {
 				if (item) {
 					if (typeof item === 'object') {
-						const id = item['id'];
-						await this.db.delete(id, storeName);
+						const keyValuesPath: string = this.getIndexKeyValuesPath(item as T);
+						await this.db.delete(keyValuesPath, storeName);
 					}
 				}
 			}
@@ -488,10 +610,16 @@ export class AsyncStorageAdapter implements Adapter {
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
 		for await (const rel of relations) {
-			const { relationType, modelName, targetName } = rel;
-			const storeName = this.getStorename(nameSpace, modelName);
-
-			const index: string =
+			const {
+				relationType,
+				modelName,
+				targetName,
+				targetNames,
+				associatedWith,
+			} = rel;
+			const storeName = getStorename(nameSpace, modelName);
+
+			const index: string | undefined =
 				getIndex(
 					this.schema.namespaces[nameSpace].relationships[modelName]
 						.relationTypes,
@@ -508,35 +636,120 @@ export class AsyncStorageAdapter implements Adapter {
 			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 allRecords = await this.db.getAll(storeName);
-						const recordToDelete = allRecords.filter(
-							childItem => childItem[hasOneIndex] === value
-						);
+						if (targetNames && targetNames?.length) {
+							let hasOneIndex;
+
+							if (index) {
+								hasOneIndex = index.split(IDENTIFIER_KEY_SEPARATOR);
+							} else if (associatedWith) {
+								if (Array.isArray(associatedWith)) {
+									hasOneIndex = associatedWith;
+								} else {
+									hasOneIndex = [associatedWith];
+								}
+							}
+
+							// iterate over targetNames array and see if each key is present in model object
+							// targetNames here being the keys for the CHILD model
+							const hasConnectedModelFields = targetNames.every(targetName =>
+								model.hasOwnProperty(targetName)
+							);
 
-						await this.deleteTraverse(
-							this.schema.namespaces[nameSpace].relationships[modelName]
-								.relationTypes,
-							recordToDelete,
-							modelName,
-							nameSpace,
-							deleteQueue
-						);
+							// PK / Composite key for the parent model
+							const keyValuesPath: string = this.getIndexKeyValuesPath(model);
+
+							let values;
+
+							const isUnidirectionalConnection = hasOneIndex === associatedWith;
+
+							if (hasConnectedModelFields && isUnidirectionalConnection) {
+								// 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 = keyValuesPath.split(
+									DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR
+								);
+							}
+
+							if (values.length === 0) break;
+
+							const allRecords = await this.db.getAll(storeName);
+
+							let recordToDelete;
+
+							// values === targetNames
+							if (hasConnectedModelFields) {
+								/**
+								 * Retrieve record by finding the record where all
+								 * targetNames are present on the connected model.
+								 *
+								 */
+								// recordToDelete = allRecords.filter(childItem =>
+								// 	values.every(value => childItem[value] != null)
+								// ) as T[];
+
+								recordToDelete = allRecords.filter(childItem =>
+									hasOneIndex.every(index => values.includes(childItem[index]))
+								);
+							} else {
+								// values === keyValuePath
+								recordToDelete = allRecords.filter(
+									childItem => childItem[hasOneIndex] === values
+								) as T[];
+							}
+
+							await this.deleteTraverse<T>(
+								this.schema.namespaces[nameSpace].relationships[modelName]
+									.relationTypes,
+								recordToDelete,
+								modelName,
+								nameSpace,
+								deleteQueue
+							);
+						} else {
+							const hasOneIndex = index || associatedWith;
+							const hasOneCustomField = targetName in model;
+							const keyValuesPath: string = this.getIndexKeyValuesPath(model);
+							const value = hasOneCustomField
+								? model[targetName]
+								: keyValuesPath;
+
+							if (!value) break;
+
+							const allRecords = await this.db.getAll(storeName);
+
+							const recordToDelete = allRecords.filter(
+								childItem => childItem[hasOneIndex as string] === value
+							) as T[];
+
+							await this.deleteTraverse<T>(
+								this.schema.namespaces[nameSpace].relationships[modelName]
+									.relationTypes,
+								recordToDelete,
+								modelName,
+								nameSpace,
+								deleteQueue
+							);
+						}
 					}
 					break;
 				case 'HAS_MANY':
 					for await (const model of models) {
+						// Key values for the parent model:
+						const keyValues: string[] = this.getIndexKeyValuesFromModel(model);
+
 						const allRecords = await this.db.getAll(storeName);
-						const childrenArray = allRecords.filter(
-							childItem => childItem[index] === model.id
-						);
 
-						await this.deleteTraverse(
+						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]
 								.relationTypes,
 							childrenArray,
@@ -556,7 +769,7 @@ export class AsyncStorageAdapter implements Adapter {
 		}
 
 		deleteQueue.push({
-			storeName: this.getStorename(nameSpace, srcModel),
+			storeName: getStorename(nameSpace, srcModel),
 			items: models.map(record =>
 				this.modelInstanceCreator(
 					this.getModelConstructorByModelName(nameSpace, srcModel),
@@ -579,29 +792,32 @@ export class AsyncStorageAdapter implements Adapter {
 	): Promise<[T, OpType][]> {
 		const { name: modelName } = modelConstructor;
 		const namespaceName = this.namespaceResolver(modelConstructor);
-		const storeName = this.getStorename(namespaceName, modelName);
-
+		const storeName = getStorename(namespaceName, modelName);
+		const keys = getIndexKeys(this.schema.namespaces[namespaceName], modelName);
 		const batch: ModelInstanceMetadata[] = [];
 
 		for (const item of items) {
-			const { id } = item;
+			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 { instance } = connectedModels.find(
-				({ instance }) => instance.id === id
-			);
+			const keyValuesPath = this.getIndexKeyValuesPath(model);
+
+			const { instance } = connectedModels.find(({ instance }) => {
+				const instanceKeyValuesPath = this.getIndexKeyValuesPath(instance);
+				return keysEqual([instanceKeyValuesPath], [keyValuesPath]);
+			});
 
 			batch.push(instance);
 		}
 
-		return await this.db.batchSave(storeName, batch);
+		return await this.db.batchSave(storeName, batch, keys);
 	}
 }