@aws-amplify/core 5.8.6-unstable.7762f1a.0 → 6.0.0

package/src/providers/pinpoint/apis/updateEndpoint.ts

@@ -0,0 +1,98 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { amplifyUuid } from '../../../utils/amplifyUuid';
+import { getClientInfo } from '../../../utils/getClientInfo';
+import {
+	updateEndpoint as clientUpdateEndpoint,
+	UpdateEndpointInput,
+} from '../../../awsClients/pinpoint';
+import { PinpointUpdateEndpointInput } from '../types';
+import { cacheEndpointId, getEndpointId } from '../utils';
+
+/**
+ * @internal
+ */
+export const updateEndpoint = async ({
+	address,
+	appId,
+	category,
+	channelType,
+	credentials,
+	identityId,
+	optOut,
+	region,
+	userAttributes,
+	userId,
+	userProfile,
+	userAgentValue,
+}: PinpointUpdateEndpointInput): Promise<void> => {
+	const endpointId = await getEndpointId(appId, category);
+	// only generate a new endpoint id if one was not found in cache
+	const createdEndpointId = !endpointId ? amplifyUuid() : undefined;
+	const {
+		customProperties,
+		demographic,
+		email,
+		location,
+		metrics,
+		name,
+		plan,
+	} = userProfile ?? {};
+	const clientInfo = getClientInfo();
+	const mergedDemographic = {
+		appVersion: clientInfo.appVersion,
+		make: clientInfo.make,
+		model: clientInfo.model,
+		modelVersion: clientInfo.version,
+		platform: clientInfo.platform,
+		...demographic,
+	};
+	const shouldAddAttributes = email || customProperties || name || plan;
+	const attributes = {
+		...(email && { email: [email] }),
+		...(name && { name: [name] }),
+		...(plan && { plan: [plan] }),
+		...customProperties,
+	};
+	const input: UpdateEndpointInput = {
+		ApplicationId: appId,
+		EndpointId: endpointId ?? createdEndpointId,
+		EndpointRequest: {
+			RequestId: amplifyUuid(),
+			EffectiveDate: new Date().toISOString(),
+			ChannelType: channelType,
+			Address: address,
+			Attributes: shouldAddAttributes ? attributes : undefined,
+			Demographic: {
+				AppVersion: mergedDemographic.appVersion,
+				Locale: mergedDemographic.locale,
+				Make: mergedDemographic.make,
+				Model: mergedDemographic.model,
+				ModelVersion: mergedDemographic.modelVersion,
+				Platform: mergedDemographic.platform,
+				PlatformVersion: mergedDemographic.platformVersion,
+				Timezone: mergedDemographic.timezone,
+			},
+			Location: {
+				City: location?.city,
+				Country: location?.country,
+				Latitude: location?.latitude,
+				Longitude: location?.longitude,
+				PostalCode: location?.postalCode,
+				Region: location?.region,
+			},
+			Metrics: metrics,
+			OptOut: optOut,
+			User: {
+				UserId: userId ?? identityId,
+				UserAttributes: userAttributes,
+			},
+		},
+	};
+	await clientUpdateEndpoint({ credentials, region, userAgentValue }, input);
+	// if we had to create an endpoint id, we need to now cache it
+	if (!!createdEndpointId) {
+		return cacheEndpointId(appId, category, createdEndpointId);
+	}
+};

package/src/providers/pinpoint/index.ts

@@ -0,0 +1,10 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export * from './apis';
+export {
+	PinpointAnalyticsEvent,
+	PinpointServiceOptions,
+	UpdateEndpointException,
+} from './types';
+export { resolveEndpointId } from './utils';

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

