@aws-amplify/notifications 1.6.6-unstable.7762f1a.0 → 2.0.0

package/src/InAppMessaging/InAppMessaging.ts

@@ -1,321 +0,0 @@
-// 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;
-	};
-
-	/**
-	 * Get the name of this module
-	 * @returns {string} name of this module
-	 */
-	getModuleName(): NotificationsSubCategory {
-		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)
-			);
-		}
-	};
-
-	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];
-	};
-}

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

@@ -1,323 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-import {
-	getInAppMessages,
-	GetInAppMessagesInput,
-	GetInAppMessagesOutput,
-	InAppMessageCampaign as PinpointInAppMessage,
-} from '@aws-amplify/core/internals/aws-clients/pinpoint';
-
-import { addEventListener, AWSPinpointProviderCommon } from '../../../common';
-import SessionTracker, {
-	SessionState,
-	SessionStateChangeHandler,
-} from '../../SessionTracker';
-import {
-	InAppMessage,
-	InAppMessageInteractionEvent,
-	InAppMessagingEvent,
-	InAppMessagingProvider,
-	NotificationsSubCategory,
-} from '../../types';
-import {
-	AWSPinpointMessageEvent,
-	DailyInAppMessageCounter,
-	InAppMessageCountMap,
-	InAppMessageCounts,
-} from './types';
-import {
-	clearMemo,
-	dispatchInAppMessagingEvent,
-	extractContent,
-	extractMetadata,
-	getStartOfDay,
-	interpretLayout,
-	isBeforeEndDate,
-	logger,
-	matchesAttributes,
-	matchesEventType,
-	matchesMetrics,
-	recordAnalyticsEvent,
-} from './utils';
-
-const MESSAGE_DAILY_COUNT_KEY = 'pinpointProvider_inAppMessages_dailyCount';
-const MESSAGE_TOTAL_COUNT_KEY = 'pinpointProvider_inAppMessages_totalCount';
-
-export default class AWSPinpointProvider
-	extends AWSPinpointProviderCommon
-	implements InAppMessagingProvider
-{
-	static subCategory: NotificationsSubCategory = 'InAppMessaging';
-
-	private configured = false;
-	private sessionMessageCountMap: InAppMessageCountMap;
-	private sessionTracker: SessionTracker;
-
-	constructor() {
-		super(logger);
-		this.sessionMessageCountMap = {};
-	}
-
-	/**
-	 * get the sub-category of the plugin
-	 */
-	getSubCategory() {
-		return AWSPinpointProvider.subCategory;
-	}
-
-	configure = (config = {}): Record<string, any> => {
-		this.config = {
-			...super.configure(config),
-			endpointInfo: { channelType: 'IN_APP' },
-		};
-
-		// some configuration steps should not be re-run even if provider is re-configured for some reason
-		if (!this.configured) {
-			this.sessionTracker = new SessionTracker(this.sessionStateChangeHandler);
-			this.sessionTracker.start();
-			// wire up default Pinpoint message event handling
-			addEventListener(
-				InAppMessageInteractionEvent.MESSAGE_DISPLAYED,
-				(message: InAppMessage) => {
-					this.recordMessageEvent(
-						message,
-						AWSPinpointMessageEvent.MESSAGE_DISPLAYED
-					);
-				}
-			);
-			addEventListener(
-				InAppMessageInteractionEvent.MESSAGE_DISMISSED,
-				(message: InAppMessage) => {
-					this.recordMessageEvent(
-						message,
-						AWSPinpointMessageEvent.MESSAGE_DISMISSED
-					);
-				}
-			);
-			addEventListener(
-				InAppMessageInteractionEvent.MESSAGE_ACTION_TAKEN,
-				(message: InAppMessage) => {
-					this.recordMessageEvent(
-						message,
-						AWSPinpointMessageEvent.MESSAGE_ACTION_TAKEN
-					);
-				}
-			);
-		}
-
-		this.configured = true;
-		dispatchInAppMessagingEvent('pinpointProvider_configured', null);
-		return this.config;
-	};
-
-	getInAppMessages = async () => {
-		if (!this.initialized) {
-			await this.init();
-		}
-		// There is no way to granuarly reconcile the filter memoization as the keys are composited from a message id and
-		// event properties thus opting to just clear them out when getting messages rather than leave potentially
-		// obsolete entries that will no longer serve any purpose.
-		clearMemo();
-		try {
-			await this.updateEndpoint();
-			// The credentials exists assuming `updateEndpoint()` is always called before.
-			const { appId, credentials, endpointId, region } = this.config;
-			const input: GetInAppMessagesInput = {
-				ApplicationId: appId,
-				EndpointId: endpointId,
-			};
-			this.logger.debug('getting in-app messages');
-			const response: GetInAppMessagesOutput = await getInAppMessages(
-				{ credentials, region },
-				input
-			);
-			const { InAppMessageCampaigns: messages } =
-				response.InAppMessagesResponse;
-			dispatchInAppMessagingEvent('getInAppMessages', messages);
-			return messages;
-		} catch (err) {
-			this.logger.error('Error getting in-app messages', err);
-			throw err;
-		}
-	};
-
-	processInAppMessages = async (
-		messages: any[],
-		event: InAppMessagingEvent
-	): Promise<InAppMessage[]> => {
-		if (!this.initialized) {
-			await this.init();
-		}
-		let highestPrioritySeen;
-		return this.normalizeMessages(
-			(messages as PinpointInAppMessage[]).reduce((acc, message) => {
-				const messageQualifies =
-					matchesEventType(message, event) &&
-					matchesAttributes(message, event) &&
-					matchesMetrics(message, event) &&
-					isBeforeEndDate(message) &&
-					this.isBelowCap(message);
-				// filter all qualifying messages returning only those that are of (relative) highest priority
-				if (messageQualifies) {
-					// have not yet encountered message with priority
-					if (!highestPrioritySeen) {
-						// this message has priority, so reset the accumulator with this message only
-						if (message.Priority) {
-							highestPrioritySeen = message.Priority;
-							return [message];
-						} else {
-							// this message also has no priority, so just add this message to accumulator
-							acc.push(message);
-						}
-						// have previously encountered message with priority, so only messages with priority matter now
-					} else if (message.Priority) {
-						// this message has higher priority (lower number), so reset the accumulator with this message only
-						if (message.Priority < highestPrioritySeen) {
-							highestPrioritySeen = message.Priority;
-							return [message];
-							// this message has the same priority, so just add this message to accumulator
-						} else if (message.Priority === highestPrioritySeen) {
-							acc.push(message);
-						}
-					}
-				}
-				return acc;
-			}, [])
-		);
-	};
-
-	private sessionStateChangeHandler: SessionStateChangeHandler = (
-		state: SessionState
-	) => {
-		if (state === 'started') {
-			// reset all session counts
-			this.sessionMessageCountMap = {};
-		}
-	};
-
-	private isBelowCap = ({
-		CampaignId,
-		SessionCap,
-		DailyCap,
-		TotalCap,
-	}: PinpointInAppMessage): boolean => {
-		const { sessionCount, dailyCount, totalCount } =
-			this.getMessageCounts(CampaignId);
-		return (
-			(!SessionCap || sessionCount < SessionCap) &&
-			(!DailyCap || dailyCount < DailyCap) &&
-			(!TotalCap || totalCount < TotalCap)
-		);
-	};
-
-	// Use the current session count in memory or initialize as empty count
-	private getSessionCount = (messageId: string): number =>
-		this.sessionMessageCountMap[messageId] || 0;
-
-	private getDailyCount = (): number => {
-		const { storage } = this.config;
-		const today = getStartOfDay();
-		const item = storage.getItem(MESSAGE_DAILY_COUNT_KEY);
-		// Parse stored count or initialize as empty count
-		const counter: DailyInAppMessageCounter = item
-			? JSON.parse(item)
-			: { count: 0, lastCountTimestamp: today };
-		// If the stored counter timestamp is today, use it as the count, otherwise reset to 0
-		return counter.lastCountTimestamp === today ? counter.count : 0;
-	};
-
-	private getTotalCountMap = (): InAppMessageCountMap => {
-		const { storage } = this.config;
-		const item = storage.getItem(MESSAGE_TOTAL_COUNT_KEY);
-		// Parse stored count map or initialize as empty
-		return item ? JSON.parse(item) : {};
-	};
-
-	private getTotalCount = (messageId: string): number => {
-		const countMap = this.getTotalCountMap();
-		// Return stored count or initialize as empty count
-		return countMap[messageId] || 0;
-	};
-
-	private getMessageCounts = (messageId: string): InAppMessageCounts => {
-		try {
-			return {
-				sessionCount: this.getSessionCount(messageId),
-				dailyCount: this.getDailyCount(),
-				totalCount: this.getTotalCount(messageId),
-			};
-		} catch (err) {
-			this.logger.error('Failed to get message counts from storage', err);
-		}
-	};
-
-	private setSessionCount = (messageId: string, count: number): void => {
-		this.sessionMessageCountMap[messageId] = count;
-	};
-
-	private setDailyCount = (count: number): void => {
-		const { storage } = this.config;
-		const dailyCount: DailyInAppMessageCounter = {
-			count,
-			lastCountTimestamp: getStartOfDay(),
-		};
-		try {
-			storage.setItem(MESSAGE_DAILY_COUNT_KEY, JSON.stringify(dailyCount));
-		} catch (err) {
-			this.logger.error('Failed to save daily message count to storage', err);
-		}
-	};
-
-	private setTotalCountMap = (countMap: InAppMessageCountMap): void => {
-		const { storage } = this.config;
-		try {
-			storage.setItem(MESSAGE_TOTAL_COUNT_KEY, JSON.stringify(countMap));
-		} catch (err) {
-			this.logger.error('Failed to save total count to storage', err);
-		}
-	};
-
-	private setTotalCount = (messageId: string, count: number): void => {
-		const updatedMap = {
-			...this.getTotalCountMap(),
-			[messageId]: count,
-		};
-		this.setTotalCountMap(updatedMap);
-	};
-
-	private incrementCounts = async (messageId: string): Promise<void> => {
-		const { sessionCount, dailyCount, totalCount } =
-			this.getMessageCounts(messageId);
-		this.setSessionCount(messageId, sessionCount + 1);
-		this.setDailyCount(dailyCount + 1);
-		this.setTotalCount(messageId, totalCount + 1);
-	};
-
-	private normalizeMessages = (
-		messages: PinpointInAppMessage[]
-	): InAppMessage[] => {
-		return messages.map(message => {
-			const { CampaignId, InAppMessage } = message;
-			return {
-				id: CampaignId,
-				content: extractContent(message),
-				layout: interpretLayout(InAppMessage.Layout),
-				metadata: extractMetadata(message),
-			};
-		});
-	};
-
-	private recordMessageEvent = async (
-		message: InAppMessage,
-		event: AWSPinpointMessageEvent
-	): Promise<void> => {
-		if (!this.initialized) {
-			await this.init();
-		}
-		recordAnalyticsEvent(event, message);
-		if (event === AWSPinpointMessageEvent.MESSAGE_DISPLAYED) {
-			await this.incrementCounts(message.id);
-		}
-	};
-}

