@aws-amplify/datastore 3.10.1-unstable.7 → 3.11.0

package/src/sync/processors/subscription.ts

@@ -12,6 +12,8 @@ import {
 	PredicatesGroup,
 	ModelPredicate,
 	AuthModeStrategy,
+	ErrorHandler,
+	ProcessName,
 } from '../../types';
 import {
 	buildSubscriptionGraphQLOperation,
@@ -20,12 +22,27 @@ import {
 	getUserGroupsFromToken,
 	TransformerMutationType,
 	getTokenForCustomAuth,
+	mapErrorToType,
+	ErrorMap,
 } from '../utils';
 import { ModelPredicateCreator } from '../../predicates';
 import { validatePredicate } from '../../util';
 
 const logger = new Logger('DataStore');
 
+// TODO: add additional error maps
+const errorMap = {
+	Unauthorized: (givenError: any) => {
+		const {
+			error: { errors: [{ message = '' } = {}] } = {
+				errors: [],
+			},
+		} = givenError;
+		const regex = /Connection failed.+Unauthorized/;
+		return regex.test(message);
+	},
+} as ErrorMap;
+
 export enum CONTROL_MSG {
 	CONNECTED = 'CONNECTED',
 }
@@ -56,7 +73,8 @@ class SubscriptionProcessor {
 		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 buildSubscription(
@@ -436,12 +454,31 @@ class SubscriptionProcessor {
 												}
 												this.drainBuffer();
 											},
-											error: subscriptionError => {
+											error: async subscriptionError => {
 												const {
 													error: { errors: [{ message = '' } = {}] } = {
 														errors: [],
 													},
 												} = subscriptionError;
+												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: mapErrorToType(
+															errorMap,
+															subscriptionError
+														),
+														process: ProcessName.subscribe,
+														remoteModel: null,
+														cause: subscriptionError,
+													});
+												} catch (e) {
+													logger.error('Sync error handler failed with:', e);
+												}
 
 												if (
 													message.includes(
@@ -487,7 +524,6 @@ class SubscriptionProcessor {
 														return;
 													}
 												}
-
 												logger.warn('subscriptionError', message);
 
 												if (typeof subscriptionReadyCallback === 'function') {
@@ -500,7 +536,6 @@ class SubscriptionProcessor {
 												) {
 													return;
 												}
-
 												observer.error(message);
 											},
 										})

package/src/sync/processors/sync.ts

