@aws-amplify/datastore 4.1.5 → 4.1.6-lerna-upgrade.4

package/src/storage/adapter/AsyncStorageAdapter.ts

@@ -8,20 +8,15 @@ import {
 	PersistentModelConstructor,
 	PredicatesGroup,
 	QueryOne,
-	RelationType,
 } from '../../types';
 import {
 	DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR,
-	getIndex,
-	getIndexFromAssociation,
 	traverseModel,
 	validatePredicate,
 	inMemoryPagination,
-	NAMESPACES,
 	keysEqual,
 	getStorename,
 	getIndexKeys,
-	IDENTIFIER_KEY_SEPARATOR,
 } from '../../util';
 import { StorageAdapterBase } from './StorageAdapterBase';
 
@@ -235,163 +230,6 @@ export class AsyncStorageAdapter extends StorageAdapterBase {
 		}
 	}
 
-	/**
-	 * Gets related Has One record for `model`
-	 *
-	 * @param model
-	 * @param srcModel
-	 * @param namespace
-	 * @param rel
-	 * @returns
-	 */
-	protected async getHasOneChild<T extends PersistentModel>(
-		model: T,
-		srcModel: string,
-		namespace: NAMESPACES,
-		rel: RelationType
-	) {
-		let hasOneIndex;
-		const { modelName, targetNames, associatedWith } = rel;
-		const storeName = getStorename(namespace, modelName);
-		const index: string | undefined =
-			getIndex(
-				this.schema.namespaces[namespace].relationships![modelName]
-					.relationTypes,
-				srcModel
-			) ||
-			// if we were unable to find an index via relationTypes
-			// i.e. for keyName connections, attempt to find one by the
-			// associatedWith property
-			getIndexFromAssociation(
-				this.schema.namespaces[namespace].relationships![modelName].indexes,
-				rel.associatedWith!
-			);
-
-		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)
-		);
-
-		// 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!
-				.filter(targetName => model[targetName] ?? false)
-				.map(targetName => model[targetName]);
-		} else {
-			// values will be that of the parent model
-			values = keyValuesPath.split(DEFAULT_PRIMARY_KEY_VALUE_SEPARATOR);
-		}
-
-		if (values.length === 0) return;
-
-		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.find(childItem =>
-				hasOneIndex.every(index => values.includes(childItem[index]))
-			);
-		} else {
-			// values === keyValuePath
-			recordToDelete = allRecords.find(
-				childItem => childItem[hasOneIndex] === values
-			) as T[];
-		}
-
-		return recordToDelete;
-	}
-
-	/**
-	 * Backwards compatability for pre-CPK codegen
-	 * TODO - deprecate this in v6; will need to re-gen MIPR for older unit
-	 * tests that hit this path
-	 */
-	protected async getHasOneChildLegacy<T extends PersistentModel>(
-		model: T,
-		srcModel: string,
-		namespace: NAMESPACES,
-		rel: RelationType
-	) {
-		const { modelName, targetName, associatedWith } = rel;
-		const storeName = getStorename(namespace, modelName);
-		const index: string | undefined =
-			getIndex(
-				this.schema.namespaces[namespace].relationships![modelName]
-					.relationTypes,
-				srcModel
-			) ||
-			// if we were unable to find an index via relationTypes
-			// i.e. for keyName connections, attempt to find one by the
-			// associatedWith property
-			getIndexFromAssociation(
-				this.schema.namespaces[namespace].relationships![modelName].indexes,
-				rel.associatedWith!
-			);
-		const hasOneIndex = index || associatedWith;
-		const hasOneCustomField = targetName! in model;
-		const keyValuesPath: string = this.getIndexKeyValuesPath(model);
-		const value = hasOneCustomField ? model[targetName!] : keyValuesPath;
-
-		if (!value) return;
-
-		const allRecords = await this.db.getAll(storeName);
-
-		const recordToDelete = allRecords.find(
-			childItem => childItem[hasOneIndex as string] === value
-		) as T;
-
-		return recordToDelete;
-	}
-
-	/**
-	 *  Gets related Has Many records by given `storeName`, `index`, and `keyValues`
-	 *
-	 * @param storeName
-	 * @param index
-	 * @param keyValues
-	 * @returns
-	 */
-	protected async getHasManyChildren<T extends PersistentModel>(
-		storeName: string,
-		index: string,
-		keyValues: string[]
-	): Promise<T[]> {
-		const allRecords = await this.db.getAll(storeName);
-		const indices = index!.split(IDENTIFIER_KEY_SEPARATOR);
-
-		const childRecords = allRecords.filter(childItem =>
-			indices.every(index => keyValues.includes(childItem[index]))
-		) as T[];
-
-		return childRecords;
-	}
-
 	//#region platform-specific helper methods
 
 	/**

package/src/storage/adapter/IndexedDBAdapter.ts

@@ -12,15 +12,12 @@ import {
 	PredicateObject,
 	PredicatesGroup,
 	QueryOne,
-	RelationType,
 } from '../../types';
 import {
-	getIndex,
 	isPrivateMode,
 	traverseModel,
 	validatePredicate,
 	inMemoryPagination,
-	NAMESPACES,
 	keysEqual,
 	getStorename,
 	isSafariCompatabilityMode,
@@ -384,7 +381,7 @@ class IndexedDBAdapter extends StorageAdapterBase {
 	}
 
 	protected async deleteItem<T extends PersistentModel>(
-		deleteQueue?: {
+		deleteQueue: {
 			storeName: string;
 			items: T[] | IDBValidKey[];
 		}[]
@@ -420,112 +417,6 @@ class IndexedDBAdapter extends StorageAdapterBase {
 		}
 	}
 
-	/**
-	 * Gets related Has One record for `model`
-	 *
-	 * @param model
-	 * @param srcModel
-	 * @param namespace
-	 * @param rel
-	 * @returns
-	 */
-	protected async getHasOneChild<T extends PersistentModel>(
-		model: T,
-		srcModel: string,
-		namespace: NAMESPACES,
-		rel: RelationType
-	) {
-		const hasOneIndex = 'byPk';
-		const { modelName, targetNames } = rel;
-		const storeName = getStorename(namespace, modelName);
-
-		const values = targetNames!
-			.filter(targetName => model[targetName] ?? false)
-			.map(targetName => model[targetName]);
-
-		if (values.length === 0) return;
-
-		const recordToDelete = <T>(
-			await this.db
-				.transaction(storeName, 'readwrite')
-				.objectStore(storeName)
-				.index(hasOneIndex)
-				.get(this.canonicalKeyPath(values))
-		);
-
-		return recordToDelete;
-	}
-
-	/**
-	 * Backwards compatability for pre-CPK codegen
-	 * TODO - deprecate this in v6; will need to re-gen MIPR for older unit
-	 * tests that hit this path
-	 */
-	protected async getHasOneChildLegacy<T extends PersistentModel>(
-		model: T,
-		srcModel: string,
-		namespace: NAMESPACES,
-		rel: RelationType
-	) {
-		const hasOneIndex = 'byPk';
-		const { modelName, targetName } = rel;
-		const storeName = getStorename(namespace, modelName);
-
-		let index;
-		let values: string[];
-
-		if (targetName && targetName in model) {
-			index = hasOneIndex;
-			const value = model[targetName];
-			if (value === null) {
-				return;
-			}
-			values = [value];
-		} else {
-			// backwards compatability for older versions of codegen that did not emit targetName for HAS_ONE relations
-			index = getIndex(
-				this.schema.namespaces[namespace].relationships![modelName]
-					.relationTypes,
-				srcModel
-			);
-			values = this.getIndexKeyValuesFromModel(model);
-		}
-
-		if (!values || !index) return;
-
-		const recordToDelete = <T>(
-			await this.db
-				.transaction(storeName, 'readwrite')
-				.objectStore(storeName)
-				.index(index)
-				.get(this.canonicalKeyPath(values))
-		);
-
-		return recordToDelete;
-	}
-
-	/**
-	 * Gets related Has Many records by given `storeName`, `index`, and `keyValues`
-	 *
-	 * @param storeName
-	 * @param index
-	 * @param keyValues
-	 * @returns
-	 */
-	protected async getHasManyChildren<T extends PersistentModel>(
-		storeName: string,
-		index: string,
-		keyValues: string[]
-	): Promise<T[]> {
-		const childRecords = await this.db
-			.transaction(storeName, 'readwrite')
-			.objectStore(storeName)
-			.index(index as string)
-			.getAll(this.canonicalKeyPath(keyValues));
-
-		return childRecords;
-	}
-
 	//#region platform-specific helper methods
 
 	private async checkPrivate() {

package/src/storage/adapter/StorageAdapterBase.ts

@@ -15,7 +15,6 @@ import {
 	PredicateObject,
 	PredicatesGroup,
 	QueryOne,
-	RelationType,
 } from '../../types';
 import {
 	NAMESPACES,
@@ -24,12 +23,12 @@ import {
 	extractPrimaryKeyValues,
 	traverseModel,
 	validatePredicate,
-	getIndex,
-	getIndexFromAssociation,
 	isModelConstructor,
+	extractPrimaryKeyFieldNames,
 } from '../../util';
 import type { IDBPDatabase, IDBPObjectStore } from 'idb';
 import type AsyncStorageDatabase from './AsyncStorageDatabase';
+import { ModelRelationship } from '../relationship';
 
 const logger = new Logger('DataStore');
 const DB_NAME = 'amplify-datastore';
@@ -382,17 +381,12 @@ export abstract class StorageAdapterBase implements Adapter {
 			const modelConstructor =
 				modelOrModelConstructor as PersistentModelConstructor<T>;
 			const namespace = this.namespaceResolver(modelConstructor) as NAMESPACES;
-
 			const models = await this.query(modelConstructor, condition);
-			const relations =
-				this.schema.namespaces![namespace].relationships![modelConstructor.name]
-					.relationTypes;
 
 			if (condition !== undefined) {
 				await this.deleteTraverse(
-					relations,
 					models,
-					modelConstructor.name,
+					modelConstructor,
 					namespace,
 					deleteQueue
 				);
@@ -407,9 +401,8 @@ export abstract class StorageAdapterBase implements Adapter {
 				return [models, deletedModels];
 			} else {
 				await this.deleteTraverse(
-					relations,
 					models,
-					modelConstructor.name,
+					modelConstructor,
 					namespace,
 					deleteQueue
 				);
@@ -428,6 +421,7 @@ export abstract class StorageAdapterBase implements Adapter {
 
 			const modelConstructor = Object.getPrototypeOf(model)
 				.constructor as PersistentModelConstructor<T>;
+
 			const namespaceName = this.namespaceResolver(
 				modelConstructor
 			) as NAMESPACES;
@@ -457,28 +451,16 @@ export abstract class StorageAdapterBase implements Adapter {
 					throw new Error(msg);
 				}
 
-				const relations =
-					this.schema.namespaces[namespaceName].relationships![
-						modelConstructor.name
-					].relationTypes;
-
 				await this.deleteTraverse(
-					relations,
 					[model],
-					modelConstructor.name,
+					modelConstructor,
 					namespaceName,
 					deleteQueue
 				);
 			} else {
-				const relations =
-					this.schema.namespaces[namespaceName].relationships![
-						modelConstructor.name
-					].relationTypes;
-
 				await this.deleteTraverse(
-					relations,
 					[model],
-					modelConstructor.name,
+					modelConstructor,
 					namespaceName,
 					deleteQueue
 				);
@@ -501,139 +483,63 @@ export abstract class StorageAdapterBase implements Adapter {
 		}[]
 	);
 
-	protected abstract getHasOneChild<T extends PersistentModel>(
-		model: T,
-		srcModel: string,
-		namespace: NAMESPACES,
-		rel: RelationType
-	): Promise<T | undefined>;
-
-	/**
-	 * Backwards compatability for pre-CPK codegen
-	 * TODO - deprecate this in v6; will need to re-gen MIPR for older unit
-	 * tests that hit this path
-	 */
-	protected abstract getHasOneChildLegacy<T extends PersistentModel>(
-		model: T,
-		srcModel: string,
-		namespace: NAMESPACES,
-		rel: RelationType
-	): Promise<T | undefined>;
-
-	protected abstract getHasManyChildren<T extends PersistentModel>(
-		storeName: string,
-		index: string,
-		keyValues: string[]
-	): Promise<T[] | undefined>;
-
 	/**
 	 * Recursively traverse relationship graph and add
 	 * all Has One and Has Many relations to `deleteQueue` param
 	 *
 	 * Actual deletion of records added to `deleteQueue` occurs in the `delete` method
 	 *
-	 * @param relations
 	 * @param models
-	 * @param srcModel
+	 * @param modelConstructor
 	 * @param namespace
 	 * @param deleteQueue
 	 */
-	protected async deleteTraverse<T extends PersistentModel>(
-		relations: RelationType[],
+	private async deleteTraverse<T extends PersistentModel>(
 		models: T[],
-		srcModel: string,
+		modelConstructor: PersistentModelConstructor<T>,
 		namespace: NAMESPACES,
 		deleteQueue: { storeName: string; items: T[] }[]
 	): Promise<void> {
-		for await (const rel of relations) {
-			const { modelName, relationType, targetNames, associatedWith } = rel;
-
-			const storeName = getStorename(namespace, modelName);
-			const index: string =
-				getIndex(
-					this.schema.namespaces[namespace].relationships![modelName]
-						.relationTypes,
-					srcModel
-				) ||
-				// if we were unable to find an index via relationTypes
-				// i.e. for keyName connections, attempt to find one by the
-				// associatedWith property
-				getIndexFromAssociation(
-					this.schema.namespaces[namespace].relationships![modelName].indexes,
-					associatedWith!
-				)!;
-
-			for await (const model of models) {
-				const childRecords: PersistentModel[] = [];
-
-				switch (relationType) {
-					case 'HAS_ONE':
-						let childRecord;
-						if (targetNames?.length) {
-							childRecord = await this.getHasOneChild(
-								model,
-								srcModel,
-								namespace,
-								rel
-							);
-						} else {
-							childRecord = await this.getHasOneChildLegacy(
-								model,
-								srcModel,
-								namespace,
-								rel
-							);
-						}
-
-						if (childRecord) {
-							childRecords.push(childRecord);
-						}
-
-						break;
-					case 'HAS_MANY':
-						const keyValues: string[] = this.getIndexKeyValuesFromModel(model);
-
-						const records = await this.getHasManyChildren(
-							storeName,
-							index,
-							keyValues
-						);
-
-						if (records?.length) {
-							childRecords.push(...records);
-						}
-
-						break;
-					case 'BELONGS_TO':
-						// Intentionally blank
-						break;
-					default:
-						throw new Error(`Invalid relation type ${relationType}`);
-				}
+		const cascadingRelationTypes = ['HAS_ONE', 'HAS_MANY'];
 
-				// instantiate models before passing them to next recursive call
-				// necessary for extracting PK metadata in `getHasOneChild` and `getHasManyChildren`
-				const childModels = await this.load(namespace, modelName, childRecords);
+		for await (const model of models) {
+			const modelDefinition =
+				this.schema.namespaces[namespace].models[modelConstructor.name];
 
-				await this.deleteTraverse(
-					this.schema.namespaces[namespace].relationships![modelName]
-						.relationTypes,
-					childModels,
-					modelName,
-					namespace,
-					deleteQueue
-				);
+			const modelMeta = {
+				builder: modelConstructor,
+				schema: modelDefinition,
+				pkField: extractPrimaryKeyFieldNames(modelDefinition),
+			};
+
+			const relationships = ModelRelationship.allFrom(modelMeta).filter(r =>
+				cascadingRelationTypes.includes(r.type)
+			);
+
+			for await (const r of relationships) {
+				const queryObject = r.createRemoteQueryObject(model);
+				if (queryObject !== null) {
+					const relatedRecords = await this.query(
+						r.remoteModelConstructor,
+						ModelPredicateCreator.createFromFlatEqualities(
+							r.remoteDefinition!,
+							queryObject
+						)
+					);
+
+					await this.deleteTraverse(
+						relatedRecords,
+						r.remoteModelConstructor,
+						namespace,
+						deleteQueue
+					);
+				}
 			}
 		}
 
 		deleteQueue.push({
-			storeName: getStorename(namespace, srcModel),
-			items: models.map(record =>
-				this.modelInstanceCreator(
-					this.getModelConstructorByModelName!(namespace, srcModel),
-					record
-				)
-			),
+			storeName: getStorename(namespace, modelConstructor.name),
+			items: models,
 		});
 	}
 }

package/src/sync/index.ts

@@ -2,8 +2,13 @@ import {
 	browserOrNode,
 	ConsoleLogger as Logger,
 	BackgroundProcessManager,
+	Hub,
 } from '@aws-amplify/core';
-import { CONTROL_MSG as PUBSUB_CONTROL_MSG } from '@aws-amplify/pubsub';
+import {
+	CONTROL_MSG as PUBSUB_CONTROL_MSG,
+	CONNECTION_STATE_CHANGE as PUBSUB_CONNECTION_STATE_CHANGE,
+	ConnectionState,
+} from '@aws-amplify/pubsub';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import { ModelInstanceCreator } from '../datastore/datastore';
 import { ModelPredicateCreator } from '../predicates';
@@ -116,6 +121,13 @@ export class SyncEngine {
 		PersistentModelConstructor<any>,
 		boolean
 	> = new WeakMap();
+	private unsleepSyncQueriesObservable: (() => void) | null;
+	private waitForSleepState: Promise<void>;
+	private syncQueriesObservableStartSleeping: (
+		value?: void | PromiseLike<void>
+	) => void;
+	private stopDisruptionListener: () => void;
+	private connectionDisrupted = false;
 
 	private runningProcesses: BackgroundProcessManager;
 
@@ -144,6 +156,9 @@ export class SyncEngine {
 		private readonly connectivityMonitor?: DataStoreConnectivity
 	) {
 		this.runningProcesses = new BackgroundProcessManager();
+		this.waitForSleepState = new Promise(resolve => {
+			this.syncQueriesObservableStartSleeping = resolve;
+		});
 
 		const MutationEvent = this.modelClasses[
 			'MutationEvent'
@@ -237,6 +252,8 @@ export class SyncEngine {
 											'Realtime disabled when in a server-side environment'
 										);
 									} else {
+										this.stopDisruptionListener =
+											this.startDisruptionListener();
 										//#region GraphQL Subscriptions
 										[ctlSubsObservable, dataSubsObservable] =
 											this.subscriptionsProcessor.start();
@@ -769,11 +786,19 @@ export class SyncEngine {
 
 							onTerminate.then(() => {
 								terminated = true;
+								this.syncQueriesObservableStartSleeping();
 								unsleep();
 							});
 
+							this.unsleepSyncQueriesObservable = unsleep;
+							this.syncQueriesObservableStartSleeping();
 							return sleep;
 						}, 'syncQueriesObservable sleep');
+
+						this.unsleepSyncQueriesObservable = null;
+						this.waitForSleepState = new Promise(resolve => {
+							this.syncQueriesObservableStartSleeping = resolve;
+						});
 					}
 				}, 'syncQueriesObservable main');
 		});
@@ -808,6 +833,11 @@ export class SyncEngine {
 		 */
 		this.unsubscribeConnectivity();
 
+		/**
+		 * Stop listening for websocket connection disruption
+		 */
+		this.stopDisruptionListener && this.stopDisruptionListener();
+
 		/**
 		 * aggressively shut down any lingering background processes.
 		 * some of this might be semi-redundant with unsubscribing. however,
@@ -1053,4 +1083,49 @@ export class SyncEngine {
 		};
 		return namespace;
 	}
+
+	/**
+	 * listen for websocket connection disruption
+	 *
+	 * May indicate there was a period of time where messages
+	 * from AppSync were missed. A sync needs to be triggered to
+	 * retrieve the missed data.
+	 */
+	private startDisruptionListener() {
+		return Hub.listen('api', (data: any) => {
+			if (
+				data.source === 'PubSub' &&
+				data.payload.event === PUBSUB_CONNECTION_STATE_CHANGE
+			) {
+				const connectionState = data.payload.data
+					.connectionState as ConnectionState;
+
+				switch (connectionState) {
+					// Do not need to listen for ConnectionDisruptedPendingNetwork
+					// Normal network reconnection logic will handle the sync
+					case ConnectionState.ConnectionDisrupted:
+						this.connectionDisrupted = true;
+						break;
+
+					case ConnectionState.Connected:
+						if (this.connectionDisrupted) {
+							this.scheduleSync();
+						}
+						this.connectionDisrupted = false;
+						break;
+				}
+			}
+		});
+	}
+
+	/*
+	 * Schedule a sync to start when syncQueriesObservable enters sleep state
+	 * Start sync immediately if syncQueriesObservable is already in sleep state
+	 */
+	private scheduleSync(): Promise<void> {
+		return this.waitForSleepState.then(() => {
+			// unsleepSyncQueriesObservable will be set if waitForSleepState has resolved
+			this.unsleepSyncQueriesObservable!();
+		});
+	}
 }