@aws-amplify/notifications 2.0.1-console-preview.5f040a2.0 → 2.0.1-console-preview.23dc225.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aws-amplify/notifications",
-  "version": "2.0.1-console-preview.5f040a2.0+5f040a2",
+  "version": "2.0.1-console-preview.23dc225.0+23dc225",
   "description": "Notifications category of aws-amplify",
   "main": "./lib/index.js",
   "module": "./lib-esm/index.js",
@@ -92,19 +92,18 @@
     "src"
   ],
   "dependencies": {
-    "lodash": "^4.17.21",
-    "uuid": "^9.0.0"
+    "lodash": "^4.17.21"
   },
   "peerDependencies": {
-    "@aws-amplify/core": "6.0.1-console-preview.5f040a2.0+5f040a2"
+    "@aws-amplify/core": "6.0.1-console-preview.23dc225.0+23dc225"
   },
   "devDependencies": {
-    "@aws-amplify/core": "6.0.1-console-preview.5f040a2.0+5f040a2",
+    "@aws-amplify/core": "6.0.1-console-preview.23dc225.0+23dc225",
     "@babel/core": "7.15.5",
     "@babel/plugin-proposal-class-properties": "^7.0.0",
     "@babel/plugin-proposal-private-methods": "^7.0.0",
     "@babel/plugin-proposal-private-property-in-object": "^7.0.0",
     "metro-react-native-babel-preset": "^0.66.2"
   },
-  "gitHead": "5f040a29ecebf29374ae9b58abc661f45143ac4f"
+  "gitHead": "23dc22531b963319f2b421f6f7c6cf867635b20e"
 }

package/src/common/AWSPinpointProviderCommon/index.ts

@@ -3,12 +3,12 @@
 
 import {
 	Category,
-	ClientDevice,
 	ConsoleLogger,
 	CustomUserAgentDetails,
 	getAmplifyUserAgent,
 	InAppMessagingAction,
 	PushNotificationAction,
+	amplifyUuid,
 } from '@aws-amplify/core/internals/utils';
 import { Cache, fetchAuthSession } from '@aws-amplify/core';
 
@@ -19,7 +19,6 @@ import {
 	updateEndpoint,
 	UpdateEndpointInput,
 } from '@aws-amplify/core/internals/aws-clients/pinpoint';
-import { v4 as uuid } from 'uuid';
 
 import {
 	NotificationsCategory,
@@ -35,15 +34,12 @@ export default abstract class AWSPinpointProviderCommon
 	static category: NotificationsCategory = 'Notifications';
 	static providerName = 'AWSPinpoint';
 
-	protected clientInfo;
 	protected config: Record<string, any> = {};
 	protected endpointInitialized = false;
 	protected initialized = false;
 	protected logger: ConsoleLogger;
 
 	constructor(logger) {
-		// this.config = { storage: new StorageHelper().getStorage() };
-		this.clientInfo = ClientDevice.clientInfo() ?? {};
 		this.logger = logger;
 	}
 
@@ -140,7 +136,7 @@ export default abstract class AWSPinpointProviderCommon
 						[endpointId]: {
 							Endpoint: {},
 							Events: {
-								[uuid()]: event,
+								[amplifyUuid()]: event,
 							},
 						},
 					},
