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

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

@@ -2,5 +2,18 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { UpdateEndpointException } from './errors';
-export { IdentifyUserInput } from './inputs';
+export {
+	IdentifyUserInput,
+	DispatchEventInput,
+	SetConflictHandlerInput,
+} from './inputs';
 export { IdentifyUserOptions } from './options';
+export {
+	PinpointMessageEvent,
+	MetricsComparator,
+	InAppMessageCounts,
+	InAppMessageCountMap,
+	DailyInAppMessageCounter,
+	InAppMessageConflictHandler,
+	OnMessageInteractionEventHandler,
+} from './types';

package/src/inAppMessaging/providers/pinpoint/types/inputs.ts

@@ -1,11 +1,58 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
-import { IdentifyUserOptions } from '.';
-import { InAppMessagingIdentifyUserInput } from '../../../types';
+import {
+	IdentifyUserOptions,
+	InAppMessageConflictHandler,
+	OnMessageInteractionEventHandler,
+} from '.';
+import {
+	InAppMessage,
+	InAppMessageInteractionEvent,
+	InAppMessagingEvent,
+	InAppMessagingIdentifyUserInput,
+} from '../../../types';
 
 /**
  * Input type for Pinpoint identifyUser API.
  */
 export type IdentifyUserInput =
 	InAppMessagingIdentifyUserInput<IdentifyUserOptions>;
+
+/**
+ * Input type for Pinpoint dispatchEvent API.
+ */
+export type DispatchEventInput = InAppMessagingEvent;
+
+/**
+ * Input type for Pinpoint SetConflictHandler API.
+ */
+export type SetConflictHandlerInput = InAppMessageConflictHandler;
+
+/**
+ * Input type for OnMessageReceived API.
+ */
+export type OnMessageReceivedInput = OnMessageInteractionEventHandler;
+
+/**
+ * Input type for OnMessageDisplayed API.
+ */
+export type OnMessageDisplayedInput = OnMessageInteractionEventHandler;
+
+/**
+ * Input type for OnMessageDismissed API.
+ */
+export type OnMessageDismissedInput = OnMessageInteractionEventHandler;
+
+/**
+ * Input type for OnMessageActionTaken API.
+ */
+export type OnMessageActionTakenInput = OnMessageInteractionEventHandler;
+
+/**
+ * Input type for NotifyMessageInteraction API.
+ */
+export type NotifyMessageInteractionInput = {
+	message: InAppMessage;
+	type: InAppMessageInteractionEvent;
+};

package/src/inAppMessaging/providers/pinpoint/types/outputs.ts

@@ -0,0 +1,24 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { EventListenerRemover } from '../../../../common';
+
+/**
+ * Output type for OnMessageReceived API.
+ */
+export type OnMessageReceivedOutput = EventListenerRemover;
+
+/**
+ * Output type for OnMessageDisplayed API.
+ */
+export type OnMessageDisplayedOutput = EventListenerRemover;
+
+/**
+ * Output type for OnMessageDismissed API.
+ */
+export type OnMessageDismissedOutput = EventListenerRemover;
+
+/**
+ * Output type for OnMessageActionTaken API.
+ */
+export type OnMessageActionTakenOutput = EventListenerRemover;

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

@@ -1,6 +1,8 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
 
