@aws-amplify/notifications 0.0.2-unstable.7462

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

@@ -0,0 +1,329 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Amplify, ConsoleLogger, Hub } from '@aws-amplify/core';
+import {
+	InAppMessageCampaign as PinpointInAppMessage,
+	Layout as PinpointInAppMessageLayout,
+} from '@aws-sdk/client-pinpoint';
+import isEmpty from 'lodash/isEmpty';
+import {
+	InAppMessage,
+	InAppMessageAction,
+	InAppMessageContent,
+	InAppMessageLayout,
+	InAppMessageTextAlign,
+	InAppMessagingEvent,
+} from '../../types';
+import { AWSPinpointMessageEvent, MetricsComparator } from './types';
+
+const AMPLIFY_SYMBOL = (
+	typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
+		? Symbol.for('amplify_default')
+		: '@@amplify_default'
+) as Symbol;
+const DELIVERY_TYPE = 'IN_APP_MESSAGE';
+
+let eventNameMemo = {};
+let eventAttributesMemo = {};
+let eventMetricsMemo = {};
+
+export const logger = new ConsoleLogger('AWSPinpointProvider');
+
+export const dispatchInAppMessagingEvent = (
+	event: string,
+	data: any,
+	message?: string
+) => {
+	Hub.dispatch(
+		'inAppMessaging',
+		{ event, data, message },
+		'InAppMessaging',
+		AMPLIFY_SYMBOL
+	);
+};
+
+export const recordAnalyticsEvent = (
+	event: AWSPinpointMessageEvent,
+	message: InAppMessage
+) => {
+	if (!message) {
+		logger.debug(
+			'Unable to record analytics event - no InAppMessage was received'
+		);
+		return;
+	}
+	if (Amplify.Analytics && typeof Amplify.Analytics.record === 'function') {
+		const { id, metadata } = message;
+		Amplify.Analytics.record({
+			name: event,
+			attributes: {
+				campaign_id: id,
+				delivery_type: DELIVERY_TYPE,
+				treatment_id: metadata?.treatmentId,
+			},
+		});
+	} else {
+		logger.debug('Analytics module is not registered into Amplify');
+	}
+};
+
+export const getStartOfDay = (): string => {
+	const now = new Date();
+	now.setHours(0, 0, 0, 0);
+	return now.toISOString();
+};
+
+export const matchesEventType = (
+	{ CampaignId, Schedule }: PinpointInAppMessage,
+	{ name: eventType }: InAppMessagingEvent
+) => {
+	const { EventType } = Schedule?.EventFilter?.Dimensions;
+	const memoKey = `${CampaignId}:${eventType}`;
+	if (!eventNameMemo.hasOwnProperty(memoKey)) {
+		eventNameMemo[memoKey] = !!EventType?.Values.includes(eventType);
+	}
+	return eventNameMemo[memoKey];
+};
+
+export const matchesAttributes = (
+	{ CampaignId, Schedule }: PinpointInAppMessage,
+	{ attributes }: InAppMessagingEvent
+): boolean => {
+	const { Attributes } = Schedule?.EventFilter?.Dimensions;
+	if (isEmpty(Attributes)) {
+		// if message does not have attributes defined it does not matter what attributes are on the event
+		return true;
+	}
+	if (isEmpty(attributes)) {
+		// if message does have attributes but the event does not then it always fails the check
+		return false;
+	}
+	const memoKey = `${CampaignId}:${JSON.stringify(attributes)}`;
+	if (!eventAttributesMemo.hasOwnProperty(memoKey)) {
+		eventAttributesMemo[memoKey] = Object.entries(Attributes).every(
+			([key, { Values }]) => Values.includes(attributes[key])
+		);
+	}
+	return eventAttributesMemo[memoKey];
+};
+
+export const matchesMetrics = (
+	{ CampaignId, Schedule }: PinpointInAppMessage,
+	{ metrics }: InAppMessagingEvent
+): boolean => {
+	const { Metrics } = Schedule?.EventFilter?.Dimensions;
+	if (isEmpty(Metrics)) {
+		// if message does not have metrics defined it does not matter what metrics are on the event
+		return true;
+	}
+	if (isEmpty(metrics)) {
+		// if message does have metrics but the event does not then it always fails the check
+		return false;
+	}
+	const memoKey = `${CampaignId}:${JSON.stringify(metrics)}`;
+	if (!eventMetricsMemo.hasOwnProperty(memoKey)) {
+		eventMetricsMemo[memoKey] = Object.entries(Metrics).every(
+			([key, { ComparisonOperator, Value }]) => {
+				const compare = getComparator(ComparisonOperator);
+				// if there is some unknown comparison operator, treat as a comparison failure
+				return compare ? compare(Value, metrics[key]) : false;
+			}
+		);
+	}
+	return eventMetricsMemo[memoKey];
+};
+
+export const getComparator = (operator: string): MetricsComparator => {
+	switch (operator) {
+		case 'EQUAL':
+			return (metricsVal, eventVal) => metricsVal === eventVal;
+		case 'GREATER_THAN':
+			return (metricsVal, eventVal) => metricsVal < eventVal;
+		case 'GREATER_THAN_OR_EQUAL':
+			return (metricsVal, eventVal) => metricsVal <= eventVal;
+		case 'LESS_THAN':
+			return (metricsVal, eventVal) => metricsVal > eventVal;
+		case 'LESS_THAN_OR_EQUAL':
+			return (metricsVal, eventVal) => metricsVal >= eventVal;
+		default:
+			return null;
+	}
+};
+
+export const isBeforeEndDate = ({
+	Schedule,
+}: PinpointInAppMessage): boolean => {
+	if (!Schedule?.EndDate) {
+		return true;
+	}
+	return new Date() < new Date(Schedule.EndDate);
+};
+
+export const isQuietTime = (message: PinpointInAppMessage): boolean => {
+	const { Schedule } = message;
+	if (!Schedule?.QuietTime) {
+		return false;
+	}
+
+	const pattern = /^[0-2]\d:[0-5]\d$/; // basic sanity check, not a fully featured HH:MM validation
+	const { Start, End } = Schedule.QuietTime;
+	if (
+		!Start ||
+		!End ||
+		Start === End ||
+		!pattern.test(Start) ||
+		!pattern.test(End)
+	) {
+		return false;
+	}
+
+	const now = new Date();
+	const start = new Date(now);
+	const end = new Date(now);
+	const [startHours, startMinutes] = Start.split(':');
+	const [endHours, endMinutes] = End.split(':');
+
+	start.setHours(
+		Number.parseInt(startHours, 10),
+		Number.parseInt(startMinutes, 10),
+		0,
+		0
+	);
+	end.setHours(
+		Number.parseInt(endHours, 10),
+		Number.parseInt(endMinutes, 10),
+		0,
+		0
+	);
+
+	// if quiet time includes midnight, bump the end time to the next day
+	if (start > end) {
+		end.setDate(end.getDate() + 1);
+	}
+
+	const isQuietTime = now >= start && now <= end;
+	if (isQuietTime) {
+		logger.debug('message filtered due to quiet time', message);
+	}
+	return isQuietTime;
+};
+
+export const clearMemo = () => {
+	eventNameMemo = {};
+	eventAttributesMemo = {};
+	eventMetricsMemo = {};
+};
+
+// in the pinpoint console when a message is created with a Modal or Full Screen layout,
+// it is assigned a layout value of MOBILE_FEED or OVERLAYS respectively in the message payload.
+// In the future, Pinpoint will be updating the layout values in the aforementioned scenario
+// to MODAL and FULL_SCREEN.
+//
+// This utility acts as a safeguard to ensure that:
+// - 1. the usage of MOBILE_FEED and OVERLAYS as values for message layouts are not leaked
+//      outside the Pinpoint provider
+// - 2. Amplify correctly handles the legacy layout values from Pinpoint after they are updated
+export const interpretLayout = (
+	layout: PinpointInAppMessage['InAppMessage']['Layout']
+): InAppMessageLayout => {
+	if (layout === PinpointInAppMessageLayout.MOBILE_FEED) {
+		return 'MODAL';
+	}
+
+	if (layout === PinpointInAppMessageLayout.OVERLAYS) {
+		return 'FULL_SCREEN';
+	}
+
+	// cast as PinpointInAppMessage['InAppMessage']['Layout'] allows `string` as a value
+	return layout as InAppMessageLayout;
+};
+
+export const extractContent = ({
+	InAppMessage: message,
+}: PinpointInAppMessage): InAppMessageContent[] => {
+	return (
+		message?.Content?.map(content => {
+			const {
+				BackgroundColor,
+				BodyConfig,
+				HeaderConfig,
+				ImageUrl,
+				PrimaryBtn,
+				SecondaryBtn,
+			} = content;
+			const defaultPrimaryButton = PrimaryBtn?.DefaultConfig;
+			const defaultSecondaryButton = SecondaryBtn?.DefaultConfig;
+			const extractedContent: InAppMessageContent = {};
+			if (BackgroundColor) {
+				extractedContent.container = {
+					style: {
+						backgroundColor: BackgroundColor,
+					},
+				};
+			}
+			if (HeaderConfig) {
+				extractedContent.header = {
+					content: HeaderConfig.Header,
+					style: {
+						color: HeaderConfig.TextColor,
+						textAlign:
+							HeaderConfig.Alignment.toLowerCase() as InAppMessageTextAlign,
+					},
+				};
+			}
+			if (BodyConfig) {
+				extractedContent.body = {
+					content: BodyConfig.Body,
+					style: {
+						color: BodyConfig.TextColor,
+						textAlign:
+							BodyConfig.Alignment.toLowerCase() as InAppMessageTextAlign,
+					},
+				};
+			}
+			if (ImageUrl) {
+				extractedContent.image = {
+					src: ImageUrl,
+				};
+			}
+			if (defaultPrimaryButton) {
+				extractedContent.primaryButton = {
+					title: defaultPrimaryButton.Text,
+					action: defaultPrimaryButton.ButtonAction as InAppMessageAction,
+					url: defaultPrimaryButton.Link,
+					style: {
+						backgroundColor: defaultPrimaryButton.BackgroundColor,
+						borderRadius: defaultPrimaryButton.BorderRadius,
+						color: defaultPrimaryButton.TextColor,
+					},
+				};
+			}
+			if (defaultSecondaryButton) {
+				extractedContent.secondaryButton = {
+					title: defaultSecondaryButton.Text,
+					action: defaultSecondaryButton.ButtonAction as InAppMessageAction,
+					url: defaultSecondaryButton.Link,
+					style: {
+						backgroundColor: defaultSecondaryButton.BackgroundColor,
+						borderRadius: defaultSecondaryButton.BorderRadius,
+						color: defaultSecondaryButton.TextColor,
+					},
+				};
+			}
+			return extractedContent;
+		}) ?? []
+	);
+};
+
+export const extractMetadata = ({
+	InAppMessage,
+	Priority,
+	Schedule,
+	TreatmentId,
+}: PinpointInAppMessage): InAppMessage['metadata'] => ({
+	customData: InAppMessage?.CustomConfig,
+	endDate: Schedule?.EndDate,
+	priority: Priority,
+	treatmentId: TreatmentId,
+});

