@aws-amplify/datastore 3.7.3 → 3.7.4-custom-pk.86

package/src/sync/processors/errorMaps.ts

@@ -0,0 +1,93 @@
+import { ErrorType } from '../../types';
+
+export type ErrorMap = Partial<{
+	[key in ErrorType]: (error: Error) => boolean;
+}>;
+
+const connectionTimeout = error =>
+	/^Connection failed: Connection Timeout/.test(error.message);
+
+const serverError = error =>
+	/^Error: Request failed with status code 5\d\d/.test(error.message);
+
+export const mutationErrorMap: ErrorMap = {
+	BadModel: () => false,
+	BadRecord: error => {
+		const { message } = error;
+		return (
+			/^Cannot return \w+ for [\w-_]+ type/.test(message) ||
+			/^Variable '.+' has coerced Null value for NonNull type/.test(message)
+		); // newly required field, out of date client
+	},
+	ConfigError: () => false,
+	Transient: error => connectionTimeout(error) || serverError(error),
+	Unauthorized: error =>
+		/^Request failed with status code 401/.test(error.message),
+};
+
+export const subscriptionErrorMap: ErrorMap = {
+	BadModel: () => false,
+	BadRecord: () => false,
+	ConfigError: () => false,
+	Transient: observableError => {
+		const error = unwrapObservableError(observableError);
+		return connectionTimeout(error) || serverError(error);
+	},
+	Unauthorized: observableError => {
+		const error = unwrapObservableError(observableError);
+		return /Connection failed.+Unauthorized/.test(error.message);
+	},
+};
+
+export const syncErrorMap: ErrorMap = {
+	BadModel: () => false,
+	BadRecord: error => /^Cannot return \w+ for [\w-_]+ type/.test(error.message),
+	ConfigError: () => false,
+	Transient: error => connectionTimeout(error) || serverError(error),
+	Unauthorized: () => false,
+};
+
+/**
+ * Get the first error reason of an observable.
+ * Allows for error maps to be easily applied to observable errors
+ *
+ * @param observableError an error from ZenObservable subscribe error callback
+ */
+function unwrapObservableError(observableError: any) {
+	const {
+		error: { errors: [error] } = {
+			errors: [],
+		},
+	} = observableError;
+
+	return error;
+}
+
+export function getMutationErrorType(error: Error): ErrorType {
+	return mapErrorToType(mutationErrorMap, error);
+}
+
+export function getSubscriptionErrorType(error: Error): ErrorType {
+	return mapErrorToType(subscriptionErrorMap, error);
+}
+
+export function getSyncErrorType(error: Error): ErrorType {
+	return mapErrorToType(syncErrorMap, error);
+}
+
+/**
+ * Categorizes an error with a broad error type, intended to make
+ * customer error handling code simpler.
+ * @param errorMap Error names and a list of patterns that indicate them (each pattern as a regex or function)
+ * @param error The underying error to categorize.
+ */
+export function mapErrorToType(errorMap: ErrorMap, error: Error): ErrorType {
+	const errorTypes = [...Object.keys(errorMap)] as ErrorType[];
+	for (const errorType of errorTypes) {
+		const matcher = errorMap[errorType];
+		if (matcher(error)) {
+			return errorType;
+		}
+	}
+	return 'Unknown';
+}

package/src/sync/processors/mutation.ts

@@ -1,8 +1,9 @@
 import API, { GraphQLResult, GRAPHQL_AUTH_MODE } from '@aws-amplify/api';
 import {
 	ConsoleLogger as Logger,
-	jitteredExponentialRetry,
+	jitteredBackoff,
 	NonRetryableError,
+	retry,
 } from '@aws-amplify/core';
 import Observable, { ZenObservable } from 'zen-observable-ts';
 import { MutationEvent } from '../';
@@ -23,8 +24,15 @@ import {
 	PersistentModelConstructor,
 	SchemaModel,
 	TypeConstructorMap,
+	ProcessName,
+	AmplifyContext,
 } from '../../types';