@@ -0,0 +1,32 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AuthSession } from '../../../singleton/Auth/types';
+import { PinpointAnalyticsEvent, PinpointSession } from './pinpoint';
+
+export type EventBufferConfig = {
+	appId: string;
+	bufferSize: number;
+	credentials: Required<AuthSession>['credentials'];
+	identityId: AuthSession['identityId'];
+	flushInterval: number;
+	flushSize: number;
+	region: string;
+	resendLimit: number;
+	userAgentValue?: string;
+};
+
+export type BufferedEvent = {
+	endpointId: string;
+	eventId: string;
+	event: PinpointAnalyticsEvent;
+	session: PinpointSession;
+	timestamp: string;
+	resendLimit: number;
+};
+
+export type BufferedEventMap = {
+	[key: string]: BufferedEvent;
+};
+
+export type EventBuffer = Array<BufferedEventMap>;

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

@@ -0,0 +1,12 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export enum UpdateEndpointException {
+	BadRequestException = 'BadRequestException',
+	ForbiddenException = 'ForbiddenException',
+	InternalServerErrorException = 'InternalServerErrorException',
+	MethodNotAllowedException = 'MethodNotAllowedException',
+	NotFoundException = 'NotFoundException',
+	PayloadTooLargeException = 'PayloadTooLargeException',
+	TooManyRequestsException = 'TooManyRequestsException',
+}

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

@@ -0,0 +1,5 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { UpdateEndpointException } from './errors';
+export * from './pinpoint';

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

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { AuthSession } from '../../../singleton/Auth/types';
+import { UserProfile } from '../../../types';
+
+export type SupportedCategory =
+	| 'Analytics'
+	| 'Core'
+	| 'InAppMessaging'
+	| 'PushNotification';
+
+type SupportedChannelType = 'APNS' | 'APNS_SANDBOX' | 'GCM' | 'IN_APP';
+
+export type PinpointProviderConfig = {
+	Pinpoint: {
+		appId: string;
+		region: string;
+	};
+};
+
+export type PinpointServiceOptions = {
+	address?: string;
+	optOut?: 'ALL' | 'NONE';
+	userAttributes?: Record<string, string[]>;
+};
+
+export type PinpointSession = {
+	Id: string;
+	Duration?: number;
+	StartTimestamp: string;
+	StopTimestamp?: string;
+};
+
+export type PinpointAnalyticsEvent = {
+	name: string;
+	attributes?: Record<string, string>;
+	metrics?: Record<string, number>;
+};
+
+// Common type that is required for operations that may trigger an endpoint update
+type PinpointCommonParameters = {
+	appId: string;
+	category: SupportedCategory;
+	channelType?: SupportedChannelType;
+	credentials: Required<AuthSession>['credentials'];
+	identityId?: AuthSession['identityId'];
+	region: string;
+	userAgentValue?: string;
+};
+
+export type PinpointUpdateEndpointInput = PinpointCommonParameters &
+	PinpointServiceOptions & {
+		userId?: string;
+		userProfile?: UserProfile;
+	};
+
+export type PinpointRecordInput = PinpointCommonParameters & {
+	event: PinpointAnalyticsEvent;
+};

package/src/providers/pinpoint/utils/PinpointEventBuffer.ts