+import { InAppMessage } from '../../../types';
+
 export type InAppMessageCountMap = Record<string, number>;
 
 export type DailyInAppMessageCounter = {
@@ -19,8 +21,14 @@ export type MetricsComparator = (
 	eventVal: number
 ) => boolean;
 
-export enum AWSPinpointMessageEvent {
+export enum PinpointMessageEvent {
 	MESSAGE_DISPLAYED = '_inapp.message_displayed',
 	MESSAGE_DISMISSED = '_inapp.message_dismissed',
 	MESSAGE_ACTION_TAKEN = '_inapp.message_clicked',
 }
+
+export type InAppMessageConflictHandler = (
+	messages: InAppMessage[]
+) => InAppMessage;
+
+export type OnMessageInteractionEventHandler = (message: InAppMessage) => void;

package/src/inAppMessaging/providers/pinpoint/utils/helpers.ts

@@ -0,0 +1,325 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	ConsoleLogger,
+	InAppMessagingAction,
+} from '@aws-amplify/core/internals/utils';
+import type { InAppMessageCampaign as PinpointInAppMessage } from '@aws-amplify/core/internals/aws-clients/pinpoint';
+import isEmpty from 'lodash/isEmpty';
+import {
+	InAppMessage,
+	InAppMessageAction,
+	InAppMessageContent,
+	InAppMessageLayout,
+	InAppMessageTextAlign,
+	InAppMessagingEvent,
+} from '../../../types';
+import { MetricsComparator, PinpointMessageEvent } from '../types';
+import { record as recordCore } from '@aws-amplify/core/internals/providers/pinpoint';
+import { resolveConfig } from './resolveConfig';
+import { resolveCredentials } from './resolveCredentials';
+import { CATEGORY } from './constants';
+import { getInAppMessagingUserAgentString } from './userAgent';
+
+const DELIVERY_TYPE = 'IN_APP_MESSAGE';
+
+let eventNameMemo = {};
+let eventAttributesMemo = {};
+let eventMetricsMemo = {};
+
+export const logger = new ConsoleLogger('InAppMessaging.Pinpoint.Utils');
+
+export const recordAnalyticsEvent = (
+	event: PinpointMessageEvent,
+	message: InAppMessage
+) => {
+	const { appId, region } = resolveConfig();
+
+	const { id, metadata } = message;
+	resolveCredentials()
+		.then(({ credentials, identityId }) => {
+			recordCore({
+				appId,
+				category: CATEGORY,
+				credentials,
+				event: {
+					name: event,
+					attributes: {
+						campaign_id: id,
+						delivery_type: DELIVERY_TYPE,
+						treatment_id: metadata?.treatmentId,
+					},
+				},
+				identityId,
+				region,
+				userAgentValue: getInAppMessagingUserAgentString(
+					InAppMessagingAction.DispatchEvent
+				),
+			});
+		})
+		.catch(e => {
+			// An error occured while fetching credentials or persisting the event to the buffer
+			logger.warn('Failed to record event.', e);
+		});
+};
+
+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 === 'MOBILE_FEED') {
+		return 'MODAL';
+	}
+
+	if (layout === '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/pinpoint/utils/index.ts

@@ -10,3 +10,9 @@ export {
 	CHANNEL_TYPE,
 	STORAGE_KEY_SUFFIX,
 } from './constants';
+
+export {
+	processInAppMessages,
+	sessionStateChangeHandler,
+	incrementMessageCounts,
+} from './messageProcessingHelpers';

package/src/inAppMessaging/providers/pinpoint/utils/messageProcessingHelpers.ts

@@ -0,0 +1,196 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { InAppMessage, InAppMessagingEvent } from '../../../types';
+import {
+	InAppMessageCounts,
+	InAppMessageCountMap,
+	DailyInAppMessageCounter,
+} from '../types';
+import {
+	extractContent,
+	extractMetadata,
+	interpretLayout,
+	isBeforeEndDate,
+	matchesAttributes,
+	matchesEventType,
+	matchesMetrics,
+} from './helpers';
+import type { InAppMessageCampaign as PinpointInAppMessage } from '@aws-amplify/core/internals/aws-clients/pinpoint';
+import { ConsoleLogger } from '@aws-amplify/core/internals/utils';
+import { defaultStorage } from '@aws-amplify/core';
+import { SessionState } from '../../../sessionTracker';
+
+const MESSAGE_DAILY_COUNT_KEY = 'pinpointProvider_inAppMessages_dailyCount';
+const MESSAGE_TOTAL_COUNT_KEY = 'pinpointProvider_inAppMessages_totalCount';
+const logger = new ConsoleLogger('InAppMessaging.processInAppMessages');
+
+let sessionMessageCountMap: InAppMessageCountMap = {};
+
+export async function processInAppMessages(
+	messages: PinpointInAppMessage[],
+	event: InAppMessagingEvent
+): Promise<InAppMessage[]> {
+	let highestPrioritySeen: number;
+	let acc: PinpointInAppMessage[] = [];
+	for (let index = 0; index < messages.length; index++) {
+		const message = messages[index];
+		const messageQualifies =
+			matchesEventType(message, event) &&
+			matchesAttributes(message, event) &&
+			matchesMetrics(message, event) &&
+			isBeforeEndDate(message) &&
+			(await 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;
+					acc = [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;
+					acc = [message];
+					// this message has the same priority, so just add this message to accumulator
+				} else if (message.Priority === highestPrioritySeen) {
+					acc.push(message);
+				}
+			}
+		}
+	}
+	return normalizeMessages(acc);
+}
+
+export function sessionStateChangeHandler(state: SessionState): void {
+	if (state === 'started') {
+		console.log('Resetting the count');
+		// reset all session counts
+		sessionMessageCountMap = {};
+	}
+}
+
+export async function incrementMessageCounts(messageId: string): Promise<void> {
+	const { sessionCount, dailyCount, totalCount } = await getMessageCounts(
+		messageId
+	);
+	setSessionCount(messageId, sessionCount + 1);
+	setDailyCount(dailyCount + 1);
+	await setTotalCount(messageId, totalCount + 1);
+}
+
+function 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),
+		};
+	});
+}
+
+async function isBelowCap({
+	CampaignId,
+	SessionCap,
+	DailyCap,
+	TotalCap,
+}: PinpointInAppMessage): Promise<Boolean> {
+	const { sessionCount, dailyCount, totalCount } = await getMessageCounts(
+		CampaignId
+	);
+
+	return (
+		(!SessionCap || sessionCount < SessionCap) &&
+		(!DailyCap || dailyCount < DailyCap) &&
+		(!TotalCap || totalCount < TotalCap)
+	);
+}
+
+async function getMessageCounts(
+	messageId: string
+): Promise<InAppMessageCounts> {
+	try {
+		return {
+			sessionCount: getSessionCount(messageId),
+			dailyCount: await getDailyCount(),
+			totalCount: await getTotalCount(messageId),
+		};
+	} catch (err) {
+		logger.error('Failed to get message counts from storage', err);
+	}
+}
+
+function getSessionCount(messageId: string): number {
+	return sessionMessageCountMap[messageId] ?? 0;
+}
+
+function setSessionCount(messageId: string, count: number): void {
+	sessionMessageCountMap[messageId] = count;
+}
+
+function setDailyCount(count: number): void {
+	const dailyCount: DailyInAppMessageCounter = {
+		count,
+		lastCountTimestamp: getStartOfDay(),
+	};
+	try {
+		defaultStorage.setItem(MESSAGE_DAILY_COUNT_KEY, JSON.stringify(dailyCount));
+	} catch (err) {
+		logger.error('Failed to save daily message count to storage', err);
+	}
+}
+
+function setTotalCountMap(countMap: InAppMessageCountMap): void {
+	try {
+		defaultStorage.setItem(MESSAGE_TOTAL_COUNT_KEY, JSON.stringify(countMap));
+	} catch (err) {
+		logger.error('Failed to save total count to storage', err);
+	}
+}
+
+async function setTotalCount(messageId: string, count: number): Promise<void> {
+	const totalCountMap = await getTotalCountMap();
+	const updatedMap = {
+		...totalCountMap,
+		[messageId]: count,
+	};
+	setTotalCountMap(updatedMap);
+}
+
+async function getDailyCount(): Promise<number> {
+	const today = getStartOfDay();
+	const item = await defaultStorage.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;
+}
+
+async function getTotalCountMap(): Promise<InAppMessageCountMap> {
+	const item = await defaultStorage.getItem(MESSAGE_TOTAL_COUNT_KEY);
+	// Parse stored count map or initialize as empty
+	return item ? JSON.parse(item) : {};
+}
+
+async function getTotalCount(messageId: string): Promise<number> {
+	const countMap = await getTotalCountMap();
+	// Return stored count or initialize as empty count
+	return countMap[messageId] || 0;
+}
+
+const getStartOfDay = (): string => {
+	const now = new Date();
+	now.setHours(0, 0, 0, 0);
+	return now.toISOString();
+};

package/src/inAppMessaging/types/index.ts

@@ -5,4 +5,10 @@ export { InAppMessagingServiceOptions } from './options';
 export { InAppMessagingIdentifyUserInput } from './inputs';
 export { InAppMessagingConfig } from './config';
 export { InAppMessageInteractionEvent, InAppMessagingEvent } from './event';
-export { InAppMessage } from './message';
+export {
+	InAppMessage,
+	InAppMessageAction,
+	InAppMessageContent,
+	InAppMessageLayout,
+	InAppMessageTextAlign,
+} from './message';

package/src/inAppMessaging/utils/index.ts

@@ -0,0 +1,8 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export {
+	isInitialized,
+	assertIsInitialized,
+	initialize,
+} from './statusHelpers';