package/src/InAppMessaging/Providers/index.ts

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as AWSPinpointProvider } from './AWSPinpointProvider';

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

@@ -0,0 +1,60 @@
+// 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;
+	};
+}

package/src/InAppMessaging/SessionTracker/SessionTracker.ts

@@ -0,0 +1,78 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { browserOrNode, ConsoleLogger as Logger } from '@aws-amplify/core';
+import noop from 'lodash/noop';
+import {
+	SessionState,
+	SessionStateChangeHandler,
+	SessionTrackerInterface,
+} from './types';
+
+// Per https://developer.mozilla.org/en-US/docs/Web/API/Page_Visibility_API
+let hidden: string;
+let visibilityChange: string;
+const { isBrowser } = browserOrNode();
+
+if (isBrowser && document) {
+	if (typeof document.hidden !== 'undefined') {
+		hidden = 'hidden';
+		visibilityChange = 'visibilitychange';
+	} else if (typeof document['msHidden'] !== 'undefined') {
+		hidden = 'msHidden';
+		visibilityChange = 'msvisibilitychange';
+	} else if (typeof document['webkitHidden'] !== 'undefined') {
+		hidden = 'webkitHidden';
+		visibilityChange = 'webkitvisibilitychange';
+	}
+}
+
+const logger = new Logger('InAppMessagingSessionTracker');
+
+export default class SessionTracker implements SessionTrackerInterface {
+	private sessionStateChangeHandler: SessionStateChangeHandler;
+
+	constructor(sessionStateChangeHandler: SessionStateChangeHandler = noop) {
+		this.sessionStateChangeHandler = sessionStateChangeHandler;
+	}
+
+	start = (): SessionState => {
+		if (isBrowser) {
+			document?.addEventListener(
+				visibilityChange,
+				this.visibilityChangeHandler
+			);
+		}
+		return this.getSessionState();
+	};
+
+	end = (): SessionState => {
+		if (isBrowser) {
+			document?.removeEventListener(
+				visibilityChange,
+				this.visibilityChangeHandler
+			);
+		}
+		return this.getSessionState();
+	};
+
+	private getSessionState = (): SessionState => {
+		if (isBrowser && document && !document[hidden]) {
+			return 'started';
+		}
+		// If, for any reason, document is undefined the session will never start
+		return 'ended';
+	};
+
+	private visibilityChangeHandler = () => {
+		if (!isBrowser || !document) {
+			return;
+		}
+		if (document[hidden]) {
+			logger.debug('App is now hidden');
+			this.sessionStateChangeHandler('ended');
+		} else {
+			logger.debug('App is now visible');
+			this.sessionStateChangeHandler('started');
+		}
+	};
+}

