@aws-amplify/notifications 1.0.25 → 1.0.26-unstable.1116fef.4

package/src/PushNotification/utils.ts

@@ -0,0 +1,112 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { isEmpty } from 'lodash';
+
+import {
+	NormalizedValues,
+	PushNotificationMessage,
+	PushNotificationPermissionStatus,
+} from './types';
+
+const DEEP_LINK_ACTION = 'deeplink';
+const URL_ACTION = 'url';
+
+export const normalizeNativePermissionStatus = (
+	nativeStatus?
+): PushNotificationPermissionStatus => {
+	switch (nativeStatus) {
+		case 'ShouldRequest':
+			return PushNotificationPermissionStatus.SHOULD_REQUEST;
+		case 'NotDetermined':
+		case 'ShouldExplainThenRequest':
+			return PushNotificationPermissionStatus.SHOULD_EXPLAIN_THEN_REQUEST;
+		case 'Authorized':
+		case 'Granted':
+			return PushNotificationPermissionStatus.GRANTED;
+		case 'Denied':
+			return PushNotificationPermissionStatus.DENIED;
+	}
+};
+
+export const normalizeNativeMessage = (
+	nativeMessage?
+): PushNotificationMessage | null => {
+	let normalized: NormalizedValues;
+	if (nativeMessage?.aps) {
+		normalized = normalizeApnsMessage(nativeMessage);
+	}
+	if (nativeMessage?.rawData) {
+		normalized = normalizeFcmMessage(nativeMessage);
+	}
+	if (!normalized) {
+		return null;
+	}
+	const { body, imageUrl, title, action, options, data } = normalized;
+	return {
+		...(body && { body }),
+		...(imageUrl && { imageUrl }),
+		...(title && { title }),
+		...action,
+		...options,
+		...(!isEmpty(data) && { data }),
+	};
+};
+
+const normalizeApnsMessage = (apnsMessage): NormalizedValues => {
+	const { aps, data = {} } = apnsMessage;
+	const { body, title } = aps.alert ?? {};
+	const action = getApnsAction(data.pinpoint) ?? {};
+	const imageUrl = data['media-url'];
+	const options = getApnsOptions(apnsMessage);
+	return { body, imageUrl, title, action, options, data };
+};
+
+const normalizeFcmMessage = (fcmMessage): NormalizedValues => {
+	const { body, imageUrl, rawData: data, title } = fcmMessage;
+	const action = getFcmAction(fcmMessage.action) ?? {};
+	const options = getFcmOptions(fcmMessage);
+	return { body, imageUrl, title, action, options, data };
+};
+
+const getApnsAction = (
+	action = {}
+): Pick<PushNotificationMessage, 'deeplinkUrl'> => {
+	if (action[DEEP_LINK_ACTION]) {
+		return { deeplinkUrl: action[DEEP_LINK_ACTION] };
+	}
+};
+
+const getFcmAction = (
+	action = {}
+): Pick<PushNotificationMessage, 'goToUrl' | 'deeplinkUrl'> => {
+	if (action[URL_ACTION]) {
+		return { goToUrl: action[URL_ACTION] };
+	}
+	if (action[DEEP_LINK_ACTION]) {
+		return { deeplinkUrl: action[DEEP_LINK_ACTION] };
+	}
+};
+
+const getApnsOptions = ({
+	aps,
+}): Pick<PushNotificationMessage, 'apnsOptions'> => {
+	const { subtitle } = aps.alert ?? {};
+	const apnsOptions = { ...(subtitle && { subtitle }) };
+	return { ...(!isEmpty(apnsOptions) && { apnsOptions }) };
+};
+
+const getFcmOptions = ({
+	channelId,
+	messageId,
+	senderId,
+	sendTime,
+}): Pick<PushNotificationMessage, 'fcmOptions'> => {
+	const fcmOptions = {
+		...(channelId && { channelId }),
+		...(messageId && { messageId }),
+		...(senderId && { senderId }),
+		...(sendTime && { sendTime: new Date(sendTime) }),
+	};
+	return { ...(!isEmpty(fcmOptions) && { fcmOptions }) };
+};

package/src/common/AWSPinpointProviderCommon/index.ts

