@aws-amplify/notifications 1.3.3-api-v6.24 → 1.3.3-api-v6.29

package/src/InAppMessaging/InAppMessaging.ts

@@ -1,78 +1,14 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import {
-	ConsoleLogger as Logger,
-	HubCallback,
-	HubCapsule,
-	Hub,
-	StorageHelper,
-} from '@aws-amplify/core';
-import flatten from 'lodash/flatten';
-
-import {
-	addEventListener,
-	EventListener,
-	notifyEventListeners,
-} from '../common';
 import { UserInfo } from '../types';
-import { AWSPinpointProvider } from './Providers';
-import {
-	InAppMessage,
-	InAppMessageInteractionEvent,
-	InAppMessagingInterface,
-	InAppMessagingConfig,
-	InAppMessageConflictHandler,
-	InAppMessagingEvent,
-	InAppMessagingProvider,
-	NotificationsSubCategory,
-	OnMessageInteractionEventHandler,
-} from './types';
-
-const STORAGE_KEY_SUFFIX = '_inAppMessages';
-
-const logger = new Logger('Notifications.InAppMessaging');
-
-export default class InAppMessaging implements InAppMessagingInterface {
-	private config: Record<string, any> = {};
-	private conflictHandler: InAppMessageConflictHandler;
-	private listeningForAnalyticEvents = false;
-	private pluggables: InAppMessagingProvider[] = [];
-	private storageSynced = false;
-
-	constructor() {
-		this.config = { storage: new StorageHelper().getStorage() };
-		this.setConflictHandler(this.defaultConflictHandler);
-	}
-
-	/**
-	 * Configure InAppMessaging
-	 * @param {Object} config - InAppMessaging configuration object
-	 */
-	configure = ({
-		listenForAnalyticsEvents = true,
-		...config
-	}: InAppMessagingConfig = {}): InAppMessagingConfig => {
-		this.config = { ...this.config, ...config };
-
-		logger.debug('configure InAppMessaging', this.config);
-
-		this.pluggables.forEach(pluggable => {
-			pluggable.configure(this.config[pluggable.getProviderName()]);
-		});
-
-		if (this.pluggables.length === 0) {
-			this.addPluggable(new AWSPinpointProvider());
-		}
-
-		if (listenForAnalyticsEvents && !this.listeningForAnalyticEvents) {
-			Hub.listen('analytics', this.analyticsListener);
-			this.listeningForAnalyticEvents = true;
-		}
-
-		return this.config;
-	};
+import { InAppMessagingInterface, NotificationsSubCategory } from './types';
+import { InternalInAppMessagingClass } from '../internals/InternalInAppMessaging';
 
+export default class InAppMessaging
+	extends InternalInAppMessagingClass
+	implements InAppMessagingInterface
+{
 	/**
 	 * Get the name of this module
 	 * @returns {string} name of this module
@@ -81,241 +17,13 @@ export default class InAppMessaging implements InAppMessagingInterface {
 		return 'InAppMessaging';
 	}
 
-	/**
-	 * Get a plugin from added plugins
-	 * @param {string} providerName - the name of the plugin to get
-	 */
-	getPluggable = (providerName: string): InAppMessagingProvider => {
-		const pluggable =
-			this.pluggables.find(
-				pluggable => pluggable.getProviderName() === providerName
-			) ?? null;
-
-		if (!pluggable) {
-			logger.debug(`No plugin found with name ${providerName}`);
-		}
-
-		return pluggable;
-	};
-
-	/**
-	 * Add plugin into InAppMessaging
-	 * @param {InAppMessagingProvider} pluggable - an instance of the plugin
-	 */
-	addPluggable = (pluggable: InAppMessagingProvider): void => {
-		if (
-			pluggable &&
-			pluggable.getCategory() === 'Notifications' &&
-			pluggable.getSubCategory() === 'InAppMessaging'
-		) {
-			if (this.getPluggable(pluggable.getProviderName())) {
-				throw new Error(
-					`Pluggable ${pluggable.getProviderName()} has already been added.`
-				);
-			}
-			this.pluggables.push(pluggable);
-			pluggable.configure(this.config[pluggable.getProviderName()]);
-		}
-	};
-
-	/**
-	 * Remove a plugin from added plugins
-	 * @param {string} providerName - the name of the plugin to remove
-	 */
-	removePluggable = (providerName: string): void => {
-		const index = this.pluggables.findIndex(
-			pluggable => pluggable.getProviderName() === providerName
-		);
-		if (index === -1) {
-			logger.debug(`No plugin found with name ${providerName}`);
-		} else {
-			this.pluggables.splice(index, 1);
-		}
-	};
-
 	/**
 	 * Get the map resources that are currently available through the provider
 	 * @param {string} provider
 	 * @returns - Array of available map resources
 	 */
-	syncMessages = (): Promise<void[]> =>
-		Promise.all<void>(
-			this.pluggables.map(async pluggable => {
-				try {
-					const messages = await pluggable.getInAppMessages();
-					const key = `${pluggable.getProviderName()}${STORAGE_KEY_SUFFIX}`;
-					await this.setMessages(key, messages);
-				} catch (err) {
-					logger.error('Failed to sync messages', err);
-					throw err;
-				}
-			})
-		);
-
-	clearMessages = (): Promise<void[]> =>
-		Promise.all<void>(
-			this.pluggables.map(async pluggable => {
-				const key = `${pluggable.getProviderName()}${STORAGE_KEY_SUFFIX}`;
-				await this.removeMessages(key);
-			})
-		);
-
-	dispatchEvent = async (event: InAppMessagingEvent): Promise<void> => {
-		const messages: InAppMessage[][] = await Promise.all<InAppMessage[]>(
-			this.pluggables.map(async pluggable => {
-				const key = `${pluggable.getProviderName()}${STORAGE_KEY_SUFFIX}`;
-				const messages = await this.getMessages(key);
-				return pluggable.processInAppMessages(messages, event);
-			})
-		);
-
-		const flattenedMessages = flatten(messages);
-
-		if (flattenedMessages.length) {
-			notifyEventListeners(
-				InAppMessageInteractionEvent.MESSAGE_RECEIVED,
-				this.conflictHandler(flattenedMessages)
-			);
-		}
-	};
+	syncMessages = (): Promise<void[]> => super.syncMessages();
 
 	identifyUser = (userId: string, userInfo: UserInfo): Promise<void[]> =>
-		Promise.all<void>(
-			this.pluggables.map(async pluggable => {
-				try {
-					await pluggable.identifyUser(userId, userInfo);
-				} catch (err) {
-					logger.error('Failed to identify user', err);
-					throw err;
-				}
-			})
-		);
-
-	onMessageReceived = (
-		handler: OnMessageInteractionEventHandler
-	): EventListener<OnMessageInteractionEventHandler> =>
-		addEventListener(InAppMessageInteractionEvent.MESSAGE_RECEIVED, handler);
-
-	onMessageDisplayed = (
-		handler: OnMessageInteractionEventHandler
-	): EventListener<OnMessageInteractionEventHandler> =>
-		addEventListener(InAppMessageInteractionEvent.MESSAGE_DISPLAYED, handler);
-
-	onMessageDismissed = (
-		handler: OnMessageInteractionEventHandler
-	): EventListener<OnMessageInteractionEventHandler> =>
-		addEventListener(InAppMessageInteractionEvent.MESSAGE_DISMISSED, handler);
-
-	onMessageActionTaken = (
-		handler: OnMessageInteractionEventHandler
-	): EventListener<OnMessageInteractionEventHandler> =>
-		addEventListener(
-			InAppMessageInteractionEvent.MESSAGE_ACTION_TAKEN,
-			handler
-		);
-
-	notifyMessageInteraction = (
-		message: InAppMessage,
-		type: InAppMessageInteractionEvent
-	): void => {
-		notifyEventListeners(type, message);
-	};
-
-	setConflictHandler = (handler: InAppMessageConflictHandler): void => {
-		this.conflictHandler = handler;
-	};
-
-	private analyticsListener: HubCallback = ({ payload }: HubCapsule) => {
-		const { event, data } = payload;
-		switch (event) {
-			case 'record': {
-				this.dispatchEvent(data);
-				break;
-			}
-			default:
-				break;
-		}
-	};
-
-	private syncStorage = async (): Promise<void> => {
-		const { storage } = this.config;
-		try {
-			// Only run sync() if it's available (i.e. React Native)
-			if (typeof storage.sync === 'function') {
-				await storage.sync();
-			}
-			this.storageSynced = true;
-		} catch (err) {
-			logger.error('Failed to sync storage', err);
-		}
-	};
-
-	private getMessages = async (key: string): Promise<any> => {
-		try {
-			if (!this.storageSynced) {
-				await this.syncStorage();
-			}
-			const { storage } = this.config;
-			const storedMessages = storage.getItem(key);
-			return storedMessages ? JSON.parse(storedMessages) : [];
-		} catch (err) {
-			logger.error('Failed to retrieve in-app messages from storage', err);
-		}
-	};
-
-	private setMessages = async (
-		key: string,
-		messages: InAppMessage[]
-	): Promise<void> => {
-		if (!messages) {
-			return;
-		}
-
-		try {
-			if (!this.storageSynced) {
-				await this.syncStorage();
-			}
-			const { storage } = this.config;
-			storage.setItem(key, JSON.stringify(messages));
-		} catch (err) {
-			logger.error('Failed to store in-app messages', err);
-		}
-	};
-
-	private removeMessages = async (key: string): Promise<void> => {
-		try {
-			if (!this.storageSynced) {
-				await this.syncStorage();
-			}
-			const { storage } = this.config;
-			storage.removeItem(key);
-		} catch (err) {
-			logger.error('Failed to remove in-app messages from storage', err);
-		}
-	};
-
-	private 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];
-	};
+		super.identifyUser(userId, userInfo);
 }

