@aws-amplify/datastore 3.7.4-custom-pk.79 → 3.7.4-custom-pk.87

package/src/storage/adapter/AsyncStorageAdapter.ts

@@ -65,8 +65,9 @@ export class AsyncStorageAdapter implements Adapter {
 
 	// Returns primary keys for a model
 	private getIndexKeys(namespaceName: string, modelName: string): string[] {
-		const keyPath =
-			this.schema.namespaces[namespaceName]?.keys[modelName]?.primaryKey;
+		const namespace = this.schema.namespaces[namespaceName];
+
+		const keyPath = namespace?.keys[modelName]?.primaryKey;
 
 		if (keyPath) {
 			return keyPath;
@@ -239,7 +240,8 @@ export class AsyncStorageAdapter implements Adapter {
 		}
 
 		for await (const relation of relations) {
-			const { fieldName, modelName, targetName, relationType } = relation;
+			const { fieldName, modelName, targetName, targetNames, relationType } =
+				relation;
 			const storeName = this.getStorename(namespaceName, modelName);
 			const modelConstructor = this.getModelConstructorByModelName(
 				namespaceName,
@@ -249,22 +251,84 @@ 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;
+							});
+
+							if (!allPresent) {
+								break;
+							}
+
+							getByFields = targetNames as any;
+
+							// keys are the key values
+							const keys = getByFields
+								.map(getByField => recordItem[getByField])
+								.join(DEFAULT_PRIMARY_KEY_SEPARATOR);
+
+							const connectionRecord = await this.db.get(
+								keys as any,
+								storeName
+							);
+
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+						} else {
+							const getByfield = recordItem[targetName]
+								? targetName
+								: fieldName;
+							if (!recordItem[getByfield]) break;
 
-						const key = recordItem[getByfield];
+							const key = recordItem[getByfield];
 
-						const connectionRecord = await this.db.get(key, storeName);
+							const connectionRecord = await this.db.get(key, storeName);
 
-						recordItem[fieldName] =
-							connectionRecord &&
-							this.modelInstanceCreator(modelConstructor, connectionRecord);
+							recordItem[fieldName] =
+								connectionRecord &&
+								this.modelInstanceCreator(modelConstructor, connectionRecord);
+						}
 					}
 
 					break;
 				case 'BELONGS_TO':
 					for await (const recordItem of records) {
-						if (recordItem[targetName]) {
+						// 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_SEPARATOR);
+
+							// Retrieve the connected record
+							const connectionRecord = await this.db.get(
+								keys as any,
+								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);
@@ -600,36 +664,99 @@ export class AsyncStorageAdapter implements Adapter {
 			switch (relationType) {
 				case 'HAS_ONE':
 					for await (const model of models) {
-						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] === value
-						) as T[];
-
-						await this.deleteTraverse<T>(
-							this.schema.namespaces[nameSpace].relationships[modelName]
-								.relationTypes,
-							recordToDelete,
-							modelName,
-							nameSpace,
-							deleteQueue
-						);
+						if (targetNames && targetNames?.length) {
+							const hasOneIndex = index || associatedWith;
+
+							// 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 keyValuesPath: string = this.getIndexKeyValuesPath(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 = keyValuesPath;
+							}
+
+							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[];
+							} 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] === 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) {
-						const keyValuesPath: string = this.getIndexKeyValuesPath(model);
+						// Key values for the parent model:
+						const keyValues: string[] = this.getIndexKeyValues(model);
 
 						const allRecords = await this.db.getAll(storeName);
-						const childrenArray = allRecords.filter(
-							childItem => childItem[index] === keyValuesPath
+
+						// Use constant if we go with this approach
+						const indices = index.split('-');
+
+						const childrenArray = allRecords.filter(childItem =>
+							indices.every(index => keyValues.includes(childItem[index]))
 						) as T[];
 
 						await this.deleteTraverse<T>(

package/src/storage/adapter/AsyncStorageDatabase.ts

@@ -6,7 +6,7 @@ import {
 	PersistentModel,
 	QueryOne,
 } from '../../types';
-import { monotonicUlidFactory } from '../../util';
+import { indexNameFromKeys, monotonicUlidFactory } from '../../util';
 import { createInMemoryStore } from './InMemoryStore';
 
 const DB_NAME = '@AmplifyDatastore';
@@ -96,8 +96,10 @@ class AsyncStorageDatabase {
 		keys: string[],
 		keyValuesPath: string
 	) {
+		const idxName = indexNameFromKeys(keys);
+
 		const ulid =
-			this.getCollectionIndex(storeName).get(keys[0]) ||
+			this.getCollectionIndex(storeName).get(idxName) ||
 			this.getMonotonicFactory(storeName)();
 
 		// Retrieve db key for item

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -29,7 +29,6 @@ import {
 	traverseModel,
 	validatePredicate,
 	sortCompareFunction,
-	extractTargetNamesFromSrc,
 } from '../../util';
 import { Adapter } from './index';
 
@@ -88,8 +87,9 @@ class IndexedDBAdapter implements Adapter {
 	}
 
 	private getIndexKeyPath(namespaceName: string, modelName: string): string[] {
-		const keyPath =
-			this.schema.namespaces[namespaceName]?.keys[modelName]?.primaryKey;
+		const namespace = this.schema.namespaces[namespaceName];
+
+		const keyPath = namespace?.keys[modelName]?.primaryKey;
 
 		if (keyPath) {
 			return keyPath;
@@ -102,6 +102,7 @@ class IndexedDBAdapter implements Adapter {
 		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]);
@@ -860,7 +861,6 @@ class IndexedDBAdapter implements Adapter {
 
 			const storeName = this.getStorename(nameSpace, modelName);
 
-			// Explain:
 			const index: string | string[] | undefined =
 				getIndex(
 					this.schema.namespaces[nameSpace].relationships[modelName]
@@ -909,7 +909,7 @@ class IndexedDBAdapter implements Adapter {
 							const recordToDelete = <T>await this.db
 								.transaction(storeName, 'readwrite')
 								.objectStore(storeName)
-								.index(hasOneIndex as any)
+								.index(hasOneIndex as string)
 								.get(values);
 
 							await this.deleteTraverse(
@@ -927,19 +927,14 @@ class IndexedDBAdapter implements Adapter {
 
 							const hasOneCustomField = targetName in model;
 							const keyValues = this.getIndexKeyValues(model);
-							let value = hasOneCustomField ? model[targetName] : keyValues[0];
-
-							if (hasOneIndex === 'byPk') {
-								// byPk requires an array keyValue
-								value = [value];
-							}
+							const value = hasOneCustomField ? [model[targetName]] : keyValues;
 
 							if (!value) break;
 
 							const recordToDelete = <T>await this.db
 								.transaction(storeName, 'readwrite')
 								.objectStore(storeName)
-								.index(hasOneIndex as any)
+								.index(hasOneIndex as string)
 								.get(value);
 
 							await this.deleteTraverse(
@@ -957,16 +952,11 @@ class IndexedDBAdapter implements Adapter {
 					for await (const model of models) {
 						const keyValues = this.getIndexKeyValues(model);
 
-						// CPK TODO: Double check this, unsure that we encounter `byPk` here, ever.
-						const hasManyIndex = index || 'byPk';
-
-						// CPK TODO: get by all key values
 						const childrenArray = await this.db
 							.transaction(storeName, 'readwrite')
 							.objectStore(storeName)
-							.index(hasManyIndex as any)
-							.getAll(keyValues[0]);
-						// .getAll(keyValues); // TODO
+							.index(index as string)
+							.getAll(keyValues);
 
 						await this.deleteTraverse(
 							this.schema.namespaces[nameSpace].relationships[modelName]
@@ -1080,13 +1070,12 @@ class IndexedDBAdapter implements Adapter {
 			autoIncrement: true,
 		});
 
-		const indexes =
-			this.schema.namespaces[namespaceName].relationships[modelName].indexes;
-		indexes.forEach(index => store.createIndex(index, index));
+		const { indexes } =
+			this.schema.namespaces[namespaceName].relationships[modelName];
 
-		const keyPath = this.getIndexKeyPath(namespaceName, modelName);
-
-		store.createIndex('byPk', keyPath, { unique: true });
+		indexes.forEach(([idxName, keyPath, options]) => {
+			store.createIndex(idxName, keyPath, options);
+		});
 	}
 }
 

package/src/sync/utils.ts

@@ -147,7 +147,7 @@ function getConnectionFields(
 	modelDefinition: SchemaModel,
 	namespace: SchemaNamespace
 ): string[] {
-	const result = [];
+	const result: string[] = [];
 
 	Object.values(modelDefinition.fields)
 		.filter(({ association }) => association && Object.keys(association).length)
@@ -169,11 +169,14 @@ function getConnectionFields(
 							const connectedModelName =
 								modelDefinition.fields[name].type['model'];
 
-							// keyFields are fields of the connected model
-							const keyFields = relations[connectedModelName].indexes;
+							const byPkIndex = relations[connectedModelName].indexes.find(
+								([name]) => name === 'byPk'
+							);
+							const keyFields = byPkIndex && byPkIndex[1];
+							const keyFieldSelectionSet = keyFields?.join(' ');
 
 							// We rely on `_deleted` when we process the sync query (e.g. in batchSave in the adapters)
-							result.push(`${name} { ${keyFields} _deleted }`);
+							result.push(`${name} { ${keyFieldSelectionSet} _deleted }`);
 						} else {
 							// backwards-compatability for schema generated prior to custom primary key support
 							result.push(`${name} { id _deleted }`);

package/src/types.ts

@@ -800,8 +800,17 @@ export type RelationType = {
 	associatedWith?: string | string[];
 };
 
+type IndexOptions = {
+	unique?: boolean;
+};
+
+export type IndexesType = Array<[string, string[], IndexOptions?]>;
+
 export type RelationshipType = {
-	[modelName: string]: { indexes: string[]; relationTypes: RelationType[] };
+	[modelName: string]: {
+		indexes: IndexesType;
+		relationTypes: RelationType[];
+	};
 };
 
 //#endregion

package/src/util.ts

@@ -7,7 +7,6 @@ import {
 	AllOperators,
 	isPredicateGroup,
 	isPredicateObj,
-	ModelAssociation,
 	ModelInstanceMetadata,
 	PersistentModel,
 	PersistentModelConstructor,
@@ -29,10 +28,16 @@ import {
 	LimitTimerRaceResolvedValues,
 	SchemaModel,
 	ModelAttribute,
+	IndexesType,
 } from './types';
 import { WordArray } from 'amazon-cognito-identity-js';
+
 const ID = 'id';
 
+export const errorMessages = {
+	idEmptyString: 'An index field cannot contain an empty string value',
+};
+
 export function extractKeyIfExists(
 	modelDefinition: SchemaModel
 ): ModelAttribute | undefined {
@@ -59,6 +64,15 @@ export function extractPrimaryKeyValues<T extends PersistentModel>(
 	return keyFields.map(key => model[key]);
 }
 
+export function extractPrimaryKeysAndValues<T extends PersistentModel>(
+	model: T,
+	keyFields: string[]
+): any {
+	const primaryKeysAndValues = {};
+	keyFields.forEach(key => (primaryKeysAndValues[key] = model[key]));
+	return primaryKeysAndValues;
+}
+
 // IdentifierFields<ManagedIdentifier>
 // Default behavior without explicit @primaryKey defined
 export function isIdManaged(modelDefinition: SchemaModel): boolean {
@@ -335,25 +349,13 @@ export const establishRelationAndKeys = (
 				});
 
 				if (connectionType === 'BELONGS_TO') {
-					// const targetNames: string[] = extractTargetNamesFromSrc(
-					// 	fieldAttribute.association
-					// );
-
-					// targetNames.forEach((targetName: string) => {
-					// 	relationship[mKey].indexes.push(targetName);
-					// });
-					if (fieldAttribute.association.targetName) {
-						// backwards-compatability for schema generated prior to custom primary key support
-						relationship[mKey].indexes.push(
-							fieldAttribute.association['targetName']
-						);
-					} else {
-						// iterate through fieldAttribute.association.targetNames, and push to relationship[mKey].indexes
-						fieldAttribute.association.targetNames.forEach(
-							(targetName: string) => {
-								relationship[mKey].indexes.push(targetName);
-							}
-						);
+					const targetNames = extractTargetNamesFromSrc(
+						fieldAttribute.association
+					);
+
+					if (targetNames) {
+						const idxName = indexNameFromKeys(targetNames);
+						relationship[mKey].indexes.push([idxName, targetNames]);
 					}
 				}
 			}
@@ -367,24 +369,36 @@ export const establishRelationAndKeys = (
 					continue;
 				}
 
+				const { fields } = attribute.properties;
+
 				if (isModelAttributePrimaryKey(attribute)) {
-					keys[mKey].primaryKey = attribute.properties.fields;
+					keys[mKey].primaryKey = fields;
+					continue;
 				}
 
-				const { fields } = attribute.properties;
-				for (const field of fields) {
-					// only add index if it hasn't already been added
-					const exists = relationship[mKey].indexes.includes(field);
-					if (!exists) {
-						relationship[mKey].indexes.push(field);
-					}
+				// create indexes for all other keys
+				const idxName = indexNameFromKeys(fields);
+				const idxExists = relationship[mKey].indexes.find(
+					([index]) => index === idxName
+				);
+
+				if (!idxExists) {
+					relationship[mKey].indexes.push([idxName, fields]);
 				}
 			}
+		}
 
-			if (!keys[mKey].primaryKey) {
-				keys[mKey].primaryKey = [ID];
-			}
+		// set 'id' as the PK for models without a custom PK explicitly defined
+		if (!keys[mKey].primaryKey) {
+			keys[mKey].primaryKey = [ID];
 		}
+
+		// create primary index
+		relationship[mKey].indexes.push([
+			'byPk',
+			keys[mKey].primaryKey as string[],
+			{ unique: true },
+		]);
 	});
 
 	return [relationship, keys];
@@ -572,7 +586,7 @@ export const traverseModel = <T extends PersistentModel>(
 	return result;
 };
 
-export const getIndex = (rel: RelationType[], src: any): string => {
+export const getIndex = (rel: RelationType[], src: any): string | undefined => {
 	let index = '';
 	rel.some((relItem: RelationType) => {
 		if (relItem.modelName === src) {
@@ -582,9 +596,20 @@ export const getIndex = (rel: RelationType[], src: any): string => {
 	return index;
 };
 
-export const getIndexFromAssociation = (indexes: string[], src: any): any => {
-	const index = indexes.find(idx => idx === src);
-	return index;
+export const getIndexFromAssociation = (
+	indexes: IndexesType,
+	src: string | string[]
+): string | undefined => {
+	let indexName: string;
+
+	if (Array.isArray(src)) {
+		indexName = indexNameFromKeys(src);
+	} else {
+		indexName = src;
+	}
+
+	const associationIndex = indexes.find(([idxName]) => idxName === indexName);
+	return associationIndex && associationIndex[0];
 };
 
 let privateModeCheckResult;
@@ -950,3 +975,14 @@ export function extractTargetNamesFromSrc(src: any): string[] | undefined {
 		return undefined;
 	}
 }
+
+// Generates snake-cased index name from an aray of key field names
+// E.g. for keys `[id, title]` => 'id-title'
+export function indexNameFromKeys(keys: string[]): string {
+	return keys.reduce((prev: string, cur: string, idx: number) => {
+		if (idx === 0) {
+			return cur;
+		}
+		return `${prev}-${cur}`;
+	}, '');
+}