@@ -0,0 +1,295 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import {
+	ClientDevice,
+	ConsoleLogger,
+	Credentials,
+	getAmplifyUserAgent,
+	StorageHelper,
+	transferKeyToUpperCase,
+} from '@aws-amplify/core';
+import { Cache } from '@aws-amplify/cache';
+import {
+	Event as AWSPinpointAnalyticsEvent,
+	UpdateEndpointCommand,
+	UpdateEndpointCommandInput,
+	PinpointClient,
+	PutEventsCommand,
+	PutEventsCommandInput,
+} from '@aws-sdk/client-pinpoint';
+import { v4 as uuid } from 'uuid';
+
+import {
+	NotificationsCategory,
+	NotificationsSubCategory,
+	NotificationsProvider,
+	UserInfo,
+} from '../../types';
+import { AWSPinpointUserInfo } from './types';
+
+export default abstract class AWSPinpointProviderCommon
+	implements NotificationsProvider
+{
+	static category: NotificationsCategory = 'Notifications';
+	static providerName = 'AWSPinpoint';
+
+	protected clientInfo;
+	protected config: Record<string, any> = {};
+	protected endpointInitialized = false;
+	protected initialized = false;
+	protected logger: ConsoleLogger;
+
+	constructor(logger) {
+		this.config = { storage: new StorageHelper().getStorage() };
+		this.clientInfo = ClientDevice.clientInfo() ?? {};
+		this.logger = logger;
+	}
+
+	/**
+	 * get the category of the plugin
+	 */
+	getCategory() {
+		return AWSPinpointProviderCommon.category;
+	}
+
+	/**
+	 * get the sub-category of the plugin
+	 */
+	abstract getSubCategory(): NotificationsSubCategory;
+
+	/**
+	 * get provider name of the plugin
+	 */
+	getProviderName(): string {
+		return AWSPinpointProviderCommon.providerName;
+	}
+
+	configure(config = {}): Record<string, any> {
+		this.config = { ...this.config, ...config };
+		this.logger.debug(
+			`configure ${this.getProviderName()}${this.getSubCategory()}Provider`,
+			this.config
+		);
+		return this.config;
+	}
+
+	identifyUser = async (userId: string, userInfo: UserInfo): Promise<void> => {
+		if (!this.initialized) {
+			await this.init();
+		}
+		try {
+			await this.updateEndpoint(userId, userInfo);
+		} catch (err) {
+			this.logger.error('Error identifying user', err);
+			throw err;
+		}
+	};
+
+	protected init = async (): Promise<void> => {
+		const { endpointId, storage } = this.config;
+		const providerName = this.getProviderName();
+		try {
+			// Only run sync() if it's available (i.e. React Native)
+			if (typeof storage.sync === 'function') {
+				await storage.sync();
+			}
+			// If an endpoint was not provided via configuration, try to get it from cache
+			if (!endpointId) {
+				this.config.endpointId = await this.getEndpointId();
+			}
+			this.initialized = true;
+		} catch (err) {
+			this.logger.error(`Failed to initialize ${providerName}`, err);
+		}
+	};
+
+	protected recordAnalyticsEvent = async (
+		event: AWSPinpointAnalyticsEvent
+	): Promise<void> => {
+		const { appId, credentials, endpointId, pinpointClient } = this.config;
+		const currentCredentials = await this.getCredentials();
+		// Shallow compare to determine if credentials stored here are outdated
+		const credentialsUpdated =
+			!credentials ||
+			Object.keys(currentCredentials).some(
+				key => currentCredentials[key] !== credentials[key]
+			);
+		// Update credentials
+		this.config.credentials = currentCredentials;
+		try {
+			// Initialize a new pinpoint client if one isn't already configured or if credentials changed
+			if (!pinpointClient || credentialsUpdated) {
+				await this.initPinpointClient();
+			}
+			// Create the PutEvents input
+			const input: PutEventsCommandInput = {
+				ApplicationId: appId,
+				EventsRequest: {
+					BatchItem: {
+						[endpointId]: {
+							Endpoint: {},
+							Events: {
+								[uuid()]: event,
+							},
+						},
+					},
+				},
+			};
+			const command: PutEventsCommand = new PutEventsCommand(input);
+			this.logger.debug('recording analytics event');
+			await this.config.pinpointClient.send(command);
+		} catch (err) {
+			this.logger.error('Error recording analytics event', err);
+			throw err;
+		}
+	};
+
+	protected updateEndpoint = async (
+		userId: string = null,
+		userInfo: AWSPinpointUserInfo = null
+	): Promise<void> => {
+		const {
+			appId,
+			credentials,
+			endpointId,
+			endpointInfo = {},
+			pinpointClient,
+		} = this.config;
+		const currentCredentials = await this.getCredentials();
+		// Shallow compare to determine if credentials stored here are outdated
+		const credentialsUpdated =
+			!credentials ||
+			Object.keys(currentCredentials).some(
+				key => currentCredentials[key] !== credentials[key]
+			);
+		// If endpoint is already initialized, and nothing else is changing, just early return
+		if (
+			this.endpointInitialized &&
+			!credentialsUpdated &&
+			!userId &&
+			!userInfo
+		) {
+			return;
+		}
+		// Update credentials
+		this.config.credentials = currentCredentials;
+		try {
+			// Initialize a new pinpoint client if one isn't already configured or if credentials changed
+			if (!pinpointClient || credentialsUpdated) {
+				this.initPinpointClient();
+			}
+			const { address, attributes, demographic, location, metrics, optOut } =
+				userInfo ?? {};
+			const { appVersion, make, model, platform, version } = this.clientInfo;
+			// Create the UpdateEndpoint input, prioritizing passed in user info and falling back to
+			// defaults (if any) obtained from the config
+			const input: UpdateEndpointCommandInput = {
+				ApplicationId: appId,
+				EndpointId: endpointId,
+				EndpointRequest: {
+					RequestId: uuid(),
+					EffectiveDate: new Date().toISOString(),
+					ChannelType: endpointInfo.channelType,
+					Address: address ?? endpointInfo.address,
+					Attributes: {
+						...endpointInfo.attributes,
+						...attributes,
+					},
+					Demographic: {
+						AppVersion: appVersion,
+						Make: make,
+						Model: model,
+						ModelVersion: version,
+						Platform: platform,
+						...transferKeyToUpperCase({
+							...endpointInfo.demographic,
+							...demographic,
+						}),
+					},
+					Location: transferKeyToUpperCase({
+						...endpointInfo.location,
+						...location,
+					}),
+					Metrics: {
+						...endpointInfo.metrics,
+						...metrics,
+					},
+					OptOut: optOut ?? endpointInfo.optOut,
+					User: {
+						UserId:
+							userId ?? endpointInfo.userId ?? currentCredentials.identityId,
+						UserAttributes: attributes ?? endpointInfo.userAttributes,
+					},
+				},
+			};
+			const command: UpdateEndpointCommand = new UpdateEndpointCommand(input);
+			this.logger.debug('updating endpoint');
+			await this.config.pinpointClient.send(command);
+			this.endpointInitialized = true;
+		} catch (err) {
+			throw err;
+		}
+	};
+
+	private initPinpointClient = (): void => {
+		const { appId, credentials, pinpointClient, region } = this.config;
+
+		if (!appId || !credentials || !region) {
+			throw new Error(
+				'One or more of credentials, appId or region is not configured'
+			);
+		}
+
+		if (pinpointClient) {
+			pinpointClient.destroy();
+		}
+
+		this.config.pinpointClient = new PinpointClient({
+			region,
+			credentials,
+			customUserAgent: getAmplifyUserAgent(`/${this.getSubCategory()}`),
+		});
+	};
+
+	private getEndpointId = async (): Promise<string> => {
+		const { appId } = this.config;
+		// Each Pinpoint channel requires its own Endpoint ID
+		// However, Push will share the Analytics endpoint for now so as to not break existing customers
+		const cacheKey =
+			this.getSubCategory() === 'PushNotification'
+				? `${this.getProviderName()}_${appId}`
+				: `${this.getSubCategory()}:${this.getProviderName()}:${appId}`;
+		// First attempt to retrieve the ID from cache
+		const cachedEndpointId = await Cache.getItem(cacheKey);
+		// Found in cache, just return it
+		if (cachedEndpointId) {
+			return cachedEndpointId;
+		}
+		// Otherwise, generate a new ID and store it in long-lived cache before returning it
+		const endpointId = uuid();
+		// Set a longer TTL to avoid endpoint id being deleted after the default TTL (3 days)
+		// Also set its priority to the highest to reduce its chance of being deleted when cache is full
+		const ttl = 1000 * 60 * 60 * 24 * 365 * 100; // 100 years
+		const expiration = new Date().getTime() + ttl;
+		Cache.setItem(cacheKey, endpointId, {
+			expires: expiration,
+			priority: 1,
+		});
+		return endpointId;
+	};
+
+	private getCredentials = async () => {
+		try {
+			const credentials = await Credentials.get();
+			if (!credentials) {
+				this.logger.debug('no credentials found');
+				return null;
+			}
+			return Credentials.shear(credentials);
+		} catch (err) {
+			this.logger.error('Error getting credentials:', err);
+			return null;
+		}
+	};
+}