package/src/InAppMessaging/SessionTracker/index.ts

@@ -0,0 +1,6 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { default as SessionTracker } from './SessionTracker';
+export * from './types';
+export default SessionTracker;

package/src/InAppMessaging/SessionTracker/types.ts

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export type SessionState = 'started' | 'ended';
+
+export type SessionStateChangeHandler = (state: SessionState) => void;
+
+export interface SessionTrackerInterface {
+	start: () => SessionState;
+	end: () => SessionState;
+}

package/src/InAppMessaging/eventListeners.ts

@@ -0,0 +1,42 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	InAppMessage,
+	InAppMessageInteractionEvent,
+	OnMessageInteractionEventHandler,
+	OnMessageInteractionEventListener,
+} from './types';
+
+const onMessageActionListeners: Record<
+	InAppMessageInteractionEvent,
+	Set<OnMessageInteractionEventListener>
+> = {
+	[InAppMessageInteractionEvent.MESSAGE_RECEIVED]: new Set(),
+	[InAppMessageInteractionEvent.MESSAGE_DISPLAYED]: new Set(),
+	[InAppMessageInteractionEvent.MESSAGE_DISMISSED]: new Set(),
+	[InAppMessageInteractionEvent.MESSAGE_ACTION_TAKEN]: new Set(),
+};
+
+export const notifyMessageInteractionEventListeners = (
+	message: InAppMessage,
+	event: InAppMessageInteractionEvent
+): void => {
+	onMessageActionListeners[event].forEach(listener => {
+		listener.handleEvent(message);
+	});
+};
+
+export const addMessageInteractionEventListener = (
+	handler: OnMessageInteractionEventHandler,
+	event: InAppMessageInteractionEvent
+): OnMessageInteractionEventListener => {
+	const listener = {
+		handleEvent: handler,
+		remove: () => {
+			onMessageActionListeners[event].delete(listener);
+		},
+	};
+	onMessageActionListeners[event].add(listener);
+	return listener;
+};

