@aws-amplify/datastore 4.1.12-unstable.43d494b.2 → 4.2.0

package/src/sync/index.ts

@@ -225,199 +225,201 @@ export class SyncEngine {
 
 				// this is awaited at the bottom. so, we don't need to register
 				// this explicitly with the context. it's already contained.
-				const startPromise = new Promise((doneStarting, failedStarting) => {
-					this.datastoreConnectivity.status().subscribe(
-						async ({ online }) =>
-							this.runningProcesses.isOpen &&
-							this.runningProcesses.add(async onTerminate => {
-								// From offline to online
-								if (online && !this.online) {
-									this.online = online;
-
-									observer.next({
-										type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
-										data: {
-											active: this.online,
-										},
-									});
-
-									let ctlSubsObservable: Observable<CONTROL_MSG>;
-									let dataSubsObservable: Observable<
-										[TransformerMutationType, SchemaModel, PersistentModel]
-									>;
-
-									// NOTE: need a way to override this conditional for testing.
-									if (isNode) {
-										logger.warn(
-											'Realtime disabled when in a server-side environment'
-										);
-									} else {
-										this.stopDisruptionListener =
-											this.startDisruptionListener();
-										//#region GraphQL Subscriptions
-										[ctlSubsObservable, dataSubsObservable] =
-											this.subscriptionsProcessor.start();
+				const startPromise = new Promise<void>(
+					(doneStarting, failedStarting) => {
+						this.datastoreConnectivity.status().subscribe(
+							async ({ online }) =>
+								this.runningProcesses.isOpen &&
+								this.runningProcesses.add(async onTerminate => {
+									// From offline to online
+									if (online && !this.online) {
+										this.online = online;
+
+										observer.next({
+											type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
+											data: {
+												active: this.online,
+											},
+										});
+
+										let ctlSubsObservable: Observable<CONTROL_MSG>;
+										let dataSubsObservable: Observable<
+											[TransformerMutationType, SchemaModel, PersistentModel]
+										>;
+
+										// NOTE: need a way to override this conditional for testing.
+										if (isNode) {
+											logger.warn(
+												'Realtime disabled when in a server-side environment'
+											);
+										} else {
+											this.stopDisruptionListener =
+												this.startDisruptionListener();
+											//#region GraphQL Subscriptions
+											[ctlSubsObservable, dataSubsObservable] =
+												this.subscriptionsProcessor.start();
+
+											try {
+												await new Promise<void>((resolve, reject) => {
+													onTerminate.then(reject);
+													const ctlSubsSubscription =
+														ctlSubsObservable.subscribe({
+															next: msg => {
+																if (msg === CONTROL_MSG.CONNECTED) {
+																	resolve();
+																}
+															},
+															error: err => {
+																reject(err);
+																const handleDisconnect =
+																	this.disconnectionHandler();
+																handleDisconnect(err);
+															},
+														});
+
+													subscriptions.push(ctlSubsSubscription);
+												});
+											} catch (err) {
+												observer.error(err);
+												failedStarting();
+												return;
+											}
 
+											logger.log('Realtime ready');
+
+											observer.next({
+												type: ControlMessage.SYNC_ENGINE_SUBSCRIPTIONS_ESTABLISHED,
+											});
+
+											//#endregion
+										}
+
+										//#region Base & Sync queries
 										try {
-											await new Promise((resolve, reject) => {
-												onTerminate.then(reject);
-												const ctlSubsSubscription = ctlSubsObservable.subscribe(
-													{
-														next: msg => {
-															if (msg === CONTROL_MSG.CONNECTED) {
+											await new Promise<void>((resolve, reject) => {
+												const syncQuerySubscription =
+													this.syncQueriesObservable().subscribe({
+														next: message => {
+															const { type } = message;
+
+															if (
+																type ===
+																ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY
+															) {
 																resolve();
 															}
+
+															observer.next(message);
 														},
-														error: err => {
-															reject(err);
-															const handleDisconnect =
-																this.disconnectionHandler();
-															handleDisconnect(err);
+														complete: () => {
+															resolve();
 														},
-													}
-												);
+														error: error => {
+															reject(error);
+														},
+													});
 
-												subscriptions.push(ctlSubsSubscription);
+												if (syncQuerySubscription) {
+													subscriptions.push(syncQuerySubscription);
+												}
 											});
-										} catch (err) {
-											observer.error(err);
+										} catch (error) {
+											observer.error(error);
 											failedStarting();
 											return;
 										}
+										//#endregion
 
-										logger.log('Realtime ready');
-
-										observer.next({
-											type: ControlMessage.SYNC_ENGINE_SUBSCRIPTIONS_ESTABLISHED,
-										});
-
+										//#region process mutations (outbox)
+										subscriptions.push(
+											this.mutationsProcessor
+												.start()
+												.subscribe(
+													({ modelDefinition, model: item, hasMore }) =>
+														this.runningProcesses.add(async () => {
+															const modelConstructor = this.userModelClasses[
+																modelDefinition.name
+															] as PersistentModelConstructor<any>;
+
+															const model = this.modelInstanceCreator(
+																modelConstructor,
+																item
+															);
+
+															await this.storage.runExclusive(storage =>
+																this.modelMerger.merge(
+																	storage,
+																	model,
+																	modelDefinition
+																)
+															);
+
+															observer.next({
+																type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED,
+																data: {
+																	model: modelConstructor,
+																	element: model,
+																},
+															});
+
+															observer.next({
+																type: ControlMessage.SYNC_ENGINE_OUTBOX_STATUS,
+																data: {
+																	isEmpty: !hasMore,
+																},
+															});
+														}, 'mutation processor event')
+												)
+										);
 										//#endregion
-									}
 
-									//#region Base & Sync queries
-									try {
-										await new Promise((resolve, reject) => {
-											const syncQuerySubscription =
-												this.syncQueriesObservable().subscribe({
-													next: message => {
-														const { type } = message;
-
-														if (
-															type ===
-															ControlMessage.SYNC_ENGINE_SYNC_QUERIES_READY
-														) {
-															resolve();
-														}
-
-														observer.next(message);
-													},
-													complete: () => {
-														resolve();
-													},
-													error: error => {
-														reject(error);
-													},
-												});
+										//#region Merge subscriptions buffer
+										// TODO: extract to function
+										if (!isNode) {
+											subscriptions.push(
+												dataSubsObservable!.subscribe(
+													([_transformerMutationType, modelDefinition, item]) =>
+														this.runningProcesses.add(async () => {
+															const modelConstructor = this.userModelClasses[
+																modelDefinition.name
+															] as PersistentModelConstructor<any>;
+
+															const model = this.modelInstanceCreator(
+																modelConstructor,
+																item
+															);
+
+															await this.storage.runExclusive(storage =>
+																this.modelMerger.merge(
+																	storage,
+																	model,
+																	modelDefinition
+																)
+															);
+														}, 'subscription dataSubsObservable event')
+												)
+											);
+										}
+										//#endregion
+									} else if (!online) {
+										this.online = online;
 
-											if (syncQuerySubscription) {
-												subscriptions.push(syncQuerySubscription);
-											}
+										observer.next({
+											type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
+											data: {
+												active: this.online,
+											},
 										});
-									} catch (error) {
-										observer.error(error);
-										failedStarting();
-										return;
-									}
-									//#endregion
-
-									//#region process mutations (outbox)
-									subscriptions.push(
-										this.mutationsProcessor
-											.start()
-											.subscribe(({ modelDefinition, model: item, hasMore }) =>
-												this.runningProcesses.add(async () => {
-													const modelConstructor = this.userModelClasses[
-														modelDefinition.name
-													] as PersistentModelConstructor<any>;
-
-													const model = this.modelInstanceCreator(
-														modelConstructor,
-														item
-													);
-
-													await this.storage.runExclusive(storage =>
-														this.modelMerger.merge(
-															storage,
-															model,
-															modelDefinition
-														)
-													);
-
-													observer.next({
-														type: ControlMessage.SYNC_ENGINE_OUTBOX_MUTATION_PROCESSED,
-														data: {
-															model: modelConstructor,
-															element: model,
-														},
-													});
 
-													observer.next({
-														type: ControlMessage.SYNC_ENGINE_OUTBOX_STATUS,
-														data: {
-															isEmpty: !hasMore,
-														},
-													});
-												}, 'mutation processor event')
-											)
-									);
-									//#endregion
-
-									//#region Merge subscriptions buffer
-									// TODO: extract to function
-									if (!isNode) {
-										subscriptions.push(
-											dataSubsObservable!.subscribe(
-												([_transformerMutationType, modelDefinition, item]) =>
-													this.runningProcesses.add(async () => {
-														const modelConstructor = this.userModelClasses[
-															modelDefinition.name
-														] as PersistentModelConstructor<any>;
-
-														const model = this.modelInstanceCreator(
-															modelConstructor,
-															item
-														);
-
-														await this.storage.runExclusive(storage =>
-															this.modelMerger.merge(
-																storage,
-																model,
-																modelDefinition
-															)
-														);
-													}, 'subscription dataSubsObservable event')
-											)
-										);
+										subscriptions.forEach(sub => sub.unsubscribe());
+										subscriptions = [];
 									}
-									//#endregion
-								} else if (!online) {
-									this.online = online;
-
-									observer.next({
-										type: ControlMessage.SYNC_ENGINE_NETWORK_STATUS,
-										data: {
-											active: this.online,
-										},
-									});
-
-									subscriptions.forEach(sub => sub.unsubscribe());
-									subscriptions = [];
-								}
 
-								doneStarting();
-							}, 'datastore connectivity event')
-					);
-				});
+									doneStarting();
+								}, 'datastore connectivity event')
+						);
+					}
+				);
 
 				this.storage
 					.observe(null, null, ownSymbol)
@@ -567,7 +569,7 @@ export class SyncEngine {
 						let start: number;
 						let syncDuration: number;
 						let lastStartedAt: number;
-						await new Promise((resolve, reject) => {
+						await new Promise<void>((resolve, reject) => {
 							if (!this.runningProcesses.isOpen) resolve();
 							onTerminate.then(() => resolve());
 							syncQueriesSubscription = this.syncQueriesProcessor
@@ -1122,10 +1124,15 @@ export class SyncEngine {
 	 * 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!();
-		});
+	private scheduleSync() {
+		return (
+			this.runningProcesses.isOpen &&
+			this.runningProcesses.add(() =>
+				this.waitForSleepState.then(() => {
+					// unsleepSyncQueriesObservable will be set if waitForSleepState has resolved
+					this.unsleepSyncQueriesObservable!();
+				})
+			)
+		);
 	}
 }

package/src/sync/processors/errorMaps.ts

@@ -22,6 +22,7 @@ export const mutationErrorMap: ErrorMap = {
 	ConfigError: () => false,
 	Transient: error => connectionTimeout(error) || serverError(error),
 	Unauthorized: error =>
+		error.message === 'Unauthorized' ||
 		/^Request failed with status code 401/.test(error.message),
 };
 
@@ -44,7 +45,7 @@ export const syncErrorMap: ErrorMap = {
 	BadRecord: error => /^Cannot return \w+ for [\w-_]+ type/.test(error.message),
 	ConfigError: () => false,
 	Transient: error => connectionTimeout(error) || serverError(error),
-	Unauthorized: () => false,
+	Unauthorized: error => (error as any).errorType === 'Unauthorized',
 };
 
 /**

package/src/sync/processors/mutation.ts

@@ -231,6 +231,22 @@ class MutationProcessor {
 											operationAuthModes[authModeAttempts - 1]
 										}`
 									);
+									try {
+										await this.errorHandler({
+											recoverySuggestion:
+												'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
+											localModel: null!,
+											message: error.message,
+											model: modelConstructor.name,
+											operation: opName,
+											errorType: getMutationErrorType(error),
+											process: ProcessName.sync,
+											remoteModel: null!,
+											cause: error,
+										});
+									} catch (e) {
+										logger.error('Mutation error handler failed with:', e);
+									}
 									throw error;
 								}
 								logger.debug(

package/src/sync/processors/sync.ts

@@ -227,6 +227,7 @@ class SyncProcessor {
 					// Catch client-side (GraphQLAuthError) & 401/403 errors here so that we don't continue to retry
 					const clientOrForbiddenErrorMessage =
 						getClientSideAuthError(error) || getForbiddenError(error);
+
 					if (clientOrForbiddenErrorMessage) {
 						logger.error('Sync processor retry error:', error);
 						throw new NonRetryableError(clientOrForbiddenErrorMessage);
@@ -284,20 +285,44 @@ class SyncProcessor {
 						});
 					}
 
+					/**
+					 * Handle $util.unauthorized() in resolver request mapper, which responses with something
+					 * like this:
+					 *
+					 * ```
+					 * {
+					 * 	data: { syncYourModel: null },
+					 * 	errors: [
+					 * 		{
+					 * 			path: ['syncLegacyJSONComments'],
+					 * 			data: null,
+					 * 			errorType: 'Unauthorized',
+					 * 			errorInfo: null,
+					 * 			locations: [{ line: 2, column: 3, sourceName: null }],
+					 * 			message:
+					 * 				'Not Authorized to access syncYourModel on type Query',
+					 * 			},
+					 * 		],
+					 * 	}
+					 * ```
+					 *
+					 * The correct handling for this is to signal that we've encountered a non-retryable error,
+					 * since the server has responded with an auth error and *NO DATA* at this point.
+					 */
 					if (unauthorized) {
-						logger.warn(
-							'queryError',
-							`User is unauthorized to query ${opName}, some items could not be returned.`
-						);
-
-						result.data = result.data || {};
-
-						result.data[opName] = {
-							...opResultDefaults,
-							...result.data[opName],
-						};
-
-						return result;
+						this.errorHandler({
+							recoverySuggestion:
+								'Ensure app code is up to date, auth directives exist and are correct on each model, and that server-side data has not been invalidated by a schema change. If the problem persists, search for or create an issue: https://github.com/aws-amplify/amplify-js/issues',
+							localModel: null!,
+							message: error.message,
+							model: modelDefinition.name,
+							operation: opName,
+							errorType: getSyncErrorType(error.errors[0]),
+							process: ProcessName.sync,
+							remoteModel: null!,
+							cause: error,
+						});
+						throw new NonRetryableError(error);
 					}
 
 					if (result.data?.[opName].items?.length) {
@@ -405,7 +430,15 @@ class SyncProcessor {
 										} catch (e) {
 											logger.error('Sync error handler failed with:', e);
 										}
-										return res();
+										/**
+										 * If there's an error, this model fails, but the rest of the sync should
+										 * continue. To facilitate this, we explicitly mark this model as `done`
+										 * with no items and allow the loop to continue organically. This ensures
+										 * all callbacks (subscription messages) happen as normal, so anything
+										 * waiting on them knows the model is as done as it can be.
+										 */
+										done = true;
+										items = [];
 									}
 
 									recordsReceived += items.length;