package/src/InAppMessaging/Providers/AWSPinpointProvider/index.ts

@@ -111,7 +111,7 @@ export default class AWSPinpointProvider
 		return this.config;
 	};
 
-	getInAppMessages = async () => {
+	getInAppMessages = async (userAgentValue?: string) => {
 		if (!this.initialized) {
 			await this.init();
 		}
@@ -129,7 +129,7 @@ export default class AWSPinpointProvider
 			};
 			this.logger.debug('getting in-app messages');
 			const response: GetInAppMessagesOutput = await getInAppMessages(
-				{ credentials, region },
+				{ credentials, region, userAgentValue },
 				input
 			);
 			const { InAppMessageCampaigns: messages } =

package/src/InAppMessaging/types.ts

@@ -4,6 +4,7 @@
 import { EventListener } from '../common';
 import { AWSPinpointProviderConfig } from '../common/AWSPinpointProviderCommon/types';
 import {
+	NotificationsConfig,
 	NotificationsProvider,
 	NotificationsSubCategory as NotificationsSubCategories,
 	UserInfo,
@@ -13,10 +14,13 @@ export type NotificationsSubCategory = Extract<
 	NotificationsSubCategories,
 	'InAppMessaging'
 >;
+export type InternalNotificationsSubCategory = 'InternalInAppMessaging';
 
 export interface InAppMessagingInterface {
-	configure: (config: InAppMessagingConfig) => InAppMessagingConfig;
-	getModuleName: () => NotificationsSubCategory;
+	configure: (config: NotificationsConfig) => InAppMessagingConfig;
+	getModuleName: () =>
+		| NotificationsSubCategory
+		| InternalNotificationsSubCategory;
 	getPluggable: (providerName: string) => InAppMessagingProvider;
 	addPluggable: (pluggable: InAppMessagingProvider) => void;
 	removePluggable: (providerName: string) => void;
@@ -48,7 +52,7 @@ export interface InAppMessagingProvider extends NotificationsProvider {
 	getSubCategory(): NotificationsSubCategory;
 
 	// get in-app messages from provider
-	getInAppMessages(): Promise<any>;
+	getInAppMessages(userAgentValue?: string): Promise<any>;
 
 	// filters in-app messages based on event input and provider logic
 	processInAppMessages(

package/src/Notifications.ts

@@ -38,7 +38,7 @@ class NotificationsClass {
 		logger.debug('configure Notifications', config);
 
 		// Configure sub-categories
-		this.inAppMessaging.configure(this.config.InAppMessaging);
+		this.inAppMessaging.configure({ Notifications: this.config });
 
 		if (this.config.Push) {
 			try {

package/src/common/AWSPinpointProviderCommon/index.ts

@@ -77,12 +77,16 @@ export default abstract class AWSPinpointProviderCommon
 		return this.config;
 	}
 
-	identifyUser = async (userId: string, userInfo: UserInfo): Promise<void> => {
+	identifyUser = async (
+		userId: string,
+		userInfo: UserInfo,
+		userAgentValue?: string
+	): Promise<void> => {
 		if (!this.initialized) {
 			await this.init();
 		}
 		try {
-			await this.updateEndpoint(userId, userInfo);
+			await this.updateEndpoint(userId, userInfo, userAgentValue);
 		} catch (err) {
 			this.logger.error('Error identifying user', err);
 			throw err;
@@ -161,7 +165,8 @@ export default abstract class AWSPinpointProviderCommon
 
 	protected updateEndpoint = async (
 		userId: string = null,
-		userInfo: AWSPinpointUserInfo = null
+		userInfo: AWSPinpointUserInfo = null,
+		userAgentValue?: string
 	): Promise<void> => {
 		const credentials = await this.getCredentials();
 		// Shallow compare to determine if credentials stored here are outdated
@@ -230,7 +235,11 @@ export default abstract class AWSPinpointProviderCommon
 			};
 			this.logger.debug('updating endpoint');
 			await updateEndpoint(
-				{ credentials, region, userAgentValue: this.getUserAgentValue() },
+				{
+					credentials,
+					region,
+					userAgentValue: userAgentValue || this.getUserAgentValue(),
+				},
 				input
 			);
 			this.endpointInitialized = true;