-import { exhaustiveCheck, USER } from '../../util';
+import {
+	exhaustiveCheck,
+	extractTargetNamesFromSrc,
+	USER,
+	USER_AGENT_SUFFIX_DATASTORE,
+} from '../../util';
 import { MutationEventOutbox } from '../outbox';
 import {
 	buildGraphQLOperation,
@@ -33,6 +41,7 @@ import {
 	TransformerMutationType,
 	getTokenForCustomAuth,
 } from '../utils';
+import { getMutationErrorType } from './errorMaps';
 
 const MAX_ATTEMPTS = 10;
 
@@ -62,9 +71,11 @@ class MutationProcessor {
 		private readonly MutationEvent: PersistentModelConstructor<MutationEvent>,
 		private readonly amplifyConfig: Record<string, any> = {},
 		private readonly authModeStrategy: AuthModeStrategy,
-		private readonly conflictHandler?: ConflictHandler,
-		private readonly errorHandler?: ErrorHandler
+		private readonly errorHandler: ErrorHandler,
+		private readonly conflictHandler: ConflictHandler,
+		private readonly amplifyContext: AmplifyContext
 	) {
+		this.amplifyContext.API = this.amplifyContext.API || API;
 		this.generateQueries();
 	}
 
@@ -234,14 +245,14 @@ class MutationProcessor {
 		operation: TransformerMutationType,
 		data: string,
 		condition: string,
-		modelConstructor: PersistentModelConstructor<PersistentModel>,
+		modelConstructor: PersistentModelConstructor<unknown>,
 		MutationEvent: PersistentModelConstructor<MutationEvent>,
 		mutationEvent: MutationEvent,
 		authMode: GRAPHQL_AUTH_MODE
 	): Promise<
 		[GraphQLResult<Record<string, PersistentModel>>, string, SchemaModel]
 	> {
-		return await jitteredExponentialRetry(
+		return await retry(
 			async (
 				model: string,
 				operation: TransformerMutationType,
@@ -251,26 +262,27 @@ class MutationProcessor {
 				MutationEvent: PersistentModelConstructor<MutationEvent>,
 				mutationEvent: MutationEvent
 			) => {
-				const [
-					query,
-					variables,
-					graphQLCondition,
-					opName,
-					modelDefinition,
-				] = this.createQueryVariables(
-					namespaceName,
-					model,
-					operation,
-					data,
-					condition
-				);
+				const [query, variables, graphQLCondition, opName, modelDefinition] =
+					this.createQueryVariables(
+						namespaceName,
+						model,
+						operation,
+						data,
+						condition
+					);
 
 				const authToken = await getTokenForCustomAuth(
 					authMode,
 					this.amplifyConfig
 				);
 
-				const tryWith = { query, variables, authMode, authToken };
+				const tryWith = {
+					query,
+					variables,
+					authMode,
+					authToken,
+					userAgentSuffix: USER_AGENT_SUFFIX_DATASTORE,
+				};
 				let attempt = 0;
 
 				const opType = this.opTypeFromTransformerOperation(operation);
@@ -278,7 +290,7 @@ class MutationProcessor {
 				do {
 					try {
 						const result = <GraphQLResult<Record<string, PersistentModel>>>(
-							await API.graphql(tryWith)
+							await this.amplifyContext.API.graphql(tryWith)
 						);
 						return [result, opName, modelDefinition];
 					} catch (err) {
@@ -345,11 +357,12 @@ class MutationProcessor {
 
 									const serverData = <
 										GraphQLResult<Record<string, PersistentModel>>
-									>await API.graphql({
+									>await this.amplifyContext.API.graphql({
 										query,
 										variables: { id: variables.input.id },
 										authMode,
 										authToken,
+										userAgentSuffix: USER_AGENT_SUFFIX_DATASTORE,
 									});
 
 									return [serverData, opName, modelDefinition];
@@ -358,17 +371,18 @@ class MutationProcessor {
 								const namespace = this.schema.namespaces[namespaceName];
 
 								// convert retry with to tryWith
-								const updatedMutation = createMutationInstanceFromModelOperation(
-									namespace.relationships,
-									modelDefinition,
-									opType,
-									modelConstructor,
-									retryWith,
-									graphQLCondition,
-									MutationEvent,
-									this.modelInstanceCreator,
-									mutationEvent.id
-								);
+								const updatedMutation =
+									createMutationInstanceFromModelOperation(
+										namespace.relationships,
+										modelDefinition,
+										opType,
+										modelConstructor,
+										retryWith,
+										graphQLCondition,
+										MutationEvent,
+										this.modelInstanceCreator,
+										mutationEvent.id
+									);
 
 								await this.storage.save(updatedMutation);
 
@@ -376,20 +390,21 @@ class MutationProcessor {
 							} else {
 								try {
 									await this.errorHandler({
-										localModel: this.modelInstanceCreator(
-											modelConstructor,
-											variables.input
-										),
+										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: variables.input,
 										message: error.message,
 										operation,
-										errorType: error.errorType,
+										errorType: getMutationErrorType(error),
 										errorInfo: error.errorInfo,
+										process: ProcessName.mutate,
+										cause: error,
 										remoteModel: error.data
 											? this.modelInstanceCreator(modelConstructor, error.data)
 											: null,
 									});
 								} catch (err) {
-									logger.warn('failed to execute errorHandler', err);
+									logger.warn('Mutation error handler failed with:', err);
 								} finally {
 									// Return empty tuple, dequeues the mutation
 									return error.data
@@ -417,7 +432,8 @@ class MutationProcessor {
 				modelConstructor,
 				MutationEvent,
 				mutationEvent,
-			]
+			],
+			safeJitteredBackoff
 		);
 	}
 
@@ -441,63 +457,73 @@ class MutationProcessor {
 
 		// include all the fields that comprise a custom PK if one is specified
 		const deleteInput = {};
-		if (primaryKey && primaryKey.length) {
+		if (primaryKey?.length) {
 			for (const pkField of primaryKey) {
 				deleteInput[pkField] = parsedData[pkField];
 			}
 		} else {
-			deleteInput['id'] = parsedData.id;
+			// CPK TODO:
+			// Previous comment from Manuel: what if it was renamed ?
+			deleteInput['id'] = (<any>parsedData).id;
 		}
 
-		const filteredData =
-			operation === TransformerMutationType.DELETE
-				? <ModelInstanceMetadata>deleteInput // For DELETE mutations, only PK is sent
-				: Object.values(modelDefinition.fields)
-						.filter(({ name, type, association }) => {
-							// connections
-							if (isModelFieldType(type)) {
-								// BELONGS_TO
-								if (
-									isTargetNameAssociation(association) &&
-									association.connectionType === 'BELONGS_TO'
-								) {
-									return true;
-								}
-
-								// All other connections
-								return false;
-							}
+		let mutationInput;
 
-							if (operation === TransformerMutationType.UPDATE) {
-								// this limits the update mutation input to changed fields only
-								return parsedData.hasOwnProperty(name);
+		if (operation === TransformerMutationType.DELETE) {
+			// For DELETE mutations, only the key(s) are included in the input
+			mutationInput = <ModelInstanceMetadata>deleteInput;
+		} else {
+			// Otherwise, we construct the mutation input with the following logic
+			mutationInput = {};
+			const modelFields = Object.values(modelDefinition.fields);
+
+			for (const { name, type, association } of modelFields) {
+				// model fields should be stripped out from the input
+				if (isModelFieldType(type)) {
+					// except for belongs to relations - we need to replace them with the correct foreign key(s)
+					if (
+						isTargetNameAssociation(association) &&
+						association.connectionType === 'BELONGS_TO'
+					) {
+						const targetNames: string[] | undefined =
+							extractTargetNamesFromSrc(association);
+
+						if (targetNames) {
+							// instead of including the connected model itself, we add its key(s) to the mutation input
+							for (const targetName of targetNames) {
+								mutationInput[targetName] = parsedData[targetName];
 							}
+							// if (association?.targetNames?.length) {
+							// 	// instead of including the connected model itself, we add its key(s) to the mutation input
+							// 	for (const targetName of association.targetNames) {
+							// 		mutationInput[targetName] = parsedData[targetName];
+							// 	}
+							// } else if (association.targetName) {
+							// 	// backwards-compatability for schema generated prior to custom primary key support
+							// 	mutationInput[association.targetName] =
+							// 		parsedData[association.targetName];
+							// }
+						}
+					}
+					continue;
+				}
+				// scalar fields / non-model types
 
-							// scalars and non-model types
-							return true;
-						})
-						.map(({ name, type, association }) => {
-							let fieldName = name;
-							let val = parsedData[name];
-
-							if (
-								isModelFieldType(type) &&
-								isTargetNameAssociation(association)
-							) {
-								fieldName = association.targetName;
-								val = parsedData[fieldName];
-							}
+				if (operation === TransformerMutationType.UPDATE) {
+					if (!parsedData.hasOwnProperty(name)) {
+						// for update mutations - strip out a field if it's unchanged
+						continue;
+					}
+				}
 
-							return [fieldName, val];
-						})
-						.reduce((acc, [k, v]) => {
-							acc[k] = v;
-							return acc;
-						}, <typeof parsedData>{});
+				// all other fields are added to the input object
+				mutationInput[name] = parsedData[name];
+			}
+		}
 
 		// Build mutation variables input object
 		const input: ModelInstanceMetadata = {
-			...filteredData,
+			...mutationInput,
 			_version,
 		};
 
@@ -539,4 +565,37 @@ class MutationProcessor {
 	}
 }
 
+const MAX_RETRY_DELAY_MS = 5 * 60 * 1000;
+const originalJitteredBackoff = jitteredBackoff(MAX_RETRY_DELAY_MS);
+
+/**
+ * @private
+ * Internal use of Amplify only.
+ *
+ * Wraps the jittered backoff calculation to retry Network Errors indefinitely.
+ * Backs off according to original jittered retry logic until the original retry
+ * logic hits its max. After this occurs, if the error is a Network Error, we
+ * ignore the attempt count and return MAX_RETRY_DELAY_MS to retry forever (until
+ * the request succeeds).
+ *
+ * @param attempt ignored
+ * @param _args ignored
+ * @param error tested to see if `.message` is 'Network Error'
+ * @returns number | false :
+ */
+export const safeJitteredBackoff: typeof originalJitteredBackoff = (
+	attempt,
+	_args,
+	error
+) => {
+	const attemptResult = originalJitteredBackoff(attempt);
+
+	// If this is the last attempt and it is a network error, we retry indefinitively every 5 minutes
+	if (attemptResult === false && error?.message === 'Network Error') {
+		return MAX_RETRY_DELAY_MS;
+	}
+
+	return attemptResult;
+};
+
 export { MutationProcessor };

package/src/sync/processors/subscription.ts

@@ -1,5 +1,5 @@
 import API, { GraphQLResult, GRAPHQL_AUTH_MODE } from '@aws-amplify/api';
-import Auth from '@aws-amplify/auth';
+import { Auth } from '@aws-amplify/auth';
 import Cache from '@aws-amplify/cache';
 import { ConsoleLogger as Logger, Hub, HubCapsule } from '@aws-amplify/core';
 import { CONTROL_MSG as PUBSUB_CONTROL_MSG } from '@aws-amplify/pubsub';
@@ -12,6 +12,9 @@ import {
 	PredicatesGroup,
 	ModelPredicate,
 	AuthModeStrategy,
+	ErrorHandler,
+	ProcessName,
+	AmplifyContext,
 } from '../../types';
 import {
 	buildSubscriptionGraphQLOperation,
@@ -22,7 +25,8 @@ import {
 	getTokenForCustomAuth,
 } from '../utils';
 import { ModelPredicateCreator } from '../../predicates';
-import { validatePredicate } from '../../util';
+import { validatePredicate, USER_AGENT_SUFFIX_DATASTORE } from '../../util';
+import { getSubscriptionErrorType } from './errorMaps';
 
 const logger = new Logger('DataStore');
 
@@ -48,18 +52,17 @@ class SubscriptionProcessor {
 		SchemaModel,
 		[TransformerMutationType, string, string][]
 	>();
-	private buffer: [
-		TransformerMutationType,
-		SchemaModel,
-		PersistentModel
-	][] = [];
+	private buffer: [TransformerMutationType, SchemaModel, PersistentModel][] =
+		[];
 	private dataObserver: ZenObservable.Observer<any>;
 
 	constructor(
 		private readonly schema: InternalSchema,
 		private readonly syncPredicates: WeakMap<SchemaModel, ModelPredicate<any>>,
 		private readonly amplifyConfig: Record<string, any> = {},
-		private readonly authModeStrategy: AuthModeStrategy
+		private readonly authModeStrategy: AuthModeStrategy,
+		private readonly errorHandler: ErrorHandler,
+		private readonly amplifyContext: AmplifyContext = { Auth, API, Cache }
 	) {}
 
 	private buildSubscription(
@@ -252,8 +255,8 @@ class SubscriptionProcessor {
 			(async () => {
 				try {
 					// retrieving current AWS Credentials
-					// TODO Should this use `this.amplify.Auth` for SSR?
-					const credentials = await Auth.currentCredentials();
+					const credentials =
+						await this.amplifyContext.Auth.currentCredentials();
 					userCredentials = credentials.authenticated
 						? USER_CREDENTIALS.auth
 						: USER_CREDENTIALS.unauth;
@@ -263,8 +266,7 @@ class SubscriptionProcessor {
 
 				try {
 					// retrieving current token info from Cognito UserPools
-					// TODO Should this use `this.amplify.Auth` for SSR?
-					const session = await Auth.currentSession();
+					const session = await this.amplifyContext.Auth.currentSession();
 					cognitoTokenPayload = session.getIdToken().decodePayload();
 				} catch (err) {
 					// best effort to get jwt from Cognito
@@ -281,11 +283,14 @@ class SubscriptionProcessor {
 
 					let token;
 					// backwards compatibility
-					const federatedInfo = await Cache.getItem('federatedInfo');
+					const federatedInfo = await this.amplifyContext.Cache.getItem(
+						'federatedInfo'
+					);
 					if (federatedInfo) {
 						token = federatedInfo.token;
 					} else {
-						const currentUser = await Auth.currentAuthenticatedUser();
+						const currentUser =
+							await this.amplifyContext.Auth.currentAuthenticatedUser();
 						if (currentUser) {
 							token = currentUser.token;
 						}
@@ -308,8 +313,8 @@ class SubscriptionProcessor {
 						.forEach(async modelDefinition => {
 							const modelAuthModes = await getModelAuthModes({
 								authModeStrategy: this.authModeStrategy,
-								defaultAuthMode: this.amplifyConfig
-									.aws_appsync_authenticationType,
+								defaultAuthMode:
+									this.amplifyConfig.aws_appsync_authenticationType,
 								modelName: modelDefinition.name,
 								schema: this.schema,
 							});
@@ -382,18 +387,23 @@ class SubscriptionProcessor {
 									}`
 								);
 
+								const userAgentSuffix = USER_AGENT_SUFFIX_DATASTORE;
+
 								const queryObservable = <
 									Observable<{
 										value: GraphQLResult<Record<string, PersistentModel>>;
 									}>
-								>(<unknown>API.graphql({ query, variables, ...{ authMode }, authToken }));
+								>(<unknown>this.amplifyContext.API.graphql({ query, variables, ...{ authMode }, authToken, userAgentSuffix }));
+
 								let subscriptionReadyCallback: () => void;
 
 								subscriptions[modelDefinition.name][
 									transformerMutationType
 								].push(
 									queryObservable
-										.map(({ value }) => value)
+										.map(({ value }) => {
+											return value;
+										})
 										.subscribe({
 											next: ({ data, errors }) => {
 												if (Array.isArray(errors) && errors.length > 0) {
@@ -413,10 +423,11 @@ class SubscriptionProcessor {
 													return;
 												}
 
-												const predicatesGroup = ModelPredicateCreator.getPredicates(
-													this.syncPredicates.get(modelDefinition),
-													false
-												);
+												const predicatesGroup =
+													ModelPredicateCreator.getPredicates(
+														this.syncPredicates.get(modelDefinition),
+														false
+													);
 
 												const { [opName]: record } = data;
 
@@ -438,7 +449,7 @@ class SubscriptionProcessor {
 												}
 												this.drainBuffer();
 											},
-											error: subscriptionError => {
+											error: async subscriptionError => {
 												const {
 													error: { errors: [{ message = '' } = {}] } = {
 														errors: [],
@@ -464,6 +475,7 @@ class SubscriptionProcessor {
 														operationAuthModeAttempts[operation] >=
 														readAuthModes.length
 													) {
+														// last auth mode retry. Continue with error
 														logger.debug(
 															`${operation} subscription failed with authMode: ${
 																readAuthModes[
@@ -471,9 +483,9 @@ class SubscriptionProcessor {
 																]
 															}`
 														);
-														logger.warn('subscriptionError', message);
-														return;
 													} else {
+														// retry with different auth mode. Do not trigger
+														// observer error or error handler
 														logger.debug(
 															`${operation} subscription failed with authMode: ${
 																readAuthModes[
@@ -489,9 +501,29 @@ class SubscriptionProcessor {
 														return;
 													}
 												}
-
 												logger.warn('subscriptionError', message);
 
+												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,
+														model: modelDefinition.name,
+														operation,
+														errorType:
+															getSubscriptionErrorType(subscriptionError),
+														process: ProcessName.subscribe,
+														remoteModel: null,
+														cause: subscriptionError,
+													});
+												} catch (e) {
+													logger.error(
+														'Subscription error handler failed with:',
+														e
+													);
+												}
+
 												if (typeof subscriptionReadyCallback === 'function') {
 													subscriptionReadyCallback();
 												}
@@ -502,7 +534,6 @@ class SubscriptionProcessor {
 												) {
 													return;
 												}
-
 												observer.error(message);
 											},
 										})
@@ -534,15 +565,15 @@ class SubscriptionProcessor {
 
 			return () => {
 				Object.keys(subscriptions).forEach(modelName => {
-					subscriptions[modelName][
-						TransformerMutationType.CREATE
-					].forEach(subscription => subscription.unsubscribe());
-					subscriptions[modelName][
-						TransformerMutationType.UPDATE
-					].forEach(subscription => subscription.unsubscribe());
-					subscriptions[modelName][
-						TransformerMutationType.DELETE
-					].forEach(subscription => subscription.unsubscribe());
+					subscriptions[modelName][TransformerMutationType.CREATE].forEach(
+						subscription => subscription.unsubscribe()
+					);
+					subscriptions[modelName][TransformerMutationType.UPDATE].forEach(
+						subscription => subscription.unsubscribe()
+					);
+					subscriptions[modelName][TransformerMutationType.DELETE].forEach(
+						subscription => subscription.unsubscribe()
+					);
 				});
 			};
 		});