@aws-amplify/notifications 1.6.4-user-agent-backup.c6dfb36.0 → 1.6.4

package/lib-esm/types.d.ts

@@ -7,7 +7,7 @@ export interface NotificationsProvider {
     getCategory(): NotificationsCategory;
     getSubCategory(): NotificationsSubCategory;
     getProviderName(): string;
-    identifyUser(userId: string, userInfo: UserInfo, userAgentValue?: string): Promise<void>;
+    identifyUser(userId: string, userInfo: UserInfo): Promise<void>;
 }
 export interface NotificationsConfig {
     Notifications?: {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@aws-amplify/notifications",
-	"version": "1.6.4-user-agent-backup.c6dfb36.0+c6dfb36",
+	"version": "1.6.4",
 	"description": "Notifications category of aws-amplify",
 	"main": "./lib/index.js",
 	"module": "./lib-esm/index.js",
@@ -46,13 +46,12 @@
 	"files": [
 		"lib",
 		"lib-esm",
-		"src",
-		"internals"
+		"src"
 	],
 	"dependencies": {
-		"@aws-amplify/cache": "5.1.10-user-agent-backup.c6dfb36.0+c6dfb36",
-		"@aws-amplify/core": "5.8.4-user-agent-backup.c6dfb36.0+c6dfb36",
-		"@aws-amplify/rtn-push-notification": "1.1.6-user-agent-backup.c6dfb36.0+c6dfb36",
+		"@aws-amplify/cache": "5.1.10",
+		"@aws-amplify/core": "5.8.4",
+		"@aws-amplify/rtn-push-notification": "1.1.6",
 		"lodash": "^4.17.21",
 		"uuid": "^3.2.1"
 	},
@@ -66,14 +65,14 @@
 			"name": "Notifications (top-level class)",
 			"path": "./lib-esm/index.js",
 			"import": "{ Amplify, Notifications }",
-			"limit": "30.67 kB"
+			"limit": "29.95 kB"
 		},
 		{
 			"name": "Notifications (with Analytics)",
 			"path": "./lib-esm/index.js",
 			"import": "{ Amplify, Notifications, Analytics }",
-			"limit": "30.68 kB"
+			"limit": "29.95 kB"
 		}
 	],
-	"gitHead": "c6dfb36977fa8dee00a9200569b69f41a4ac8c2d"
+	"gitHead": "f0df916a96cdd4b4f2ebbf45c3d3add6d5f16e37"
 }

package/src/InAppMessaging/InAppMessaging.ts

@@ -1,14 +1,78 @@
 // 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 { InAppMessagingInterface, NotificationsSubCategory } from './types';
-import { InternalInAppMessagingClass } from '../internals/InternalInAppMessaging';
+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;
+	};
 