@@ -0,0 +1,256 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { ConsoleLogger as Logger } from '../../../Logger';
+import {
+	EventsBatch,
+	putEvents,
+	PutEventsInput,
+	PutEventsOutput,
+} from '../../../awsClients/pinpoint';
+import {
+	EventBufferConfig,
+	BufferedEvent,
+	BufferedEventMap,
+	EventBuffer,
+} from '../types/buffer';
+import { AuthSession } from '../../../singleton/Auth/types';
+import { isAppInForeground } from './isAppInForeground';
+
+const logger = new Logger('PinpointEventBuffer');
+const RETRYABLE_CODES = [429, 500];
+const ACCEPTED_CODES = [202];
+
+export class PinpointEventBuffer {
+	private _config: EventBufferConfig;
+	private _interval: ReturnType<typeof setInterval> | undefined = undefined;
+	private _buffer: EventBuffer;
+	private _pause = false;
+	private _flush = false;
+
+	constructor(config: EventBufferConfig) {
+		this._buffer = [];
+		this._config = config;
+
+		this._sendBatch = this._sendBatch.bind(this);
+
+		this._startLoop();
+	}
+
+	public push(event: BufferedEvent) {
+		if (this._buffer.length >= this._config.bufferSize) {
+			logger.debug('Exceeded Pinpoint event buffer limits, event dropped.', {
+				eventId: event.eventId,
+			});
+
+			return;
+		}
+
+		this._buffer.push({ [event.eventId]: event });
+	}
+
+	public pause() {
+		this._pause = true;
+	}
+
+	public resume() {
+		this._pause = false;
+	}
+
+	public flush() {
+		this._flush = true;
+	}
+
+	public identityHasChanged(identityId: AuthSession['identityId']) {
+		return this._config.identityId !== identityId;
+	}
+
+	public flushAll() {
+		this._putEvents(this._buffer.splice(0, this._buffer.length));
+	}
+
+	private _startLoop() {
+		if (this._interval) {
+			clearInterval(this._interval);
+		}
+
+		const { flushInterval } = this._config;
+
+		this._interval = setInterval(this._sendBatch, flushInterval);
+	}
+
+	private _sendBatch() {
+		const bufferLength = this._buffer.length;
+
+		if (this._flush && !bufferLength && this._interval) {
+			clearInterval(this._interval);
+		}
+
+		if (this._pause || !bufferLength || !isAppInForeground()) {
+			return;
+		}
+
+		const { flushSize } = this._config;
+
+		const batchSize = Math.min(flushSize, bufferLength);
+		const bufferSubset = this._buffer.splice(0, batchSize);
+
+		this._putEvents(bufferSubset);
+	}
+
+	private async _putEvents(buffer: EventBuffer) {
+		const eventMap: BufferedEventMap = this._bufferToMap(buffer);
+		const batchEventParams = this._generateBatchEventParams(eventMap);
+
+		try {
+			const { credentials, region, userAgentValue } = this._config;
+			const data: PutEventsOutput = await putEvents(
+				{
+					credentials,
+					region,
+					userAgentValue,
+				},
+				batchEventParams
+			);
+			this._processPutEventsSuccessResponse(data, eventMap);
+		} catch (err) {
+			return this._handlePutEventsFailure(err, eventMap);
+		}
+	}
+
+	private _generateBatchEventParams(
+		eventMap: BufferedEventMap
+	): PutEventsInput {
+		const batchItem: Record<string, EventsBatch> = {};
+
+		Object.values(eventMap).forEach(item => {
+			const { event, timestamp, endpointId, eventId, session } = item;
+			const { name, attributes, metrics } = event;
+
+			batchItem[endpointId] = {
+				Endpoint: {
+					...batchItem[endpointId]?.Endpoint,
+				},
+				Events: {
+					...batchItem[endpointId]?.Events,
+					[eventId]: {
+						EventType: name,
+						Timestamp: new Date(timestamp).toISOString(),
+						Attributes: attributes,
+						Metrics: metrics,
+						Session: session,
+					},
+				},
+			};
+		});
+
+		return {
+			ApplicationId: this._config.appId,
+			EventsRequest: {
+				BatchItem: batchItem,
+			},
+		};
+	}
+
+	private _handlePutEventsFailure(err: any, eventMap: BufferedEventMap) {
+		logger.debug('putEvents call to Pinpoint failed.', err);
+		const statusCode = err.$metadata && err.$metadata.httpStatusCode;
+
+		if (RETRYABLE_CODES.includes(statusCode)) {
+			const retryableEvents = Object.values(eventMap);
+			this._retry(retryableEvents);
+			return;
+		}
+	}
+
+	private _processPutEventsSuccessResponse(
+		data: PutEventsOutput,
+		eventMap: BufferedEventMap
+	) {
+		const { Results = {} } = data.EventsResponse ?? {};
+		const retryableEvents: BufferedEvent[] = [];
+
+		Object.entries(Results).forEach(([endpointId, endpointValues]) => {
+			const responses = endpointValues.EventsItemResponse ?? {};
+
+			Object.entries(responses).forEach(([eventId, eventValues]) => {
+				const eventObject = eventMap[eventId];
+				if (!eventObject) {
+					return;
+				}
+
+				const { StatusCode, Message } = eventValues ?? {};
+
+				// manually crafting handlers response to keep API consistant
+				const response = {
+					EventsResponse: {
+						Results: {
+							[endpointId]: {
+								EventsItemResponse: {
+									[eventId]: { StatusCode, Message },
+								},
+							},
+						},
+					},
+				};
+
+				if (StatusCode && ACCEPTED_CODES.includes(StatusCode)) {
+					return;
+				}
+
+				if (StatusCode && RETRYABLE_CODES.includes(StatusCode)) {
+					retryableEvents.push(eventObject);
+					return;
+				}
+
+				const { name } = eventObject.event;
+
+				logger.warn('Pinpoint event failed to send.', {
+					eventId,
+					name,
+					message: Message,
+				});
+			});
+		});
+
+		if (retryableEvents.length) {
+			this._retry(retryableEvents);
+		}
+	}
+
+	private _retry(retryableEvents: BufferedEvent[]) {
+		// retryable events that haven't reached the resendLimit
+		const eligibleEvents: EventBuffer = [];
+
+		retryableEvents.forEach((bufferedEvent: BufferedEvent) => {
+			const { eventId } = bufferedEvent;
+			const { name } = bufferedEvent.event;
+
+			if (bufferedEvent!.resendLimit!-- > 0) {
+				logger.debug('Resending event.', {
+					eventId,
+					name,
+					remainingAttempts: bufferedEvent.resendLimit,
+				});
+				eligibleEvents.push({ [eventId!]: bufferedEvent });
+				return;
+			}
+
+			logger.debug('No retry attempts remaining for event.', {
+				eventId,
+				name,
+			});
+		});
+
+		// add the events to the front of the buffer
+		this._buffer.unshift(...eligibleEvents);
+	}
+
+	private _bufferToMap(buffer: EventBuffer) {
+		return buffer.reduce((acc, curVal) => {
+			const [[key, value]] = Object.entries(curVal);
+			acc[key] = value;
+			return acc;
+		}, {});
+	}
+}