@@ -185,14 +181,13 @@ export default abstract class AWSPinpointProviderCommon
 		try {
 			const { address, attributes, demographic, location, metrics, optOut } =
 				userInfo ?? {};
-			const { appVersion, make, model, platform, version } = this.clientInfo;
 			// Create the UpdateEndpoint input, prioritizing passed in user info and falling back to
 			// defaults (if any) obtained from the config
 			const input: UpdateEndpointInput = {
 				ApplicationId: appId,
 				EndpointId: endpointId,
 				EndpointRequest: {
-					RequestId: uuid(),
+					RequestId: amplifyUuid(),
 					EffectiveDate: new Date().toISOString(),
 					ChannelType: endpointInfo.channelType,
 					Address: address ?? endpointInfo.address,
@@ -201,11 +196,11 @@ export default abstract class AWSPinpointProviderCommon
 						...attributes,
 					},
 					Demographic: {
-						AppVersion: appVersion,
-						Make: make,
-						Model: model,
-						ModelVersion: version,
-						Platform: platform,
+						AppVersion: null,
+						Make: null,
+						Model: null,
+						ModelVersion: null,
+						Platform: null,
 						...this.transferKeyToUpperCase({
 							...endpointInfo.demographic,
 							...demographic,
@@ -252,7 +247,7 @@ export default abstract class AWSPinpointProviderCommon
 			return cachedEndpointId;
 		}
 		// Otherwise, generate a new ID and store it in long-lived cache before returning it
-		const endpointId = uuid();
+		const endpointId = amplifyUuid();
 		// Set a longer TTL to avoid endpoint id being deleted after the default TTL (3 days)
 		// Also set its priority to the highest to reduce its chance of being deleted when cache is full
 		const ttl = 1000 * 60 * 60 * 24 * 365 * 100; // 100 years

package/src/common/eventListeners/index.ts

@@ -1,7 +1,7 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { EventListener, EventType } from './types';
+import { EventListener, EventListenerRemover, EventType } from './types';
 
 const eventListeners: Record<string, Set<EventListener<Function>>> = {};
 
@@ -28,7 +28,7 @@ export const notifyEventListenersAndAwaitHandlers = (
 export const addEventListener = <EventHandler extends Function>(
 	type: EventType,
 	handler: EventHandler
-): EventListener<EventHandler> => {
+): EventListenerRemover => {
 	// If there is no listener set for the event type, just create it
 	if (!eventListeners[type]) {
 		eventListeners[type] = new Set<EventListener<EventHandler>>();
@@ -40,5 +40,7 @@ export const addEventListener = <EventHandler extends Function>(
 		},
 	};
 	eventListeners[type].add(listener);
-	return listener;
+	return {
+		remove: () => listener.remove(),
+	};
 };

package/src/common/eventListeners/types.ts

@@ -10,3 +10,7 @@ export interface EventListener<EventHandler extends Function> {
 }
 
 export type EventType = InAppMessageInteractionEvent | PushNotificationEvent;
+
+export type EventListenerRemover = {
+	remove: () => void;
+};

package/src/common/index.ts

@@ -7,4 +7,8 @@ export {
 	notifyEventListeners,
 	notifyEventListenersAndAwaitHandlers,
 } from './eventListeners';
-export { EventListener, EventType } from './eventListeners/types';
+export {
+	EventListener,
+	EventType,
+	EventListenerRemover,
+} from './eventListeners/types';

package/src/inAppMessaging/errors/validation.ts

@@ -8,6 +8,7 @@ export enum InAppMessagingValidationErrorCode {
 	NoCredentials = 'NoCredentials',
 	NoRegion = 'NoRegion',
 	NoEndpointId = 'NoEndpointId',
+	NotInitialized = 'NotInitialized',
 }
 
 export const validationErrorMap: AmplifyErrorMap<InAppMessagingValidationErrorCode> =
@@ -24,4 +25,9 @@ export const validationErrorMap: AmplifyErrorMap<InAppMessagingValidationErrorCo
 		[InAppMessagingValidationErrorCode.NoEndpointId]: {
 			message: 'Could not find or create EndpointId.',
 		},
+		[InAppMessagingValidationErrorCode.NotInitialized]: {
+			message: 'In-app messaging has not been initialized.',
+			recoverySuggestion:
+				'Please make sure to first call `initializePushNotifications`.',
+		},
 	};

package/src/inAppMessaging/index.ts

@@ -1,4 +1,15 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { identifyUser, syncMessages } from './providers/pinpoint';
+export {
+	identifyUser,
+	syncMessages,
+	dispatchEvent,
+	setConflictHandler,
+	initializeInAppMessaging,
+	onMessageReceived,
+	onMessageDisplayed,
+	onMessageDismissed,
+	onMessageActionTaken,
+	notifyMessageInteraction,
+} from './providers/pinpoint';

package/src/inAppMessaging/providers/index.ts

@@ -1,4 +1,15 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { identifyUser, syncMessages } from './pinpoint/apis';
+export {
+	identifyUser,
+	syncMessages,
+	dispatchEvent,
+	setConflictHandler,
+	initializeInAppMessaging,
+	onMessageReceived,
+	onMessageDisplayed,
+	onMessageDismissed,
+	onMessageActionTaken,
+	notifyMessageInteraction,
+} from './pinpoint/apis';

package/src/inAppMessaging/providers/pinpoint/apis/dispatchEvent.ts

@@ -0,0 +1,63 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	PINPOINT_KEY_PREFIX,
+	STORAGE_KEY_SUFFIX,
+	processInAppMessages,
+} from '../utils';
+import { InAppMessage } from '../../../types';
+import flatten from 'lodash/flatten';
+import { defaultStorage } from '@aws-amplify/core';
+import { notifyEventListeners } from '../../../../common';
+import { assertServiceError } from '../../../errors';
+import { DispatchEventInput } from '../types';
+import { syncMessages } from './syncMessages';
+import { conflictHandler, setConflictHandler } from './setConflictHandler';
+import { assertIsInitialized } from '../../../utils';
+
+/**
+ * Triggers an In-App message to be displayed. Use this after your campaigns have been synced to the device using
+ * {@link syncMessages}. Based on the messages synced and the event passed to this API, it triggers the display
+ * of the In-App message that meets the criteria.
+ *
+ * @remark
+ * If an event would trigger multiple messages, the message closest to expiry will be chosen by default.
+ * To change this behavior, you can use the {@link setConflictHandler} API to provide
+ * your own logic for resolving message conflicts.
+ *
+ * @param DispatchEventInput The input object that holds the event to be dispatched.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @throws service exceptions - Thrown when the underlying Pinpoint service returns an error.
+ * @returns A promise that will resolve when the operation is complete.
+ * @example
+ * ```ts
+ * // Sync message before disptaching an event
+ * await syncMessages();
+ *
+ * // Dispatch an event
+ * await dispatchEvent({ name: 'test_event' });
+ * ```
+ */
+export async function dispatchEvent(input: DispatchEventInput): Promise<void> {
+	assertIsInitialized();
+	try {
+		const key = `${PINPOINT_KEY_PREFIX}${STORAGE_KEY_SUFFIX}`;
+		const cachedMessages = await defaultStorage.getItem(key);
+		const messages: InAppMessage[] = await processInAppMessages(
+			cachedMessages ? JSON.parse(cachedMessages) : [],
+			input
+		);
+		const flattenedMessages = flatten(messages);
+		if (flattenedMessages.length > 0) {
+			notifyEventListeners(
+				'messageReceived',
+				conflictHandler(flattenedMessages)
+			);
+		}
+	} catch (error) {
+		assertServiceError(error);
+		throw error;
+	}
+}

package/src/inAppMessaging/providers/pinpoint/apis/identifyUser.ts

@@ -12,6 +12,7 @@ import {
 	resolveCredentials,
 } from '../utils';
 import { IdentifyUserInput } from '../types';
+import { assertIsInitialized } from '../../../utils';
 
 /**
  * Sends information about a user to Pinpoint. Sending user information allows you to associate a user to their user
@@ -20,13 +21,10 @@ import { IdentifyUserInput } from '../types';
  *
  * @param {IdentifyUserParameters} params The input object used to construct requests sent to Pinpoint's UpdateEndpoint
  *  API.
- *
  * @throws service: {@link UpdateEndpointException} - Thrown when the underlying Pinpoint service returns an error.
  * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
- *  configuration is incorrect.
- *
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
  * @returns A promise that will resolve when the operation is complete.
- *
  * @example
  * ```ts
  * // Identify a user with Pinpoint
@@ -72,6 +70,7 @@ export const identifyUser = async ({
 	userProfile,
 	options,
 }: IdentifyUserInput): Promise<void> => {
+	assertIsInitialized();
 	const { credentials, identityId } = await resolveCredentials();
 	const { appId, region } = resolveConfig();
 	const { address, optOut, userAttributes } = options?.serviceOptions ?? {};

package/src/inAppMessaging/providers/pinpoint/apis/index.ts

@@ -3,3 +3,11 @@
 
 export { identifyUser } from './identifyUser';
 export { syncMessages } from './syncMessages';
+export { dispatchEvent } from './dispatchEvent';
+export { setConflictHandler } from './setConflictHandler';
+export { initializeInAppMessaging } from './initializeInAppMessaging';
+export { onMessageReceived } from './onMessageReceived';
+export { onMessageDismissed } from './onMessageDismissed';
+export { onMessageDisplayed } from './onMessageDisplayed';
+export { onMessageActionTaken } from './onMessageActionTaken';
+export { notifyMessageInteraction } from './notifyMessageInteraction';

package/src/inAppMessaging/providers/pinpoint/apis/initializeInAppMessaging.ts

@@ -0,0 +1,64 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import SessionTracker from '../../../sessionTracker';
+import { InAppMessage, InAppMessagingEvent } from '../../../types';
+import { addEventListener } from '../../../../common';
+import { recordAnalyticsEvent } from '../utils/helpers';
+import { PinpointMessageEvent } from '../types';
+import { Hub, HubCapsule } from '@aws-amplify/core';
+import { dispatchEvent } from './dispatchEvent';
+import { incrementMessageCounts, sessionStateChangeHandler } from '../utils';
+import { isInitialized, initialize } from '../../../utils';
+
+/**
+ * Initialize and set up in-app messaging category. This API needs to be called to enable other InAppMessaging APIs.
+ *
+ * @remarks
+ * Make sure to call this early in your app at the root entry point after configuring Amplify.
+ * @example
+ * ```ts
+ * Amplify.configure(config);
+ * initializeInAppMessaging();
+ * ```
+ */
+export function initializeInAppMessaging(): void {
+	if (isInitialized()) {
+		return;
+	}
+	// set up the session tracker and start it
+	const sessionTracker = new SessionTracker(sessionStateChangeHandler);
+	sessionTracker.start();
+
+	// wire up default Pinpoint message event handling
+	addEventListener('messageDisplayed', (message: InAppMessage) => {
+		console.log('Recording message displayed event');
+		recordAnalyticsEvent(PinpointMessageEvent.MESSAGE_DISPLAYED, message);
+		incrementMessageCounts(message.id);
+	});
+	addEventListener('messageDismissed', (message: InAppMessage) => {
+		recordAnalyticsEvent(PinpointMessageEvent.MESSAGE_DISMISSED, message);
+	});
+	addEventListener('messageActionTaken', (message: InAppMessage) => {
+		recordAnalyticsEvent(PinpointMessageEvent.MESSAGE_ACTION_TAKEN, message);
+	});
+
+	// listen to analytics hub events
+	Hub.listen('analytics', analyticsListener);
+
+	initialize();
+}
+
+function analyticsListener({
+	payload,
+}: HubCapsule<string, { event: string; data: InAppMessagingEvent }>) {
+	const { event, data } = payload;
+	switch (event) {
+		case 'record': {
+			dispatchEvent(data);
+			break;
+		}
+		default:
+			break;
+	}
+}

package/src/inAppMessaging/providers/pinpoint/apis/notifyMessageInteraction.ts

@@ -0,0 +1,28 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { notifyEventListeners } from '../../../../common';
+import { assertIsInitialized } from '../../../utils';
+import { NotifyMessageInteractionInput } from '../types/inputs';
+
+/**
+ * Notifies the respective listener of the specified type with the message given.
+ *
+ * @param {NotifyMessageInteractionInput} input - The input object that holds the type and message.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @example
+ * ```ts
+ * onMessageRecieved((message) => {
+ *   // Show end users the In-App message and notify event listeners
+ *   notifyMessageInteraction({ type: 'messageDisplayed', message });
+ * });
+ * ```
+ */
+export function notifyMessageInteraction({
+	type,
+	message,
+}: NotifyMessageInteractionInput): void {
+	assertIsInitialized();
+	notifyEventListeners(type, message);
+}

package/src/inAppMessaging/providers/pinpoint/apis/onMessageActionTaken.ts

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../common';
+import { assertIsInitialized } from '../../../utils';
+import { OnMessageActionTakenInput } from '../types/inputs';
+import { OnMessageActionTakenOutput } from '../types/outputs';
+
+/**
+ * Registers a callback that will be invoked on `messageActionTaken` events.
+ *
+ * @param {OnMessageActionTakenInput} input - The input object that holds the callback handler.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @returns {OnMessageActionTakenOutput} - An object that holds a remove method to stop listening to events.
+ * @example
+ * ```ts
+ * onMessageActionTaken((message) => {
+ *   // use the message
+ *   console.log(message.id);
+ * });
+ * ```
+ */
+export function onMessageActionTaken(
+	input: OnMessageActionTakenInput
+): OnMessageActionTakenOutput {
+	assertIsInitialized();
+	return addEventListener('messageActionTaken', input);
+}

package/src/inAppMessaging/providers/pinpoint/apis/onMessageDismissed.ts

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../common';
+import { OnMessageDismissedOutput } from '../types/outputs';
+import { OnMessageDismissedInput } from '../types/inputs';
+import { assertIsInitialized } from '../../../utils';
+
+/**
+ * Registers a callback that will be invoked on `messageDismissed` events.
+ *
+ * @param {OnMessageDismissedInput} input - The input object that holds the callback handler.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @returns {OnMessageDismissedOutput} - An object that holds a remove method to stop listening to events.
+ * @example
+ * ```ts
+ * onMessageDismissed((message) => {
+ *   // use the message
+ *   console.log(message.id);
+ * });
+ * ```
+ */
+export function onMessageDismissed(
+	input: OnMessageDismissedInput
+): OnMessageDismissedOutput {
+	assertIsInitialized();
+	return addEventListener('messageDismissed', input);
+}

package/src/inAppMessaging/providers/pinpoint/apis/onMessageDisplayed.ts

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../common';
+import { OnMessageDisplayedOutput } from '../types/outputs';
+import { OnMessageDisplayedInput } from '../types/inputs';
+import { assertIsInitialized } from '../../../utils';
+
+/**
+ * Registers a callback that will be invoked on `messageDisplayed` events.
+ *
+ * @param {OnMessageDisplayedInput} input - The input object that holds the callback handler.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @returns {OnMessageDismissedOutput} - An object that holds a remove method to stop listening to events.
+ * @example
+ * ```ts
+ * onMessageDisplayed((message) => {
+ *   // use the message
+ * 	 console.log(message.id);
+ * });
+ * ```
+ */
+export function onMessageDisplayed(
+	input: OnMessageDisplayedInput
+): OnMessageDisplayedOutput {
+	assertIsInitialized();
+	return addEventListener('messageDisplayed', input);
+}

package/src/inAppMessaging/providers/pinpoint/apis/onMessageReceived.ts

@@ -0,0 +1,29 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { addEventListener } from '../../../../common';
+import { assertIsInitialized } from '../../../utils';
+import { OnMessageReceivedInput } from '../types/inputs';
+import { OnMessageReceivedOutput } from '../types/outputs';
+
+/**
+ * Registers a callback that will be invoked on `messageReceived` events.
+ *
+ * @param {OnMessageReceivedInput} input - The input object that holds the callback handler.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @returns {OnMessageReceivedOutput} - An object that holds a remove method to stop listening to events.
+ * @example
+ * ```ts
+ * onMessageReceived((message) => {
+ *   // use the message
+ *   console.log(message.id);
+ * });
+ * ```
+ */
+export function onMessageReceived(
+	input: OnMessageReceivedInput
+): OnMessageReceivedOutput {
+	assertIsInitialized();
+	return addEventListener('messageReceived', input);
+}

package/src/inAppMessaging/providers/pinpoint/apis/setConflictHandler.ts

@@ -0,0 +1,68 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { InAppMessage } from '../../../types';
+import { assertIsInitialized } from '../../../utils';
+import { InAppMessageConflictHandler, SetConflictHandlerInput } from '../types';
+
+export let conflictHandler: InAppMessageConflictHandler =
+	defaultConflictHandler;
+
+/**
+ * Set a conflict handler that will be used to resolve conflicts that may emerge
+ * when matching events with synced messages.
+ *
+ * @remark
+ * The conflict handler is not persisted across app restarts and so must be set again before dispatching an event for
+ * any custom handling to take effect.
+ * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
+ * @param SetConflictHandlerInput: The input object that holds the conflict handler to be used.
+ * @example
+ * ```ts
+ * // Sync messages before dispatching an event
+ * await syncMessages();
+ *
+ * // Example custom conflict handler
+ * const myConflictHandler = (messages) => {
+ * 		// Return a random message
+ * 		const randomIndex = Math.floor(Math.random() * messages.length);
+ * 		return messages[randomIndex];
+ *  };
+ *
+ * // Set the conflict handler
+ * setConflictHandler(myConflictHandler);
+ *
+ * // Dispatch an event
+ * await dispatchEvent({ name: 'test_event' });
+ * ```
+ */
+export function setConflictHandler(input: SetConflictHandlerInput): void {
+	assertIsInitialized();
+	conflictHandler = input;
+}
+
+function defaultConflictHandler(messages: InAppMessage[]): InAppMessage {
+	// default behavior is to return the message closest to expiry
+	// this function assumes that messages processed by providers already filters out expired messages
+	const sorted = messages.sort((a, b) => {
+		const endDateA = a.metadata?.endDate;
+		const endDateB = b.metadata?.endDate;
+		// if both message end dates are falsy or have the same date string, treat them as equal
+		if (endDateA === endDateB) {
+			return 0;
+		}
+		// if only message A has an end date, treat it as closer to expiry
+		if (endDateA && !endDateB) {
+			return -1;
+		}
+		// if only message B has an end date, treat it as closer to expiry
+		if (!endDateA && endDateB) {
+			return 1;
+		}
+		// otherwise, compare them
+		return new Date(endDateA) < new Date(endDateB) ? -1 : 1;
+	});
+	// always return the top sorted
+	return sorted[0];
+}

package/src/inAppMessaging/providers/pinpoint/apis/syncMessages.ts

@@ -26,6 +26,7 @@ import {
 	assertServiceError,
 	assertValidationError,
 } from '../../../errors';
+import { assertIsInitialized } from '../../../utils';
 
 /**
  * Fetch and persist messages from Pinpoint campaigns.
@@ -33,10 +34,8 @@ import {
  *
  * @throws service exceptions - Thrown when the underlying Pinpoint service returns an error.
  * @throws validation: {@link InAppMessagingValidationErrorCode} - Thrown when the provided parameters or library
- *  configuration is incorrect.
- *
+ * configuration is incorrect, or if In App messaging hasn't been initialized.
  * @returns A promise that will resolve when the operation is complete.
- *
  * @example
  * ```ts
  * // Sync InApp messages with Pinpoint and device.
@@ -45,8 +44,9 @@ import {
  * ```
  */
 export async function syncMessages(): Promise<void> {
+	assertIsInitialized();
 	const messages = await fetchInAppMessages();
-	if (messages.length === 0) {
+	if (!messages || messages.length === 0) {
 		return;
 	}
 	try {
@@ -95,7 +95,8 @@ async function fetchInAppMessages() {
 			{ credentials, region },
 			input
 		);
-		const { InAppMessageCampaigns: messages } = response.InAppMessagesResponse;
+		const { InAppMessageCampaigns: messages } =
+			response.InAppMessagesResponse ?? {};
 		return messages;
 	} catch (error) {
 		assertServiceError(error);

package/src/inAppMessaging/providers/pinpoint/index.ts

@@ -1,4 +1,15 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-export { identifyUser, syncMessages } from './apis';
+export {
+	identifyUser,
+	syncMessages,
+	dispatchEvent,
+	setConflictHandler,
+	initializeInAppMessaging,
+	onMessageReceived,
+	onMessageDisplayed,
+	onMessageDismissed,
+	onMessageActionTaken,
+	notifyMessageInteraction,
+} from './apis';