-export default class InAppMessaging
-	extends InternalInAppMessagingClass
-	implements InAppMessagingInterface
-{
 	/**
 	 * Get the name of this module
 	 * @returns {string} name of this module
@@ -17,13 +81,241 @@ export default class InAppMessaging
 		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[]> => super.syncMessages();
+	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)
+			);
+		}
+	};
 
 	identifyUser = (userId: string, userInfo: UserInfo): Promise<void[]> =>
-		super.identifyUser(userId, userInfo);
+		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];
+	};
 }

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

@@ -111,7 +111,7 @@ export default class AWSPinpointProvider
 		return this.config;
 	};
 
-	getInAppMessages = async (userAgentValue?: string) => {
+	getInAppMessages = async () => {
 		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, userAgentValue },
+				{ credentials, region },
 				input
 			);
 			const { InAppMessageCampaigns: messages } =

package/src/InAppMessaging/types.ts

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

package/src/common/AWSPinpointProviderCommon/index.ts

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

package/src/types.ts

@@ -22,11 +22,7 @@ export interface NotificationsProvider {
 	getProviderName(): string;
 
 	// identify the current user with the provider
-	identifyUser(
-		userId: string,
-		userInfo: UserInfo,
-		userAgentValue?: string
-	): Promise<void>;
+	identifyUser(userId: string, userInfo: UserInfo): Promise<void>;
 }
 
 export interface NotificationsConfig {

package/internals/package.json

@@ -1,8 +0,0 @@
-{
-	"name": "@aws-amplify/notifications/internals",
-	"types": "../lib-esm/internals/index.d.ts",
-	"main": "../lib/internals/index.js",
-	"module": "../lib-esm/internals/index.js",
-	"react-native": "../lib-esm/internals/index.js",
-	"sideEffects": false
-}

package/lib/internals/InternalInAppMessaging.d.ts

@@ -1,59 +0,0 @@
-import { CustomUserAgentDetails } from '@aws-amplify/core';
-import { EventListener } from '../common';
-import { NotificationsConfig, UserInfo } from '../types';
-import { InAppMessage, InAppMessageInteractionEvent, InAppMessagingInterface, InAppMessagingConfig, InAppMessageConflictHandler, InAppMessagingEvent, InAppMessagingProvider, OnMessageInteractionEventHandler, InternalNotificationsSubCategory, NotificationsSubCategory } from '../InAppMessaging/types';
-export declare class InternalInAppMessagingClass implements InAppMessagingInterface {
-    private config;
-    private conflictHandler;
-    private listeningForAnalyticEvents;
-    private pluggables;
-    private storageSynced;
-    constructor();
-    /**
-     * Configure InAppMessaging
-     * @param {Object} config - InAppMessaging configuration object
-     */
-    configure({ Notifications: notificationsConfig, }?: NotificationsConfig): InAppMessagingConfig;
-    /**
-     * Get the name of this module
-     * @returns {string} name of this module
-     */
-    getModuleName(): NotificationsSubCategory | InternalNotificationsSubCategory;
-    /**
-     * Get a plugin from added plugins
-     * @param {string} providerName - the name of the plugin to get
-     */
-    getPluggable: (providerName: string) => InAppMessagingProvider;
-    /**
-     * Add plugin into InAppMessaging
-     * @param {InAppMessagingProvider} pluggable - an instance of the plugin
-     */
-    addPluggable: (pluggable: InAppMessagingProvider) => void;
-    /**
-     * Remove a plugin from added plugins
-     * @param {string} providerName - the name of the plugin to remove
-     */
-    removePluggable: (providerName: string) => void;
-    /**
-     * Get the map resources that are currently available through the provider
-     * @param {CustomUserAgentDetails} customUserAgentDetails optional parameter to send user agent details
-     * @returns - Array of available map resources
-     */
-    syncMessages(customUserAgentDetails?: CustomUserAgentDetails): Promise<void[]>;
-    clearMessages(): Promise<void[]>;
-    dispatchEvent(event: InAppMessagingEvent): Promise<void>;
-    identifyUser(userId: string, userInfo: UserInfo, customUserAgentDetails?: CustomUserAgentDetails): Promise<void[]>;
-    onMessageReceived: (handler: OnMessageInteractionEventHandler) => EventListener<OnMessageInteractionEventHandler>;
-    onMessageDisplayed: (handler: OnMessageInteractionEventHandler) => EventListener<OnMessageInteractionEventHandler>;
-    onMessageDismissed: (handler: OnMessageInteractionEventHandler) => EventListener<OnMessageInteractionEventHandler>;
-    onMessageActionTaken: (handler: OnMessageInteractionEventHandler) => EventListener<OnMessageInteractionEventHandler>;
-    notifyMessageInteraction: (message: InAppMessage, type: InAppMessageInteractionEvent) => void;
-    setConflictHandler: (handler: InAppMessageConflictHandler) => void;
-    private analyticsListener;
-    private syncStorage;
-    private getMessages;
-    private setMessages;
-    private removeMessages;
-    private defaultConflictHandler;
-}
-export declare const InternalInAppMessaging: InternalInAppMessagingClass;