package/src/common/AWSPinpointProviderCommon/types.ts

@@ -0,0 +1,14 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { UserInfo } from '../../types';
+
+export interface AWSPinpointProviderConfig {
+	appId: string;
+	region: string;
+}
+
+export interface AWSPinpointUserInfo extends UserInfo {
+	address?: string;
+	optOut?: 'ALL' | 'NONE';
+}

package/src/common/constants.ts

@@ -0,0 +1,5 @@
+export const AMPLIFY_SYMBOL = (
+	typeof Symbol !== 'undefined' && typeof Symbol.for === 'function'
+		? Symbol.for('amplify_default')
+		: '@@amplify_default'
+) as Symbol;

package/src/common/eventListeners/index.ts

@@ -0,0 +1,44 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { EventListener, EventType } from './types';
+
+const eventListeners: Record<string, Set<EventListener<Function>>> = {};
+
+export const notifyEventListeners = (type: EventType, ...args: any[]): void => {
+	eventListeners[type]?.forEach(listener => {
+		listener.handleEvent(...args);
+	});
+};
+
+export const notifyEventListenersAndAwaitHandlers = (
+	type: EventType,
+	...args: any[]
+): Promise<void[]> =>
+	Promise.all<void>(
+		Array.from(eventListeners[type] ?? []).map(async listener => {
+			try {
+				await listener.handleEvent(...args);
+			} catch (err) {
+				throw err;
+			}
+		})
+	);
+
+export const addEventListener = <EventHandler extends Function>(
+	type: EventType,
+	handler: EventHandler
+): EventListener<EventHandler> => {
+	// If there is no listener set for the event type, just create it
+	if (!eventListeners[type]) {
+		eventListeners[type] = new Set<EventListener<EventHandler>>();
+	}
+	const listener = {
+		handleEvent: handler,
+		remove: () => {
+			eventListeners[type].delete(listener);
+		},
+	};
+	eventListeners[type].add(listener);
+	return listener;
+};