package/src/providers/pinpoint/utils/cacheEndpointId.ts

@@ -0,0 +1,27 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Cache } from '../../..';
+import { SupportedCategory } from '../types';
+import { getCacheKey } from './getCacheKey';
+
+/**
+ * Writes an endpoint id to a long-lived cache.
+ *
+ * @internal
+ */
+export const cacheEndpointId = async (
+	appId: string,
+	category: SupportedCategory,
+	endpointId: string
+): Promise<void> => {
+	const cacheKey = getCacheKey(appId, category);
+	// 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;
+	return Cache.setItem(cacheKey, endpointId, {
+		expires: expiration,
+		priority: 1,
+	});
+};

package/src/providers/pinpoint/utils/constants.ts

@@ -0,0 +1,8 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// Default buffer constants
+export const BUFFER_SIZE = 1000;
+export const FLUSH_SIZE = 100;
+export const FLUSH_INTERVAL = 5 * 1000; // 5s
+export const RESEND_LIMIT = 5;

package/src/providers/pinpoint/utils/getCacheKey.ts

@@ -0,0 +1,16 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { SupportedCategory } from '../types';
+
+const PROVIDER_NAME = 'pinpoint';
+
+/**
+ * Returns a unique cache key for a particular category/appId combination.
+ *
+ * @internal
+ */
+export const getCacheKey = (
+	appId: string,
+	category: SupportedCategory
+): string => `${category}:${PROVIDER_NAME}:${appId}`;

package/src/providers/pinpoint/utils/getEndpointId.ts

@@ -0,0 +1,20 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { Cache } from '../../..';
+import { SupportedCategory } from '../types';
+import { getCacheKey } from './getCacheKey';
+
+/**
+ * Returns an endpoint id from cache or `undefined` if not found.
+ *
+ * @internal
+ */
+export const getEndpointId = async (
+	appId: string,
+	category: SupportedCategory
+): Promise<string | undefined> => {
+	const cacheKey = getCacheKey(appId, category);
+	const cachedEndpointId = await Cache.getItem(cacheKey);
+	return cachedEndpointId ?? undefined;
+};