package/src/InAppMessaging/index.ts

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { default } from './InAppMessaging';
+export { AWSPinpointProvider } from './Providers';
+export { AWSPinpointUserInfo } from './Providers/AWSPinpointProvider/types';
+export {
+	InAppMessage,
+	InAppMessageAction,
+	InAppMessageButton,
+	InAppMessageContent,
+	InAppMessageImage,
+	InAppMessageInteractionEvent,
+	InAppMessageLayout,
+	InAppMessageStyle,
+	InAppMessageTextAlign,
+	InAppMessagingConfig,
+	InAppMessagingEvent,
+	UserInfo,
+} from './types';

package/src/InAppMessaging/types.ts

@@ -0,0 +1,146 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+import { NotificationsCategory } from '../types';
+import { AWSPinpointProviderConfig } from './Providers/AWSPinpointProvider/types';
+
+export type NotificationsSubcategory = 'InAppMessaging';
+
+export type UserInfo = {
+	attributes?: Record<string, string[]>;
+	demographic?: {
+		appVersion?: string;
+		locale?: string;
+		make?: string;
+		model?: string;
+		modelVersion?: string;
+		platform?: string;
+		platformVersion?: string;
+		timezone?: string;
+	};
+	location?: {
+		city?: string;
+		country?: string;
+		latitude?: number;
+		longitude?: number;
+		postalCode?: string;
+		region?: string;
+	};
+	metrics?: Record<string, number>;
+};
+
+export type InAppMessagingEvent = {
+	name: string;
+	attributes?: Record<string, string>;
+	metrics?: Record<string, number>;
+};
+
+export interface InAppMessagingConfig {
+	listenForAnalyticsEvents?: boolean;
+	AWSPinpoint?: AWSPinpointProviderConfig;
+}
+
+export interface InAppMessagingProvider {
+	// you need to implement these methods
+
+	// configure your provider
+	configure(config: object): object;
+
+	// return category ('Notifications')
+	getCategory(): NotificationsCategory;
+
+	// return sub-category ('InAppMessaging')
+	getSubCategory(): NotificationsSubcategory;
+
+	// return the name of you provider
+	getProviderName(): string;
+
+	// get in-app messages from provider
+	getInAppMessages(): Promise<any>;
+
+	// filters in-app messages based on event input and provider logic
+	processInAppMessages(
+		messages: InAppMessage[],
+		event: InAppMessagingEvent
+	): Promise<InAppMessage[]>;
+
+	// identify the current user with the provider
+	identifyUser(userId: string, userInfo: UserInfo): Promise<void>;
+}
+
+export type InAppMessageLayout =
+	| 'BOTTOM_BANNER'
+	| 'CAROUSEL'
+	| 'FULL_SCREEN'
+	| 'MIDDLE_BANNER'
+	| 'MODAL'
+	| 'TOP_BANNER';
+
+export type InAppMessageAction = 'CLOSE' | 'DEEP_LINK' | 'LINK';
+
+export type InAppMessageTextAlign = 'center' | 'left' | 'right';
+
+interface InAppMessageContainer {
+	style?: InAppMessageStyle;
+}
+
+interface InAppMessageHeader {
+	content: string;
+	style?: InAppMessageStyle;
+}
+
+interface InAppMessageBody {
+	content: string;
+	style?: InAppMessageStyle;
+}
+
+export interface InAppMessageImage {
+	src: string;
+}
+
+export interface InAppMessageButton {
+	title: string;
+	action: InAppMessageAction;
+	url?: string;
+	style?: InAppMessageStyle;
+}
+
+export interface InAppMessageStyle {
+	backgroundColor?: string;
+	borderRadius?: number;
+	color?: string;
+	textAlign?: InAppMessageTextAlign;
+}
+
+export interface InAppMessageContent {
+	container?: InAppMessageContainer;
+	header?: InAppMessageHeader;
+	body?: InAppMessageBody;
+	image?: InAppMessageImage;
+	primaryButton?: InAppMessageButton;
+	secondaryButton?: InAppMessageButton;
+}
+
+export interface InAppMessage {
+	id: string;
+	layout: InAppMessageLayout;
+	content: InAppMessageContent[];
+	metadata?: any;
+}
+
+export type OnMessageInteractionEventHandler = (message: InAppMessage) => any;
+
+export interface OnMessageInteractionEventListener {
+	handleEvent: OnMessageInteractionEventHandler;
+	remove: () => void;
+}
+
+export enum InAppMessageInteractionEvent {
+	MESSAGE_RECEIVED = 'MESSAGE_RECEIVED_EVENT',
+	MESSAGE_DISPLAYED = 'MESSAGE_DISPLAYED_EVENT',
+	MESSAGE_DISMISSED = 'MESSAGE_DISMISSED_EVENT',
+	MESSAGE_ACTION_TAKEN = 'MESSAGE_ACTION_TAKEN_EVENT',
+}
+
+export type InAppMessageConflictHandler = (
+	messages: InAppMessage[]
+) => InAppMessage;