package/src/InAppMessaging/SessionTracker/SessionTracker.native.ts

@@ -1,60 +0,0 @@
-// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
-// SPDX-License-Identifier: Apache-2.0
-
-import { ConsoleLogger as Logger } from '@aws-amplify/core';
-import { AppState, AppStateStatus } from 'react-native';
-import noop from 'lodash/noop';
-import {
-	SessionState,
-	SessionStateChangeHandler,
-	SessionTrackerInterface,
-} from './types';
-
-const isActive = appState => appState === 'active';
-const isInactive = appState =>
-	appState === 'inactive' || appState === 'background';
-
-const logger = new Logger('InAppMessagingSessionTracker');
-
-export default class SessionTracker implements SessionTrackerInterface {
-	private currentAppState: AppStateStatus;
-	private sessionStateChangeHandler: SessionStateChangeHandler;
-
-	constructor(sessionStateChangeHandler: SessionStateChangeHandler = noop) {
-		this.currentAppState = 'active';
-		this.sessionStateChangeHandler = sessionStateChangeHandler;
-	}
-
-	start = (): SessionState => {
-		AppState.addEventListener('change', this.appStateChangeHandler);
-		return this.getSessionState();
-	};
-
-	end = (): SessionState => {
-		AppState.removeEventListener('change', this.appStateChangeHandler);
-		return this.getSessionState();
-	};
-
-	private getSessionState = (): SessionState => {
-		if (isActive(this.currentAppState)) {
-			return 'started';
-		}
-		// consider any other app state as session ended
-		return 'ended';
-	};
-
-	private appStateChangeHandler = nextAppState => {
-		// if going from active to inactive
-		if (isActive(this.currentAppState) && isInactive(nextAppState)) {
-			logger.debug('App has gone to the background');
-			this.sessionStateChangeHandler('ended');
-		}
-		// if going from inactive to active
-		if (isInactive(this.currentAppState) && isActive(nextAppState)) {
-			logger.debug('App has come to the foreground');
-			this.sessionStateChangeHandler('started');
-		}
-		// otherwise do nothing but always update current state
-		this.currentAppState = nextAppState;
-	};
-}