package/src/providers/pinpoint/utils/getEventBuffer.ts

@@ -0,0 +1,60 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { EventBufferConfig } from '../types/buffer';
+import { PinpointEventBuffer } from './PinpointEventBuffer';
+import { BUFFER_SIZE, FLUSH_INTERVAL, FLUSH_SIZE, RESEND_LIMIT } from './constants';
+
+// Map of buffers by region -> appId
+const eventBufferMap: Record<string, Record<string, PinpointEventBuffer>> = {};
+
+/**
+ * Returns a PinpointEventBuffer instance for the specified region & app ID, creating one if it does not yet exist.
+ * 
+ * @internal
+ */
+export const getEventBuffer = ({
+	appId,
+	bufferSize = BUFFER_SIZE,
+	credentials,
+	flushInterval = FLUSH_INTERVAL,
+	flushSize = FLUSH_SIZE,
+	identityId,
+	region,
+	resendLimit = RESEND_LIMIT,
+	userAgentValue
+}: EventBufferConfig): PinpointEventBuffer => {
+	if (eventBufferMap[region]?.[appId]) {
+		const buffer = eventBufferMap[region][appId];
+
+		/*
+		If the identity has changed flush out the buffer and create a new instance. The old instance will be garbage 
+		collected.
+		*/
+		if (buffer.identityHasChanged(identityId)) {
+			buffer.flush();
+		} else {
+			return buffer;
+		}
+	}
+
+	const buffer = new PinpointEventBuffer({
+		appId,
+		bufferSize,
+		credentials,
+		flushInterval,
+		flushSize,
+		identityId,
+		region,
+		resendLimit,
+		userAgentValue
+	});
+
+	if (!eventBufferMap[region]) {
+		eventBufferMap[region] = {};
+	}
+
+	eventBufferMap[region][appId] = buffer;
+
+	return buffer;
+};

package/src/providers/pinpoint/utils/index.ts

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export { cacheEndpointId } from './cacheEndpointId';
+export { getCacheKey } from './getCacheKey';
+export { getEndpointId } from './getEndpointId';
+export { resolveEndpointId } from './resolveEndpointId';

package/src/providers/pinpoint/utils/isAppInForeground.native.ts

@@ -0,0 +1,7 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+// @ts-ignore: missing type definition
+import { AppState } from 'react-native';
+
+export const isAppInForeground = () => AppState.currentState === 'active';

package/src/providers/pinpoint/utils/isAppInForeground.ts

@@ -0,0 +1,4 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+export const isAppInForeground = () => true;

package/src/providers/pinpoint/utils/resolveEndpointId.ts

@@ -0,0 +1,46 @@
+// Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+// SPDX-License-Identifier: Apache-2.0
+
+import { assert } from '../../../errors';
+import { AmplifyErrorCode } from '../../../types';
+import { updateEndpoint } from '../apis';
+import { PinpointUpdateEndpointInput } from '../types';
+import { getEndpointId } from './getEndpointId';
+
+/**
+ * Resolves an endpoint id from cache or prepare via updateEndpoint if one does not already exist,
+ * which will generate and cache an endpoint id between calls.
+ *
+ * @internal
+ */
+export const resolveEndpointId = async ({
+	address,
+	appId,
+	category,
+	channelType,
+	credentials,
+	identityId,
+	region,
+	userAgentValue,
+}: PinpointUpdateEndpointInput) => {
+	let endpointId = await getEndpointId(appId, category);
+
+	if (!endpointId) {
+		await updateEndpoint({
+			address,
+			appId,
+			category,
+			channelType,
+			credentials,
+			identityId,
+			region,
+			userAgentValue,
+		});
+
+		endpointId = await getEndpointId(appId, category);
+	}
+
+	assert(!!endpointId, AmplifyErrorCode.NoEndpointId);
+
+	return endpointId;
+};

package/src/server.ts

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