package/src/common/eventListeners/types.ts

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { InAppMessageInteractionEvent } from '../../InAppMessaging/types';
+import { PushNotificationEvent } from '../../PushNotification/types';
+
+export interface EventListener<EventHandler extends Function> {
+	handleEvent: EventHandler;
+	remove: () => void;
+}
+
+export type EventType = InAppMessageInteractionEvent | PushNotificationEvent;

package/src/common/index.ts

@@ -0,0 +1,11 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { default as AWSPinpointProviderCommon } from './AWSPinpointProviderCommon';
+export { AMPLIFY_SYMBOL } from './constants';
+export {
+	addEventListener,
+	notifyEventListeners,
+	notifyEventListenersAndAwaitHandlers,
+} from './eventListeners';
+export { EventListener, EventType } from './eventListeners/types';

package/src/index.ts

@@ -2,8 +2,10 @@
 // SPDX-License-Identifier: Apache-2.0
 
 export { default as Notifications } from './Notifications';
+
+export { AWSPinpointProviderCommon } from './common';
+export { AWSPinpointUserInfo } from './common/AWSPinpointProviderCommon/types';
 export {
-	AWSPinpointUserInfo,
 	InAppMessage,
 	InAppMessageAction,
 	InAppMessageButton,
@@ -15,6 +17,10 @@ export {
 	InAppMessageTextAlign,
 	InAppMessagingConfig,
 	InAppMessagingEvent,
-	UserInfo,
 } from './InAppMessaging';
-export { NotificationsConfig } from './types';
+export {
+	PushNotificationMessage,
+	PushNotificationPermissions,
+	PushNotificationPermissionStatus,
+} from './PushNotification/types';
+export { NotificationsConfig, UserInfo } from './types';

package/src/types.ts

@@ -1,11 +1,56 @@
 // Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
 // SPDX-License-Identifier: Apache-2.0
-import { InAppMessagingConfig } from './InAppMessaging';
+
+import { InAppMessagingConfig } from './InAppMessaging/types';
+import { PushNotificationConfig } from './PushNotification/types';
 
 export type NotificationsCategory = 'Notifications';
 
-export interface NotificationsConfig extends Record<any, any> {
+export type NotificationsSubCategory = 'InAppMessaging' | 'PushNotification';
+
+export interface NotificationsProvider {
+	// configure provider
+	configure(config: object): object;
+
+	// return category ('Notifications')
+	getCategory(): NotificationsCategory;
+
+	// return sub-category
+	getSubCategory(): NotificationsSubCategory;
+
+	// return the name of you provider
+	getProviderName(): string;
+
+	// identify the current user with the provider
+	identifyUser(userId: string, userInfo: UserInfo): Promise<void>;
+}
+
+export interface NotificationsConfig {
 	Notifications?: {
 		InAppMessaging?: InAppMessagingConfig;
+		PushNotification?: PushNotificationConfig;
 	};
 }
+
+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>;
+};