@@ -8,6 +8,8 @@ import {
 	PredicatesGroup,
 	GraphQLFilter,
 	AuthModeStrategy,
+	ErrorHandler,
+	ProcessName,
 } from '../../types';
 import {
 	buildGraphQLOperation,
@@ -16,6 +18,8 @@ import {
 	getForbiddenError,
 	predicateToGraphQLFilter,
 	getTokenForCustomAuth,
+	mapErrorToType,
+	ErrorMap,
 } from '../utils';
 import {
 	jitteredExponentialRetry,
@@ -24,7 +28,7 @@ import {
 	NonRetryableError,
 } from '@aws-amplify/core';
 import { ModelPredicateCreator } from '../../predicates';
-
+import { ModelInstanceCreator } from '../../datastore/datastore';
 const opResultDefaults = {
 	items: [],
 	nextToken: null,
@@ -33,6 +37,11 @@ const opResultDefaults = {
 
 const logger = new Logger('DataStore');
 
+// TODO: add additional error maps
+const errorMap = {
+	BadRecord: error => /^Cannot return \w+ for [\w-_]+ type/.test(error.message),
+} as ErrorMap;
+
 class SyncProcessor {
 	private readonly typeQuery = new WeakMap<SchemaModel, [string, string]>();
 
@@ -40,7 +49,9 @@ class SyncProcessor {
 		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 modelInstanceCreator?: ModelInstanceCreator
 	) {
 		this.generateQueries();
 	}
@@ -223,15 +234,33 @@ class SyncProcessor {
 							error.data[opName] &&
 							error.data[opName].items
 					);
-
 					if (this.partialDataFeatureFlagEnabled()) {
 						if (hasItems) {
 							const result = error;
 							result.data[opName].items = result.data[opName].items.filter(
 								item => item !== null
 							);
-
 							if (error.errors) {
+								await Promise.all(
+									error.errors.map(async err => {
+										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: err.message,
+												model: modelDefinition.name,
+												operation: opName,
+												errorType: mapErrorToType(errorMap, err),
+												process: ProcessName.sync,
+												remoteModel: null,
+												cause: err,
+											});
+										} catch (e) {
+											logger.error('Sync error handler failed with:', e);
+										}
+									})
+								);
 								Hub.dispatch('datastore', {
 									event: 'syncQueriesPartialSyncError',
 									data: {

package/src/sync/utils.ts

@@ -26,6 +26,7 @@ import {
 	ModelOperation,
 	InternalSchema,
 	AuthModeStrategy,
+	ErrorType,
 } from '../types';
 import { exhaustiveCheck } from '../util';
 import { MutationEvent } from './';
@@ -40,6 +41,27 @@ enum GraphQLOperationType {
 	GET = 'query',
 }
 
+export type ErrorMap = {
+	[key in ErrorType]: (error: Error) => boolean;
+};
+
+/**
+ * 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';
+}
+
 export enum TransformerMutationType {
 	CREATE = 'Create',
 	UPDATE = 'Update',

package/src/types.ts

@@ -658,7 +658,7 @@ export type DataStoreConfig = {
 	DataStore?: {
 		authModeStrategyType?: AuthModeStrategyType;
 		conflictHandler?: ConflictHandler; // default : retry until client wins up to x times
-		errorHandler?: (error: SyncError) => void; // default : logger.warn
+		errorHandler?: (error: SyncError<PersistentModel>) => void; // default : logger.warn
 		maxRecordsToSync?: number; // merge
 		syncPageSize?: number;
 		fullSyncInterval?: number;
@@ -668,7 +668,7 @@ export type DataStoreConfig = {
 	};
 	authModeStrategyType?: AuthModeStrategyType;
 	conflictHandler?: ConflictHandler; // default : retry until client wins up to x times
-	errorHandler?: (error: SyncError) => void; // default : logger.warn
+	errorHandler?: (error: SyncError<PersistentModel>) => void; // default : logger.warn
 	maxRecordsToSync?: number; // merge
 	syncPageSize?: number;
 	fullSyncInterval?: number;
@@ -775,15 +775,32 @@ export type SyncConflict = {
 	attempts: number;
 };
 
-export type SyncError = {
+export type SyncError<T extends PersistentModel> = {
 	message: string;
-	errorType: string;
-	errorInfo: string;
-	localModel: PersistentModel;
-	remoteModel: PersistentModel;
+	errorType: ErrorType;
+	errorInfo?: string;
+	recoverySuggestion?: string;
+	model?: string;
+	localModel: T;
+	remoteModel: T;
+	process: ProcessName;
 	operation: string;
+	cause?: Error;
 };
 
+export type ErrorType =
+	| 'ConfigError'
+	| 'BadRecord'
+	| 'Unauthorized'
+	| 'Transient'
+	| 'Unknown';
+
+export enum ProcessName {
+	'sync' = 'sync',
+	'mutate' = 'mutate',
+	'subscribe' = 'subscribe',
+}
+
 export const DISCARD = Symbol('DISCARD');
 
 export type ConflictHandler = (
@@ -792,7 +809,7 @@ export type ConflictHandler = (
 	| Promise<PersistentModel | typeof DISCARD>
 	| PersistentModel
 	| typeof DISCARD;
-export type ErrorHandler = (error: SyncError) => void;
+export type ErrorHandler = (error: SyncError<PersistentModel>) => void;
 
 export type DeferredCallbackResolverOptions = {
 	callback: () => void;